kafka_protocol/messages/
describe_client_quotas_response.rs

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

kafka_protocol/messages/
describe_client_quotas_response.rs
