kacrab_protocol/generated/
incremental_alter_configs_request.rs

1//! Generated from IncrementalAlterConfigsRequest.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 IncrementalAlterConfigsRequestData {
17    /// The incremental 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 IncrementalAlterConfigsRequestData {
24    fn default() -> Self {
25        Self {
26            resources: Vec::new(),
27            validate_only: false,
28            _unknown_tagged_fields: Vec::new(),
29        }
30    }
31}
32impl IncrementalAlterConfigsRequestData {
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 > 1 {
43            return Err(UnsupportedVersion::new(44, version).into());
44        }
45        let resources;
46        let validate_only;
47        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
48        if version >= 1 {
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 >= 1 {
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 > 1 {
86            return Err(UnsupportedVersion::new(44, version).into());
87        }
88        if version >= 1 {
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 >= 1 {
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 > 1 {
109            return Err(UnsupportedVersion::new(44, version).into());
110        }
111        let mut len: usize = 0;
112        if version >= 1 {
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 >= 1 {
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 >= 1 {
172            resource_name = read_compact_string(buf)?;
173        } else {
174            resource_name = read_string(buf)?;
175        }
176        if version >= 1 {
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 >= 1 {
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 >= 1 {
215            write_compact_string(buf, &self.resource_name)?;
216        } else {
217            write_string(buf, &self.resource_name)?;
218        }
219        if version >= 1 {
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 >= 1 {
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 >= 1 {
241            len += compact_string_len(&self.resource_name)?;
242        } else {
243            len += string_len(&self.resource_name)?;
244        }
245        if version >= 1 {
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 >= 1 {
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 type (Set, Delete, Append, Subtract) of operation.
269    pub config_operation: i8,
270    /// The value to set for the configuration key.
271    pub value: Option<KafkaString>,
272    pub _unknown_tagged_fields: Vec<RawTaggedField>,
273}
274impl Default for AlterableConfig {
275    fn default() -> Self {
276        Self {
277            name: KafkaString::default(),
278            config_operation: 0_i8,
279            value: None,
280            _unknown_tagged_fields: Vec::new(),
281        }
282    }
283}
284impl AlterableConfig {
285    pub fn with_name(mut self, value: KafkaString) -> Self {
286        self.name = value;
287        self
288    }
289    pub fn with_config_operation(mut self, value: i8) -> Self {
290        self.config_operation = value;
291        self
292    }
293    pub fn with_value(mut self, value: Option<KafkaString>) -> Self {
294        self.value = value;
295        self
296    }
297    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
298        let name;
299        let config_operation;
300        let value;
301        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
302        if version >= 1 {
303            name = read_compact_string(buf)?;
304        } else {
305            name = read_string(buf)?;
306        }
307        config_operation = read_i8(buf)?;
308        if version >= 1 {
309            value = read_compact_nullable_string(buf)?;
310        } else {
311            value = read_nullable_string(buf)?;
312        }
313        if version >= 1 {
314            let tagged_fields = read_tagged_fields(buf)?;
315            for field in &tagged_fields {
316                match field.tag {
317                    _ => {
318                        _unknown_tagged_fields.push(field.clone());
319                    },
320                }
321            }
322        }
323        Ok(Self {
324            name,
325            config_operation,
326            value,
327            _unknown_tagged_fields,
328        })
329    }
330    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
331        if version >= 1 {
332            write_compact_string(buf, &self.name)?;
333        } else {
334            write_string(buf, &self.name)?;
335        }
336        write_i8(buf, self.config_operation);
337        if version >= 1 {
338            write_compact_nullable_string(buf, self.value.as_ref())?;
339        } else {
340            write_nullable_string(buf, self.value.as_ref())?;
341        }
342        if version >= 1 {
343            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
344            all_tags.sort_by_key(|f| f.tag);
345            write_tagged_fields(buf, &all_tags)?;
346        }
347        Ok(())
348    }
349    pub fn encoded_len(&self, version: i16) -> Result<usize> {
350        let mut len: usize = 0;
351        if version >= 1 {
352            len += compact_string_len(&self.name)?;
353        } else {
354            len += string_len(&self.name)?;
355        }
356        len += 1;
357        if version >= 1 {
358            len += compact_nullable_string_len(self.value.as_ref())?;
359        } else {
360            len += nullable_string_len(self.value.as_ref())?;
361        }
362        if version >= 1 {
363            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
364            all_tags.sort_by_key(|f| f.tag);
365            len += tagged_fields_len(&all_tags)?;
366        }
367        Ok(len)
368    }
369}
kacrab_protocol/generated/incremental_alter_configs_request.rs

kacrab_protocol/generated/
incremental_alter_configs_request.rs
