1#![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#[non_exhaustive]
22#[derive(Debug, Clone, PartialEq)]
23pub struct AlterClientQuotasRequest {
24 pub entries: Vec<EntryData>,
28
29 pub validate_only: bool,
33
34 pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
36}
37
38impl AlterClientQuotasRequest {
39 pub fn with_entries(mut self, value: Vec<EntryData>) -> Self {
45 self.entries = value;
46 self
47 }
48 pub fn with_validate_only(mut self, value: bool) -> Self {
54 self.validate_only = value;
55 self
56 }
57 pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
59 self.unknown_tagged_fields = value;
60 self
61 }
62 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 < 0 || version > 1 {
73 bail!("specified version not supported by this message type");
74 }
75 if version >= 1 {
76 types::CompactArray(types::Struct { version }).encode(buf, &self.entries)?;
77 } else {
78 types::Array(types::Struct { version }).encode(buf, &self.entries)?;
79 }
80 types::Boolean.encode(buf, &self.validate_only)?;
81 if version >= 1 {
82 let num_tagged_fields = self.unknown_tagged_fields.len();
83 if num_tagged_fields > std::u32::MAX as usize {
84 bail!(
85 "Too many tagged fields to encode ({} fields)",
86 num_tagged_fields
87 );
88 }
89 types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
90
91 write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
92 }
93 Ok(())
94 }
95 fn compute_size(&self, version: i16) -> Result<usize> {
96 let mut total_size = 0;
97 if version >= 1 {
98 total_size +=
99 types::CompactArray(types::Struct { version }).compute_size(&self.entries)?;
100 } else {
101 total_size += types::Array(types::Struct { version }).compute_size(&self.entries)?;
102 }
103 total_size += types::Boolean.compute_size(&self.validate_only)?;
104 if version >= 1 {
105 let num_tagged_fields = self.unknown_tagged_fields.len();
106 if num_tagged_fields > std::u32::MAX as usize {
107 bail!(
108 "Too many tagged fields to encode ({} fields)",
109 num_tagged_fields
110 );
111 }
112 total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
113
114 total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
115 }
116 Ok(total_size)
117 }
118}
119
120#[cfg(feature = "broker")]
121impl Decodable for AlterClientQuotasRequest {
122 fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
123 if version < 0 || version > 1 {
124 bail!("specified version not supported by this message type");
125 }
126 let entries = if version >= 1 {
127 types::CompactArray(types::Struct { version }).decode(buf)?
128 } else {
129 types::Array(types::Struct { version }).decode(buf)?
130 };
131 let validate_only = types::Boolean.decode(buf)?;
132 let mut unknown_tagged_fields = BTreeMap::new();
133 if version >= 1 {
134 let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
135 for _ in 0..num_tagged_fields {
136 let tag: u32 = types::UnsignedVarInt.decode(buf)?;
137 let size: u32 = types::UnsignedVarInt.decode(buf)?;
138 let unknown_value = buf.try_get_bytes(size as usize)?;
139 unknown_tagged_fields.insert(tag as i32, unknown_value);
140 }
141 }
142 Ok(Self {
143 entries,
144 validate_only,
145 unknown_tagged_fields,
146 })
147 }
148}
149
150impl Default for AlterClientQuotasRequest {
151 fn default() -> Self {
152 Self {
153 entries: Default::default(),
154 validate_only: false,
155 unknown_tagged_fields: BTreeMap::new(),
156 }
157 }
158}
159
160impl Message for AlterClientQuotasRequest {
161 const VERSIONS: VersionRange = VersionRange { min: 0, max: 1 };
162 const DEPRECATED_VERSIONS: Option<VersionRange> = None;
163}
164
165#[non_exhaustive]
167#[derive(Debug, Clone, PartialEq)]
168pub struct EntityData {
169 pub entity_type: StrBytes,
173
174 pub entity_name: Option<StrBytes>,
178
179 pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
181}
182
183impl EntityData {
184 pub fn with_entity_type(mut self, value: StrBytes) -> Self {
190 self.entity_type = value;
191 self
192 }
193 pub fn with_entity_name(mut self, value: Option<StrBytes>) -> Self {
199 self.entity_name = value;
200 self
201 }
202 pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
204 self.unknown_tagged_fields = value;
205 self
206 }
207 pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
209 self.unknown_tagged_fields.insert(key, value);
210 self
211 }
212}
213
214#[cfg(feature = "client")]
215impl Encodable for EntityData {
216 fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
217 if version < 0 || version > 1 {
218 bail!("specified version not supported by this message type");
219 }
220 if version >= 1 {
221 types::CompactString.encode(buf, &self.entity_type)?;
222 } else {
223 types::String.encode(buf, &self.entity_type)?;
224 }
225 if version >= 1 {
226 types::CompactString.encode(buf, &self.entity_name)?;
227 } else {
228 types::String.encode(buf, &self.entity_name)?;
229 }
230 if version >= 1 {
231 let num_tagged_fields = self.unknown_tagged_fields.len();
232 if num_tagged_fields > std::u32::MAX as usize {
233 bail!(
234 "Too many tagged fields to encode ({} fields)",
235 num_tagged_fields
236 );
237 }
238 types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
239
240 write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
241 }
242 Ok(())
243 }
244 fn compute_size(&self, version: i16) -> Result<usize> {
245 let mut total_size = 0;
246 if version >= 1 {
247 total_size += types::CompactString.compute_size(&self.entity_type)?;
248 } else {
249 total_size += types::String.compute_size(&self.entity_type)?;
250 }
251 if version >= 1 {
252 total_size += types::CompactString.compute_size(&self.entity_name)?;
253 } else {
254 total_size += types::String.compute_size(&self.entity_name)?;
255 }
256 if version >= 1 {
257 let num_tagged_fields = self.unknown_tagged_fields.len();
258 if num_tagged_fields > std::u32::MAX as usize {
259 bail!(
260 "Too many tagged fields to encode ({} fields)",
261 num_tagged_fields
262 );
263 }
264 total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
265
266 total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
267 }
268 Ok(total_size)
269 }
270}
271
272#[cfg(feature = "broker")]
273impl Decodable for EntityData {
274 fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
275 if version < 0 || version > 1 {
276 bail!("specified version not supported by this message type");
277 }
278 let entity_type = if version >= 1 {
279 types::CompactString.decode(buf)?
280 } else {
281 types::String.decode(buf)?
282 };
283 let entity_name = if version >= 1 {
284 types::CompactString.decode(buf)?
285 } else {
286 types::String.decode(buf)?
287 };
288 let mut unknown_tagged_fields = BTreeMap::new();
289 if version >= 1 {
290 let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
291 for _ in 0..num_tagged_fields {
292 let tag: u32 = types::UnsignedVarInt.decode(buf)?;
293 let size: u32 = types::UnsignedVarInt.decode(buf)?;
294 let unknown_value = buf.try_get_bytes(size as usize)?;
295 unknown_tagged_fields.insert(tag as i32, unknown_value);
296 }
297 }
298 Ok(Self {
299 entity_type,
300 entity_name,
301 unknown_tagged_fields,
302 })
303 }
304}
305
306impl Default for EntityData {
307 fn default() -> Self {
308 Self {
309 entity_type: Default::default(),
310 entity_name: Some(Default::default()),
311 unknown_tagged_fields: BTreeMap::new(),
312 }
313 }
314}
315
316impl Message for EntityData {
317 const VERSIONS: VersionRange = VersionRange { min: 0, max: 1 };
318 const DEPRECATED_VERSIONS: Option<VersionRange> = None;
319}
320
321#[non_exhaustive]
323#[derive(Debug, Clone, PartialEq)]
324pub struct EntryData {
325 pub entity: Vec<EntityData>,
329
330 pub ops: Vec<OpData>,
334
335 pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
337}
338
339impl EntryData {
340 pub fn with_entity(mut self, value: Vec<EntityData>) -> Self {
346 self.entity = value;
347 self
348 }
349 pub fn with_ops(mut self, value: Vec<OpData>) -> Self {
355 self.ops = value;
356 self
357 }
358 pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
360 self.unknown_tagged_fields = value;
361 self
362 }
363 pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
365 self.unknown_tagged_fields.insert(key, value);
366 self
367 }
368}
369
370#[cfg(feature = "client")]
371impl Encodable for EntryData {
372 fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
373 if version < 0 || version > 1 {
374 bail!("specified version not supported by this message type");
375 }
376 if version >= 1 {
377 types::CompactArray(types::Struct { version }).encode(buf, &self.entity)?;
378 } else {
379 types::Array(types::Struct { version }).encode(buf, &self.entity)?;
380 }
381 if version >= 1 {
382 types::CompactArray(types::Struct { version }).encode(buf, &self.ops)?;
383 } else {
384 types::Array(types::Struct { version }).encode(buf, &self.ops)?;
385 }
386 if version >= 1 {
387 let num_tagged_fields = self.unknown_tagged_fields.len();
388 if num_tagged_fields > std::u32::MAX as usize {
389 bail!(
390 "Too many tagged fields to encode ({} fields)",
391 num_tagged_fields
392 );
393 }
394 types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
395
396 write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
397 }
398 Ok(())
399 }
400 fn compute_size(&self, version: i16) -> Result<usize> {
401 let mut total_size = 0;
402 if version >= 1 {
403 total_size +=
404 types::CompactArray(types::Struct { version }).compute_size(&self.entity)?;
405 } else {
406 total_size += types::Array(types::Struct { version }).compute_size(&self.entity)?;
407 }
408 if version >= 1 {
409 total_size += types::CompactArray(types::Struct { version }).compute_size(&self.ops)?;
410 } else {
411 total_size += types::Array(types::Struct { version }).compute_size(&self.ops)?;
412 }
413 if version >= 1 {
414 let num_tagged_fields = self.unknown_tagged_fields.len();
415 if num_tagged_fields > std::u32::MAX as usize {
416 bail!(
417 "Too many tagged fields to encode ({} fields)",
418 num_tagged_fields
419 );
420 }
421 total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
422
423 total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
424 }
425 Ok(total_size)
426 }
427}
428
429#[cfg(feature = "broker")]
430impl Decodable for EntryData {
431 fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
432 if version < 0 || version > 1 {
433 bail!("specified version not supported by this message type");
434 }
435 let entity = if version >= 1 {
436 types::CompactArray(types::Struct { version }).decode(buf)?
437 } else {
438 types::Array(types::Struct { version }).decode(buf)?
439 };
440 let ops = if version >= 1 {
441 types::CompactArray(types::Struct { version }).decode(buf)?
442 } else {
443 types::Array(types::Struct { version }).decode(buf)?
444 };
445 let mut unknown_tagged_fields = BTreeMap::new();
446 if version >= 1 {
447 let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
448 for _ in 0..num_tagged_fields {
449 let tag: u32 = types::UnsignedVarInt.decode(buf)?;
450 let size: u32 = types::UnsignedVarInt.decode(buf)?;
451 let unknown_value = buf.try_get_bytes(size as usize)?;
452 unknown_tagged_fields.insert(tag as i32, unknown_value);
453 }
454 }
455 Ok(Self {
456 entity,
457 ops,
458 unknown_tagged_fields,
459 })
460 }
461}
462
463impl Default for EntryData {
464 fn default() -> Self {
465 Self {
466 entity: Default::default(),
467 ops: Default::default(),
468 unknown_tagged_fields: BTreeMap::new(),
469 }
470 }
471}
472
473impl Message for EntryData {
474 const VERSIONS: VersionRange = VersionRange { min: 0, max: 1 };
475 const DEPRECATED_VERSIONS: Option<VersionRange> = None;
476}
477
478#[non_exhaustive]
480#[derive(Debug, Clone, PartialEq)]
481pub struct OpData {
482 pub key: StrBytes,
486
487 pub value: f64,
491
492 pub remove: bool,
496
497 pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
499}
500
501impl OpData {
502 pub fn with_key(mut self, value: StrBytes) -> Self {
508 self.key = value;
509 self
510 }
511 pub fn with_value(mut self, value: f64) -> Self {
517 self.value = value;
518 self
519 }
520 pub fn with_remove(mut self, value: bool) -> Self {
526 self.remove = value;
527 self
528 }
529 pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
531 self.unknown_tagged_fields = value;
532 self
533 }
534 pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
536 self.unknown_tagged_fields.insert(key, value);
537 self
538 }
539}
540
541#[cfg(feature = "client")]
542impl Encodable for OpData {
543 fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
544 if version < 0 || version > 1 {
545 bail!("specified version not supported by this message type");
546 }
547 if version >= 1 {
548 types::CompactString.encode(buf, &self.key)?;
549 } else {
550 types::String.encode(buf, &self.key)?;
551 }
552 types::Float64.encode(buf, &self.value)?;
553 types::Boolean.encode(buf, &self.remove)?;
554 if version >= 1 {
555 let num_tagged_fields = self.unknown_tagged_fields.len();
556 if num_tagged_fields > std::u32::MAX as usize {
557 bail!(
558 "Too many tagged fields to encode ({} fields)",
559 num_tagged_fields
560 );
561 }
562 types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
563
564 write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
565 }
566 Ok(())
567 }
568 fn compute_size(&self, version: i16) -> Result<usize> {
569 let mut total_size = 0;
570 if version >= 1 {
571 total_size += types::CompactString.compute_size(&self.key)?;
572 } else {
573 total_size += types::String.compute_size(&self.key)?;
574 }
575 total_size += types::Float64.compute_size(&self.value)?;
576 total_size += types::Boolean.compute_size(&self.remove)?;
577 if version >= 1 {
578 let num_tagged_fields = self.unknown_tagged_fields.len();
579 if num_tagged_fields > std::u32::MAX as usize {
580 bail!(
581 "Too many tagged fields to encode ({} fields)",
582 num_tagged_fields
583 );
584 }
585 total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
586
587 total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
588 }
589 Ok(total_size)
590 }
591}
592
593#[cfg(feature = "broker")]
594impl Decodable for OpData {
595 fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
596 if version < 0 || version > 1 {
597 bail!("specified version not supported by this message type");
598 }
599 let key = if version >= 1 {
600 types::CompactString.decode(buf)?
601 } else {
602 types::String.decode(buf)?
603 };
604 let value = types::Float64.decode(buf)?;
605 let remove = types::Boolean.decode(buf)?;
606 let mut unknown_tagged_fields = BTreeMap::new();
607 if version >= 1 {
608 let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
609 for _ in 0..num_tagged_fields {
610 let tag: u32 = types::UnsignedVarInt.decode(buf)?;
611 let size: u32 = types::UnsignedVarInt.decode(buf)?;
612 let unknown_value = buf.try_get_bytes(size as usize)?;
613 unknown_tagged_fields.insert(tag as i32, unknown_value);
614 }
615 }
616 Ok(Self {
617 key,
618 value,
619 remove,
620 unknown_tagged_fields,
621 })
622 }
623}
624
625impl Default for OpData {
626 fn default() -> Self {
627 Self {
628 key: Default::default(),
629 value: 0.0,
630 remove: false,
631 unknown_tagged_fields: BTreeMap::new(),
632 }
633 }
634}
635
636impl Message for OpData {
637 const VERSIONS: VersionRange = VersionRange { min: 0, max: 1 };
638 const DEPRECATED_VERSIONS: Option<VersionRange> = None;
639}
640
641impl HeaderVersion for AlterClientQuotasRequest {
642 fn header_version(version: i16) -> i16 {
643 if version >= 1 {
644 2
645 } else {
646 1
647 }
648 }
649}