kafka_protocol/messages/
incremental_alter_configs_request.rs

1//! IncrementalAlterConfigsRequest
2//!
3//! See the schema for this message [here](https://github.com/apache/kafka/blob/trunk/clients/src/main/resources/common/message/IncrementalAlterConfigsRequest.json).
4// WARNING: the items of this module are generated and should not be edited directly
5#![allow(unused)]
6
7use std::borrow::Borrow;
8use std::collections::BTreeMap;
9
10use anyhow::{bail, Result};
11use bytes::Bytes;
12use uuid::Uuid;
13
14use crate::protocol::{
15    buf::{ByteBuf, ByteBufMut},
16    compute_unknown_tagged_fields_size, types, write_unknown_tagged_fields, Decodable, Decoder,
17    Encodable, Encoder, HeaderVersion, Message, StrBytes, VersionRange,
18};
19
20/// Valid versions: 0-1
21#[non_exhaustive]
22#[derive(Debug, Clone, PartialEq)]
23pub struct AlterConfigsResource {
24    /// The resource type.
25    ///
26    /// Supported API versions: 0-1
27    pub resource_type: i8,
28
29    /// The resource name.
30    ///
31    /// Supported API versions: 0-1
32    pub resource_name: StrBytes,
33
34    /// The configurations.
35    ///
36    /// Supported API versions: 0-1
37    pub configs: Vec<AlterableConfig>,
38
39    /// Other tagged fields
40    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
41}
42
43impl AlterConfigsResource {
44    /// Sets `resource_type` to the passed value.
45    ///
46    /// The resource type.
47    ///
48    /// Supported API versions: 0-1
49    pub fn with_resource_type(mut self, value: i8) -> Self {
50        self.resource_type = value;
51        self
52    }
53    /// Sets `resource_name` to the passed value.
54    ///
55    /// The resource name.
56    ///
57    /// Supported API versions: 0-1
58    pub fn with_resource_name(mut self, value: StrBytes) -> Self {
59        self.resource_name = value;
60        self
61    }
62    /// Sets `configs` to the passed value.
63    ///
64    /// The configurations.
65    ///
66    /// Supported API versions: 0-1
67    pub fn with_configs(mut self, value: Vec<AlterableConfig>) -> Self {
68        self.configs = value;
69        self
70    }
71    /// Sets unknown_tagged_fields to the passed value.
72    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
73        self.unknown_tagged_fields = value;
74        self
75    }
76    /// Inserts an entry into unknown_tagged_fields.
77    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
78        self.unknown_tagged_fields.insert(key, value);
79        self
80    }
81}
82
83#[cfg(feature = "client")]
84impl Encodable for AlterConfigsResource {
85    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
86        if version < 0 || version > 1 {
87            bail!("specified version not supported by this message type");
88        }
89        types::Int8.encode(buf, &self.resource_type)?;
90        if version >= 1 {
91            types::CompactString.encode(buf, &self.resource_name)?;
92        } else {
93            types::String.encode(buf, &self.resource_name)?;
94        }
95        if version >= 1 {
96            types::CompactArray(types::Struct { version }).encode(buf, &self.configs)?;
97        } else {
98            types::Array(types::Struct { version }).encode(buf, &self.configs)?;
99        }
100        if version >= 1 {
101            let num_tagged_fields = self.unknown_tagged_fields.len();
102            if num_tagged_fields > std::u32::MAX as usize {
103                bail!(
104                    "Too many tagged fields to encode ({} fields)",
105                    num_tagged_fields
106                );
107            }
108            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
109
110            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
111        }
112        Ok(())
113    }
114    fn compute_size(&self, version: i16) -> Result<usize> {
115        let mut total_size = 0;
116        total_size += types::Int8.compute_size(&self.resource_type)?;
117        if version >= 1 {
118            total_size += types::CompactString.compute_size(&self.resource_name)?;
119        } else {
120            total_size += types::String.compute_size(&self.resource_name)?;
121        }
122        if version >= 1 {
123            total_size +=
124                types::CompactArray(types::Struct { version }).compute_size(&self.configs)?;
125        } else {
126            total_size += types::Array(types::Struct { version }).compute_size(&self.configs)?;
127        }
128        if version >= 1 {
129            let num_tagged_fields = self.unknown_tagged_fields.len();
130            if num_tagged_fields > std::u32::MAX as usize {
131                bail!(
132                    "Too many tagged fields to encode ({} fields)",
133                    num_tagged_fields
134                );
135            }
136            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
137
138            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
139        }
140        Ok(total_size)
141    }
142}
143
144#[cfg(feature = "broker")]
145impl Decodable for AlterConfigsResource {
146    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
147        if version < 0 || version > 1 {
148            bail!("specified version not supported by this message type");
149        }
150        let resource_type = types::Int8.decode(buf)?;
151        let resource_name = if version >= 1 {
152            types::CompactString.decode(buf)?
153        } else {
154            types::String.decode(buf)?
155        };
156        let configs = if version >= 1 {
157            types::CompactArray(types::Struct { version }).decode(buf)?
158        } else {
159            types::Array(types::Struct { version }).decode(buf)?
160        };
161        let mut unknown_tagged_fields = BTreeMap::new();
162        if version >= 1 {
163            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
164            for _ in 0..num_tagged_fields {
165                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
166                let size: u32 = types::UnsignedVarInt.decode(buf)?;
167                let unknown_value = buf.try_get_bytes(size as usize)?;
168                unknown_tagged_fields.insert(tag as i32, unknown_value);
169            }
170        }
171        Ok(Self {
172            resource_type,
173            resource_name,
174            configs,
175            unknown_tagged_fields,
176        })
177    }
178}
179
180impl Default for AlterConfigsResource {
181    fn default() -> Self {
182        Self {
183            resource_type: 0,
184            resource_name: Default::default(),
185            configs: Default::default(),
186            unknown_tagged_fields: BTreeMap::new(),
187        }
188    }
189}
190
191impl Message for AlterConfigsResource {
192    const VERSIONS: VersionRange = VersionRange { min: 0, max: 1 };
193    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
194}
195
196/// Valid versions: 0-1
197#[non_exhaustive]
198#[derive(Debug, Clone, PartialEq)]
199pub struct AlterableConfig {
200    /// The configuration key name.
201    ///
202    /// Supported API versions: 0-1
203    pub name: StrBytes,
204
205    /// The type (Set, Delete, Append, Subtract) of operation.
206    ///
207    /// Supported API versions: 0-1
208    pub config_operation: i8,
209
210    /// The value to set for the configuration key.
211    ///
212    /// Supported API versions: 0-1
213    pub value: Option<StrBytes>,
214
215    /// Other tagged fields
216    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
217}
218
219impl AlterableConfig {
220    /// Sets `name` to the passed value.
221    ///
222    /// The configuration key name.
223    ///
224    /// Supported API versions: 0-1
225    pub fn with_name(mut self, value: StrBytes) -> Self {
226        self.name = value;
227        self
228    }
229    /// Sets `config_operation` to the passed value.
230    ///
231    /// The type (Set, Delete, Append, Subtract) of operation.
232    ///
233    /// Supported API versions: 0-1
234    pub fn with_config_operation(mut self, value: i8) -> Self {
235        self.config_operation = value;
236        self
237    }
238    /// Sets `value` to the passed value.
239    ///
240    /// The value to set for the configuration key.
241    ///
242    /// Supported API versions: 0-1
243    pub fn with_value(mut self, value: Option<StrBytes>) -> Self {
244        self.value = value;
245        self
246    }
247    /// Sets unknown_tagged_fields to the passed value.
248    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
249        self.unknown_tagged_fields = value;
250        self
251    }
252    /// Inserts an entry into unknown_tagged_fields.
253    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
254        self.unknown_tagged_fields.insert(key, value);
255        self
256    }
257}
258
259#[cfg(feature = "client")]
260impl Encodable for AlterableConfig {
261    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
262        if version < 0 || version > 1 {
263            bail!("specified version not supported by this message type");
264        }
265        if version >= 1 {
266            types::CompactString.encode(buf, &self.name)?;
267        } else {
268            types::String.encode(buf, &self.name)?;
269        }
270        types::Int8.encode(buf, &self.config_operation)?;
271        if version >= 1 {
272            types::CompactString.encode(buf, &self.value)?;
273        } else {
274            types::String.encode(buf, &self.value)?;
275        }
276        if version >= 1 {
277            let num_tagged_fields = self.unknown_tagged_fields.len();
278            if num_tagged_fields > std::u32::MAX as usize {
279                bail!(
280                    "Too many tagged fields to encode ({} fields)",
281                    num_tagged_fields
282                );
283            }
284            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
285
286            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
287        }
288        Ok(())
289    }
290    fn compute_size(&self, version: i16) -> Result<usize> {
291        let mut total_size = 0;
292        if version >= 1 {
293            total_size += types::CompactString.compute_size(&self.name)?;
294        } else {
295            total_size += types::String.compute_size(&self.name)?;
296        }
297        total_size += types::Int8.compute_size(&self.config_operation)?;
298        if version >= 1 {
299            total_size += types::CompactString.compute_size(&self.value)?;
300        } else {
301            total_size += types::String.compute_size(&self.value)?;
302        }
303        if version >= 1 {
304            let num_tagged_fields = self.unknown_tagged_fields.len();
305            if num_tagged_fields > std::u32::MAX as usize {
306                bail!(
307                    "Too many tagged fields to encode ({} fields)",
308                    num_tagged_fields
309                );
310            }
311            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
312
313            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
314        }
315        Ok(total_size)
316    }
317}
318
319#[cfg(feature = "broker")]
320impl Decodable for AlterableConfig {
321    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
322        if version < 0 || version > 1 {
323            bail!("specified version not supported by this message type");
324        }
325        let name = if version >= 1 {
326            types::CompactString.decode(buf)?
327        } else {
328            types::String.decode(buf)?
329        };
330        let config_operation = types::Int8.decode(buf)?;
331        let value = if version >= 1 {
332            types::CompactString.decode(buf)?
333        } else {
334            types::String.decode(buf)?
335        };
336        let mut unknown_tagged_fields = BTreeMap::new();
337        if version >= 1 {
338            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
339            for _ in 0..num_tagged_fields {
340                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
341                let size: u32 = types::UnsignedVarInt.decode(buf)?;
342                let unknown_value = buf.try_get_bytes(size as usize)?;
343                unknown_tagged_fields.insert(tag as i32, unknown_value);
344            }
345        }
346        Ok(Self {
347            name,
348            config_operation,
349            value,
350            unknown_tagged_fields,
351        })
352    }
353}
354
355impl Default for AlterableConfig {
356    fn default() -> Self {
357        Self {
358            name: Default::default(),
359            config_operation: 0,
360            value: Some(Default::default()),
361            unknown_tagged_fields: BTreeMap::new(),
362        }
363    }
364}
365
366impl Message for AlterableConfig {
367    const VERSIONS: VersionRange = VersionRange { min: 0, max: 1 };
368    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
369}
370
371/// Valid versions: 0-1
372#[non_exhaustive]
373#[derive(Debug, Clone, PartialEq)]
374pub struct IncrementalAlterConfigsRequest {
375    /// The incremental updates for each resource.
376    ///
377    /// Supported API versions: 0-1
378    pub resources: Vec<AlterConfigsResource>,
379
380    /// True if we should validate the request, but not change the configurations.
381    ///
382    /// Supported API versions: 0-1
383    pub validate_only: bool,
384
385    /// Other tagged fields
386    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
387}
388
389impl IncrementalAlterConfigsRequest {
390    /// Sets `resources` to the passed value.
391    ///
392    /// The incremental updates for each resource.
393    ///
394    /// Supported API versions: 0-1
395    pub fn with_resources(mut self, value: Vec<AlterConfigsResource>) -> Self {
396        self.resources = value;
397        self
398    }
399    /// Sets `validate_only` to the passed value.
400    ///
401    /// True if we should validate the request, but not change the configurations.
402    ///
403    /// Supported API versions: 0-1
404    pub fn with_validate_only(mut self, value: bool) -> Self {
405        self.validate_only = value;
406        self
407    }
408    /// Sets unknown_tagged_fields to the passed value.
409    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
410        self.unknown_tagged_fields = value;
411        self
412    }
413    /// Inserts an entry into unknown_tagged_fields.
414    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
415        self.unknown_tagged_fields.insert(key, value);
416        self
417    }
418}
419
420#[cfg(feature = "client")]
421impl Encodable for IncrementalAlterConfigsRequest {
422    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
423        if version < 0 || version > 1 {
424            bail!("specified version not supported by this message type");
425        }
426        if version >= 1 {
427            types::CompactArray(types::Struct { version }).encode(buf, &self.resources)?;
428        } else {
429            types::Array(types::Struct { version }).encode(buf, &self.resources)?;
430        }
431        types::Boolean.encode(buf, &self.validate_only)?;
432        if version >= 1 {
433            let num_tagged_fields = self.unknown_tagged_fields.len();
434            if num_tagged_fields > std::u32::MAX as usize {
435                bail!(
436                    "Too many tagged fields to encode ({} fields)",
437                    num_tagged_fields
438                );
439            }
440            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
441
442            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
443        }
444        Ok(())
445    }
446    fn compute_size(&self, version: i16) -> Result<usize> {
447        let mut total_size = 0;
448        if version >= 1 {
449            total_size +=
450                types::CompactArray(types::Struct { version }).compute_size(&self.resources)?;
451        } else {
452            total_size += types::Array(types::Struct { version }).compute_size(&self.resources)?;
453        }
454        total_size += types::Boolean.compute_size(&self.validate_only)?;
455        if version >= 1 {
456            let num_tagged_fields = self.unknown_tagged_fields.len();
457            if num_tagged_fields > std::u32::MAX as usize {
458                bail!(
459                    "Too many tagged fields to encode ({} fields)",
460                    num_tagged_fields
461                );
462            }
463            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
464
465            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
466        }
467        Ok(total_size)
468    }
469}
470
471#[cfg(feature = "broker")]
472impl Decodable for IncrementalAlterConfigsRequest {
473    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
474        if version < 0 || version > 1 {
475            bail!("specified version not supported by this message type");
476        }
477        let resources = if version >= 1 {
478            types::CompactArray(types::Struct { version }).decode(buf)?
479        } else {
480            types::Array(types::Struct { version }).decode(buf)?
481        };
482        let validate_only = types::Boolean.decode(buf)?;
483        let mut unknown_tagged_fields = BTreeMap::new();
484        if version >= 1 {
485            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
486            for _ in 0..num_tagged_fields {
487                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
488                let size: u32 = types::UnsignedVarInt.decode(buf)?;
489                let unknown_value = buf.try_get_bytes(size as usize)?;
490                unknown_tagged_fields.insert(tag as i32, unknown_value);
491            }
492        }
493        Ok(Self {
494            resources,
495            validate_only,
496            unknown_tagged_fields,
497        })
498    }
499}
500
501impl Default for IncrementalAlterConfigsRequest {
502    fn default() -> Self {
503        Self {
504            resources: Default::default(),
505            validate_only: false,
506            unknown_tagged_fields: BTreeMap::new(),
507        }
508    }
509}
510
511impl Message for IncrementalAlterConfigsRequest {
512    const VERSIONS: VersionRange = VersionRange { min: 0, max: 1 };
513    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
514}
515
516impl HeaderVersion for IncrementalAlterConfigsRequest {
517    fn header_version(version: i16) -> i16 {
518        if version >= 1 {
519            2
520        } else {
521            1
522        }
523    }
524}
kafka_protocol/messages/incremental_alter_configs_request.rs

kafka_protocol/messages/
incremental_alter_configs_request.rs
