kafka_protocol/messages/
alter_client_quotas_request.rs

1//! AlterClientQuotasRequest
2//!
3//! See the schema for this message [here](https://github.com/apache/kafka/blob/trunk/clients/src/main/resources/common/message/AlterClientQuotasRequest.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 AlterClientQuotasRequest {
24    /// The quota configuration entries to alter.
25    ///
26    /// Supported API versions: 0-1
27    pub entries: Vec<EntryData>,
28
29    /// Whether the alteration should be validated, but not performed.
30    ///
31    /// Supported API versions: 0-1
32    pub validate_only: bool,
33
34    /// Other tagged fields
35    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
36}
37
38impl AlterClientQuotasRequest {
39    /// Sets `entries` to the passed value.
40    ///
41    /// The quota configuration entries to alter.
42    ///
43    /// Supported API versions: 0-1
44    pub fn with_entries(mut self, value: Vec<EntryData>) -> Self {
45        self.entries = value;
46        self
47    }
48    /// Sets `validate_only` to the passed value.
49    ///
50    /// Whether the alteration should be validated, but not performed.
51    ///
52    /// Supported API versions: 0-1
53    pub fn with_validate_only(mut self, value: bool) -> Self {
54        self.validate_only = value;
55        self
56    }
57    /// Sets unknown_tagged_fields to the passed value.
58    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
59        self.unknown_tagged_fields = value;
60        self
61    }
62    /// Inserts an entry into unknown_tagged_fields.
63    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
64        self.unknown_tagged_fields.insert(key, value);
65        self
66    }
67}
68
69#[cfg(feature = "client")]
70impl Encodable for AlterClientQuotasRequest {
71    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
72        if version >= 1 {
73            types::CompactArray(types::Struct { version }).encode(buf, &self.entries)?;
74        } else {
75            types::Array(types::Struct { version }).encode(buf, &self.entries)?;
76        }
77        types::Boolean.encode(buf, &self.validate_only)?;
78        if version >= 1 {
79            let num_tagged_fields = self.unknown_tagged_fields.len();
80            if num_tagged_fields > std::u32::MAX as usize {
81                bail!(
82                    "Too many tagged fields to encode ({} fields)",
83                    num_tagged_fields
84                );
85            }
86            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
87
88            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
89        }
90        Ok(())
91    }
92    fn compute_size(&self, version: i16) -> Result<usize> {
93        let mut total_size = 0;
94        if version >= 1 {
95            total_size +=
96                types::CompactArray(types::Struct { version }).compute_size(&self.entries)?;
97        } else {
98            total_size += types::Array(types::Struct { version }).compute_size(&self.entries)?;
99        }
100        total_size += types::Boolean.compute_size(&self.validate_only)?;
101        if version >= 1 {
102            let num_tagged_fields = self.unknown_tagged_fields.len();
103            if num_tagged_fields > std::u32::MAX as usize {
104                bail!(
105                    "Too many tagged fields to encode ({} fields)",
106                    num_tagged_fields
107                );
108            }
109            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
110
111            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
112        }
113        Ok(total_size)
114    }
115}
116
117#[cfg(feature = "broker")]
118impl Decodable for AlterClientQuotasRequest {
119    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
120        let entries = if version >= 1 {
121            types::CompactArray(types::Struct { version }).decode(buf)?
122        } else {
123            types::Array(types::Struct { version }).decode(buf)?
124        };
125        let validate_only = types::Boolean.decode(buf)?;
126        let mut unknown_tagged_fields = BTreeMap::new();
127        if version >= 1 {
128            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
129            for _ in 0..num_tagged_fields {
130                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
131                let size: u32 = types::UnsignedVarInt.decode(buf)?;
132                let unknown_value = buf.try_get_bytes(size as usize)?;
133                unknown_tagged_fields.insert(tag as i32, unknown_value);
134            }
135        }
136        Ok(Self {
137            entries,
138            validate_only,
139            unknown_tagged_fields,
140        })
141    }
142}
143
144impl Default for AlterClientQuotasRequest {
145    fn default() -> Self {
146        Self {
147            entries: Default::default(),
148            validate_only: false,
149            unknown_tagged_fields: BTreeMap::new(),
150        }
151    }
152}
153
154impl Message for AlterClientQuotasRequest {
155    const VERSIONS: VersionRange = VersionRange { min: 0, max: 1 };
156    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
157}
158
159/// Valid versions: 0-1
160#[non_exhaustive]
161#[derive(Debug, Clone, PartialEq)]
162pub struct EntityData {
163    /// The entity type.
164    ///
165    /// Supported API versions: 0-1
166    pub entity_type: StrBytes,
167
168    /// The name of the entity, or null if the default.
169    ///
170    /// Supported API versions: 0-1
171    pub entity_name: Option<StrBytes>,
172
173    /// Other tagged fields
174    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
175}
176
177impl EntityData {
178    /// Sets `entity_type` to the passed value.
179    ///
180    /// The entity type.
181    ///
182    /// Supported API versions: 0-1
183    pub fn with_entity_type(mut self, value: StrBytes) -> Self {
184        self.entity_type = value;
185        self
186    }
187    /// Sets `entity_name` to the passed value.
188    ///
189    /// The name of the entity, or null if the default.
190    ///
191    /// Supported API versions: 0-1
192    pub fn with_entity_name(mut self, value: Option<StrBytes>) -> Self {
193        self.entity_name = value;
194        self
195    }
196    /// Sets unknown_tagged_fields to the passed value.
197    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
198        self.unknown_tagged_fields = value;
199        self
200    }
201    /// Inserts an entry into unknown_tagged_fields.
202    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
203        self.unknown_tagged_fields.insert(key, value);
204        self
205    }
206}
207
208#[cfg(feature = "client")]
209impl Encodable for EntityData {
210    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
211        if version >= 1 {
212            types::CompactString.encode(buf, &self.entity_type)?;
213        } else {
214            types::String.encode(buf, &self.entity_type)?;
215        }
216        if version >= 1 {
217            types::CompactString.encode(buf, &self.entity_name)?;
218        } else {
219            types::String.encode(buf, &self.entity_name)?;
220        }
221        if version >= 1 {
222            let num_tagged_fields = self.unknown_tagged_fields.len();
223            if num_tagged_fields > std::u32::MAX as usize {
224                bail!(
225                    "Too many tagged fields to encode ({} fields)",
226                    num_tagged_fields
227                );
228            }
229            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
230
231            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
232        }
233        Ok(())
234    }
235    fn compute_size(&self, version: i16) -> Result<usize> {
236        let mut total_size = 0;
237        if version >= 1 {
238            total_size += types::CompactString.compute_size(&self.entity_type)?;
239        } else {
240            total_size += types::String.compute_size(&self.entity_type)?;
241        }
242        if version >= 1 {
243            total_size += types::CompactString.compute_size(&self.entity_name)?;
244        } else {
245            total_size += types::String.compute_size(&self.entity_name)?;
246        }
247        if version >= 1 {
248            let num_tagged_fields = self.unknown_tagged_fields.len();
249            if num_tagged_fields > std::u32::MAX as usize {
250                bail!(
251                    "Too many tagged fields to encode ({} fields)",
252                    num_tagged_fields
253                );
254            }
255            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
256
257            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
258        }
259        Ok(total_size)
260    }
261}
262
263#[cfg(feature = "broker")]
264impl Decodable for EntityData {
265    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
266        let entity_type = if version >= 1 {
267            types::CompactString.decode(buf)?
268        } else {
269            types::String.decode(buf)?
270        };
271        let entity_name = if version >= 1 {
272            types::CompactString.decode(buf)?
273        } else {
274            types::String.decode(buf)?
275        };
276        let mut unknown_tagged_fields = BTreeMap::new();
277        if version >= 1 {
278            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
279            for _ in 0..num_tagged_fields {
280                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
281                let size: u32 = types::UnsignedVarInt.decode(buf)?;
282                let unknown_value = buf.try_get_bytes(size as usize)?;
283                unknown_tagged_fields.insert(tag as i32, unknown_value);
284            }
285        }
286        Ok(Self {
287            entity_type,
288            entity_name,
289            unknown_tagged_fields,
290        })
291    }
292}
293
294impl Default for EntityData {
295    fn default() -> Self {
296        Self {
297            entity_type: Default::default(),
298            entity_name: Some(Default::default()),
299            unknown_tagged_fields: BTreeMap::new(),
300        }
301    }
302}
303
304impl Message for EntityData {
305    const VERSIONS: VersionRange = VersionRange { min: 0, max: 1 };
306    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
307}
308
309/// Valid versions: 0-1
310#[non_exhaustive]
311#[derive(Debug, Clone, PartialEq)]
312pub struct EntryData {
313    /// The quota entity to alter.
314    ///
315    /// Supported API versions: 0-1
316    pub entity: Vec<EntityData>,
317
318    /// An individual quota configuration entry to alter.
319    ///
320    /// Supported API versions: 0-1
321    pub ops: Vec<OpData>,
322
323    /// Other tagged fields
324    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
325}
326
327impl EntryData {
328    /// Sets `entity` to the passed value.
329    ///
330    /// The quota entity to alter.
331    ///
332    /// Supported API versions: 0-1
333    pub fn with_entity(mut self, value: Vec<EntityData>) -> Self {
334        self.entity = value;
335        self
336    }
337    /// Sets `ops` to the passed value.
338    ///
339    /// An individual quota configuration entry to alter.
340    ///
341    /// Supported API versions: 0-1
342    pub fn with_ops(mut self, value: Vec<OpData>) -> Self {
343        self.ops = value;
344        self
345    }
346    /// Sets unknown_tagged_fields to the passed value.
347    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
348        self.unknown_tagged_fields = value;
349        self
350    }
351    /// Inserts an entry into unknown_tagged_fields.
352    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
353        self.unknown_tagged_fields.insert(key, value);
354        self
355    }
356}
357
358#[cfg(feature = "client")]
359impl Encodable for EntryData {
360    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
361        if version >= 1 {
362            types::CompactArray(types::Struct { version }).encode(buf, &self.entity)?;
363        } else {
364            types::Array(types::Struct { version }).encode(buf, &self.entity)?;
365        }
366        if version >= 1 {
367            types::CompactArray(types::Struct { version }).encode(buf, &self.ops)?;
368        } else {
369            types::Array(types::Struct { version }).encode(buf, &self.ops)?;
370        }
371        if version >= 1 {
372            let num_tagged_fields = self.unknown_tagged_fields.len();
373            if num_tagged_fields > std::u32::MAX as usize {
374                bail!(
375                    "Too many tagged fields to encode ({} fields)",
376                    num_tagged_fields
377                );
378            }
379            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
380
381            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
382        }
383        Ok(())
384    }
385    fn compute_size(&self, version: i16) -> Result<usize> {
386        let mut total_size = 0;
387        if version >= 1 {
388            total_size +=
389                types::CompactArray(types::Struct { version }).compute_size(&self.entity)?;
390        } else {
391            total_size += types::Array(types::Struct { version }).compute_size(&self.entity)?;
392        }
393        if version >= 1 {
394            total_size += types::CompactArray(types::Struct { version }).compute_size(&self.ops)?;
395        } else {
396            total_size += types::Array(types::Struct { version }).compute_size(&self.ops)?;
397        }
398        if version >= 1 {
399            let num_tagged_fields = self.unknown_tagged_fields.len();
400            if num_tagged_fields > std::u32::MAX as usize {
401                bail!(
402                    "Too many tagged fields to encode ({} fields)",
403                    num_tagged_fields
404                );
405            }
406            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
407
408            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
409        }
410        Ok(total_size)
411    }
412}
413
414#[cfg(feature = "broker")]
415impl Decodable for EntryData {
416    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
417        let entity = if version >= 1 {
418            types::CompactArray(types::Struct { version }).decode(buf)?
419        } else {
420            types::Array(types::Struct { version }).decode(buf)?
421        };
422        let ops = if version >= 1 {
423            types::CompactArray(types::Struct { version }).decode(buf)?
424        } else {
425            types::Array(types::Struct { version }).decode(buf)?
426        };
427        let mut unknown_tagged_fields = BTreeMap::new();
428        if version >= 1 {
429            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
430            for _ in 0..num_tagged_fields {
431                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
432                let size: u32 = types::UnsignedVarInt.decode(buf)?;
433                let unknown_value = buf.try_get_bytes(size as usize)?;
434                unknown_tagged_fields.insert(tag as i32, unknown_value);
435            }
436        }
437        Ok(Self {
438            entity,
439            ops,
440            unknown_tagged_fields,
441        })
442    }
443}
444
445impl Default for EntryData {
446    fn default() -> Self {
447        Self {
448            entity: Default::default(),
449            ops: Default::default(),
450            unknown_tagged_fields: BTreeMap::new(),
451        }
452    }
453}
454
455impl Message for EntryData {
456    const VERSIONS: VersionRange = VersionRange { min: 0, max: 1 };
457    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
458}
459
460/// Valid versions: 0-1
461#[non_exhaustive]
462#[derive(Debug, Clone, PartialEq)]
463pub struct OpData {
464    /// The quota configuration key.
465    ///
466    /// Supported API versions: 0-1
467    pub key: StrBytes,
468
469    /// The value to set, otherwise ignored if the value is to be removed.
470    ///
471    /// Supported API versions: 0-1
472    pub value: f64,
473
474    /// Whether the quota configuration value should be removed, otherwise set.
475    ///
476    /// Supported API versions: 0-1
477    pub remove: bool,
478
479    /// Other tagged fields
480    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
481}
482
483impl OpData {
484    /// Sets `key` to the passed value.
485    ///
486    /// The quota configuration key.
487    ///
488    /// Supported API versions: 0-1
489    pub fn with_key(mut self, value: StrBytes) -> Self {
490        self.key = value;
491        self
492    }
493    /// Sets `value` to the passed value.
494    ///
495    /// The value to set, otherwise ignored if the value is to be removed.
496    ///
497    /// Supported API versions: 0-1
498    pub fn with_value(mut self, value: f64) -> Self {
499        self.value = value;
500        self
501    }
502    /// Sets `remove` to the passed value.
503    ///
504    /// Whether the quota configuration value should be removed, otherwise set.
505    ///
506    /// Supported API versions: 0-1
507    pub fn with_remove(mut self, value: bool) -> Self {
508        self.remove = value;
509        self
510    }
511    /// Sets unknown_tagged_fields to the passed value.
512    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
513        self.unknown_tagged_fields = value;
514        self
515    }
516    /// Inserts an entry into unknown_tagged_fields.
517    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
518        self.unknown_tagged_fields.insert(key, value);
519        self
520    }
521}
522
523#[cfg(feature = "client")]
524impl Encodable for OpData {
525    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
526        if version >= 1 {
527            types::CompactString.encode(buf, &self.key)?;
528        } else {
529            types::String.encode(buf, &self.key)?;
530        }
531        types::Float64.encode(buf, &self.value)?;
532        types::Boolean.encode(buf, &self.remove)?;
533        if version >= 1 {
534            let num_tagged_fields = self.unknown_tagged_fields.len();
535            if num_tagged_fields > std::u32::MAX as usize {
536                bail!(
537                    "Too many tagged fields to encode ({} fields)",
538                    num_tagged_fields
539                );
540            }
541            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
542
543            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
544        }
545        Ok(())
546    }
547    fn compute_size(&self, version: i16) -> Result<usize> {
548        let mut total_size = 0;
549        if version >= 1 {
550            total_size += types::CompactString.compute_size(&self.key)?;
551        } else {
552            total_size += types::String.compute_size(&self.key)?;
553        }
554        total_size += types::Float64.compute_size(&self.value)?;
555        total_size += types::Boolean.compute_size(&self.remove)?;
556        if version >= 1 {
557            let num_tagged_fields = self.unknown_tagged_fields.len();
558            if num_tagged_fields > std::u32::MAX as usize {
559                bail!(
560                    "Too many tagged fields to encode ({} fields)",
561                    num_tagged_fields
562                );
563            }
564            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
565
566            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
567        }
568        Ok(total_size)
569    }
570}
571
572#[cfg(feature = "broker")]
573impl Decodable for OpData {
574    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
575        let key = if version >= 1 {
576            types::CompactString.decode(buf)?
577        } else {
578            types::String.decode(buf)?
579        };
580        let value = types::Float64.decode(buf)?;
581        let remove = types::Boolean.decode(buf)?;
582        let mut unknown_tagged_fields = BTreeMap::new();
583        if version >= 1 {
584            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
585            for _ in 0..num_tagged_fields {
586                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
587                let size: u32 = types::UnsignedVarInt.decode(buf)?;
588                let unknown_value = buf.try_get_bytes(size as usize)?;
589                unknown_tagged_fields.insert(tag as i32, unknown_value);
590            }
591        }
592        Ok(Self {
593            key,
594            value,
595            remove,
596            unknown_tagged_fields,
597        })
598    }
599}
600
601impl Default for OpData {
602    fn default() -> Self {
603        Self {
604            key: Default::default(),
605            value: 0.0,
606            remove: false,
607            unknown_tagged_fields: BTreeMap::new(),
608        }
609    }
610}
611
612impl Message for OpData {
613    const VERSIONS: VersionRange = VersionRange { min: 0, max: 1 };
614    const DEPRECATED_VERSIONS: Option<VersionRange> = None;
615}
616
617impl HeaderVersion for AlterClientQuotasRequest {
618    fn header_version(version: i16) -> i16 {
619        if version >= 1 {
620            2
621        } else {
622            1
623        }
624    }
625}
kafka_protocol/messages/alter_client_quotas_request.rs

kafka_protocol/messages/
alter_client_quotas_request.rs
