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 DeleteAclsFilterResult {
24 pub error_code: i16,
28
29 pub error_message: Option<StrBytes>,
33
34 pub matching_acls: Vec<DeleteAclsMatchingAcl>,
38
39 pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
41}
42
43impl DeleteAclsFilterResult {
44 pub fn with_error_code(mut self, value: i16) -> Self {
50 self.error_code = value;
51 self
52 }
53 pub fn with_error_message(mut self, value: Option<StrBytes>) -> Self {
59 self.error_message = value;
60 self
61 }
62 pub fn with_matching_acls(mut self, value: Vec<DeleteAclsMatchingAcl>) -> Self {
68 self.matching_acls = value;
69 self
70 }
71 pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
73 self.unknown_tagged_fields = value;
74 self
75 }
76 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 = "broker")]
84impl Encodable for DeleteAclsFilterResult {
85 fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
86 if version < 0 || version > 3 {
87 bail!("specified version not supported by this message type");
88 }
89 types::Int16.encode(buf, &self.error_code)?;
90 if version >= 2 {
91 types::CompactString.encode(buf, &self.error_message)?;
92 } else {
93 types::String.encode(buf, &self.error_message)?;
94 }
95 if version >= 2 {
96 types::CompactArray(types::Struct { version }).encode(buf, &self.matching_acls)?;
97 } else {
98 types::Array(types::Struct { version }).encode(buf, &self.matching_acls)?;
99 }
100 if version >= 2 {
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::Int16.compute_size(&self.error_code)?;
117 if version >= 2 {
118 total_size += types::CompactString.compute_size(&self.error_message)?;
119 } else {
120 total_size += types::String.compute_size(&self.error_message)?;
121 }
122 if version >= 2 {
123 total_size +=
124 types::CompactArray(types::Struct { version }).compute_size(&self.matching_acls)?;
125 } else {
126 total_size +=
127 types::Array(types::Struct { version }).compute_size(&self.matching_acls)?;
128 }
129 if version >= 2 {
130 let num_tagged_fields = self.unknown_tagged_fields.len();
131 if num_tagged_fields > std::u32::MAX as usize {
132 bail!(
133 "Too many tagged fields to encode ({} fields)",
134 num_tagged_fields
135 );
136 }
137 total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
138
139 total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
140 }
141 Ok(total_size)
142 }
143}
144
145#[cfg(feature = "client")]
146impl Decodable for DeleteAclsFilterResult {
147 fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
148 if version < 0 || version > 3 {
149 bail!("specified version not supported by this message type");
150 }
151 let error_code = types::Int16.decode(buf)?;
152 let error_message = if version >= 2 {
153 types::CompactString.decode(buf)?
154 } else {
155 types::String.decode(buf)?
156 };
157 let matching_acls = if version >= 2 {
158 types::CompactArray(types::Struct { version }).decode(buf)?
159 } else {
160 types::Array(types::Struct { version }).decode(buf)?
161 };
162 let mut unknown_tagged_fields = BTreeMap::new();
163 if version >= 2 {
164 let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
165 for _ in 0..num_tagged_fields {
166 let tag: u32 = types::UnsignedVarInt.decode(buf)?;
167 let size: u32 = types::UnsignedVarInt.decode(buf)?;
168 let unknown_value = buf.try_get_bytes(size as usize)?;
169 unknown_tagged_fields.insert(tag as i32, unknown_value);
170 }
171 }
172 Ok(Self {
173 error_code,
174 error_message,
175 matching_acls,
176 unknown_tagged_fields,
177 })
178 }
179}
180
181impl Default for DeleteAclsFilterResult {
182 fn default() -> Self {
183 Self {
184 error_code: 0,
185 error_message: Some(Default::default()),
186 matching_acls: Default::default(),
187 unknown_tagged_fields: BTreeMap::new(),
188 }
189 }
190}
191
192impl Message for DeleteAclsFilterResult {
193 const VERSIONS: VersionRange = VersionRange { min: 0, max: 3 };
194 const DEPRECATED_VERSIONS: Option<VersionRange> = None;
195}
196
197#[non_exhaustive]
199#[derive(Debug, Clone, PartialEq)]
200pub struct DeleteAclsMatchingAcl {
201 pub error_code: i16,
205
206 pub error_message: Option<StrBytes>,
210
211 pub resource_type: i8,
215
216 pub resource_name: StrBytes,
220
221 pub pattern_type: i8,
225
226 pub principal: StrBytes,
230
231 pub host: StrBytes,
235
236 pub operation: i8,
240
241 pub permission_type: i8,
245
246 pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
248}
249
250impl DeleteAclsMatchingAcl {
251 pub fn with_error_code(mut self, value: i16) -> Self {
257 self.error_code = value;
258 self
259 }
260 pub fn with_error_message(mut self, value: Option<StrBytes>) -> Self {
266 self.error_message = value;
267 self
268 }
269 pub fn with_resource_type(mut self, value: i8) -> Self {
275 self.resource_type = value;
276 self
277 }
278 pub fn with_resource_name(mut self, value: StrBytes) -> Self {
284 self.resource_name = value;
285 self
286 }
287 pub fn with_pattern_type(mut self, value: i8) -> Self {
293 self.pattern_type = value;
294 self
295 }
296 pub fn with_principal(mut self, value: StrBytes) -> Self {
302 self.principal = value;
303 self
304 }
305 pub fn with_host(mut self, value: StrBytes) -> Self {
311 self.host = value;
312 self
313 }
314 pub fn with_operation(mut self, value: i8) -> Self {
320 self.operation = value;
321 self
322 }
323 pub fn with_permission_type(mut self, value: i8) -> Self {
329 self.permission_type = value;
330 self
331 }
332 pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
334 self.unknown_tagged_fields = value;
335 self
336 }
337 pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
339 self.unknown_tagged_fields.insert(key, value);
340 self
341 }
342}
343
344#[cfg(feature = "broker")]
345impl Encodable for DeleteAclsMatchingAcl {
346 fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
347 if version < 0 || version > 3 {
348 bail!("specified version not supported by this message type");
349 }
350 types::Int16.encode(buf, &self.error_code)?;
351 if version >= 2 {
352 types::CompactString.encode(buf, &self.error_message)?;
353 } else {
354 types::String.encode(buf, &self.error_message)?;
355 }
356 types::Int8.encode(buf, &self.resource_type)?;
357 if version >= 2 {
358 types::CompactString.encode(buf, &self.resource_name)?;
359 } else {
360 types::String.encode(buf, &self.resource_name)?;
361 }
362 if version >= 1 {
363 types::Int8.encode(buf, &self.pattern_type)?;
364 } else {
365 if self.pattern_type != 3 {
366 bail!("A field is set that is not available on the selected protocol version");
367 }
368 }
369 if version >= 2 {
370 types::CompactString.encode(buf, &self.principal)?;
371 } else {
372 types::String.encode(buf, &self.principal)?;
373 }
374 if version >= 2 {
375 types::CompactString.encode(buf, &self.host)?;
376 } else {
377 types::String.encode(buf, &self.host)?;
378 }
379 types::Int8.encode(buf, &self.operation)?;
380 types::Int8.encode(buf, &self.permission_type)?;
381 if version >= 2 {
382 let num_tagged_fields = self.unknown_tagged_fields.len();
383 if num_tagged_fields > std::u32::MAX as usize {
384 bail!(
385 "Too many tagged fields to encode ({} fields)",
386 num_tagged_fields
387 );
388 }
389 types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
390
391 write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
392 }
393 Ok(())
394 }
395 fn compute_size(&self, version: i16) -> Result<usize> {
396 let mut total_size = 0;
397 total_size += types::Int16.compute_size(&self.error_code)?;
398 if version >= 2 {
399 total_size += types::CompactString.compute_size(&self.error_message)?;
400 } else {
401 total_size += types::String.compute_size(&self.error_message)?;
402 }
403 total_size += types::Int8.compute_size(&self.resource_type)?;
404 if version >= 2 {
405 total_size += types::CompactString.compute_size(&self.resource_name)?;
406 } else {
407 total_size += types::String.compute_size(&self.resource_name)?;
408 }
409 if version >= 1 {
410 total_size += types::Int8.compute_size(&self.pattern_type)?;
411 } else {
412 if self.pattern_type != 3 {
413 bail!("A field is set that is not available on the selected protocol version");
414 }
415 }
416 if version >= 2 {
417 total_size += types::CompactString.compute_size(&self.principal)?;
418 } else {
419 total_size += types::String.compute_size(&self.principal)?;
420 }
421 if version >= 2 {
422 total_size += types::CompactString.compute_size(&self.host)?;
423 } else {
424 total_size += types::String.compute_size(&self.host)?;
425 }
426 total_size += types::Int8.compute_size(&self.operation)?;
427 total_size += types::Int8.compute_size(&self.permission_type)?;
428 if version >= 2 {
429 let num_tagged_fields = self.unknown_tagged_fields.len();
430 if num_tagged_fields > std::u32::MAX as usize {
431 bail!(
432 "Too many tagged fields to encode ({} fields)",
433 num_tagged_fields
434 );
435 }
436 total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
437
438 total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
439 }
440 Ok(total_size)
441 }
442}
443
444#[cfg(feature = "client")]
445impl Decodable for DeleteAclsMatchingAcl {
446 fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
447 if version < 0 || version > 3 {
448 bail!("specified version not supported by this message type");
449 }
450 let error_code = types::Int16.decode(buf)?;
451 let error_message = if version >= 2 {
452 types::CompactString.decode(buf)?
453 } else {
454 types::String.decode(buf)?
455 };
456 let resource_type = types::Int8.decode(buf)?;
457 let resource_name = if version >= 2 {
458 types::CompactString.decode(buf)?
459 } else {
460 types::String.decode(buf)?
461 };
462 let pattern_type = if version >= 1 {
463 types::Int8.decode(buf)?
464 } else {
465 3
466 };
467 let principal = if version >= 2 {
468 types::CompactString.decode(buf)?
469 } else {
470 types::String.decode(buf)?
471 };
472 let host = if version >= 2 {
473 types::CompactString.decode(buf)?
474 } else {
475 types::String.decode(buf)?
476 };
477 let operation = types::Int8.decode(buf)?;
478 let permission_type = types::Int8.decode(buf)?;
479 let mut unknown_tagged_fields = BTreeMap::new();
480 if version >= 2 {
481 let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
482 for _ in 0..num_tagged_fields {
483 let tag: u32 = types::UnsignedVarInt.decode(buf)?;
484 let size: u32 = types::UnsignedVarInt.decode(buf)?;
485 let unknown_value = buf.try_get_bytes(size as usize)?;
486 unknown_tagged_fields.insert(tag as i32, unknown_value);
487 }
488 }
489 Ok(Self {
490 error_code,
491 error_message,
492 resource_type,
493 resource_name,
494 pattern_type,
495 principal,
496 host,
497 operation,
498 permission_type,
499 unknown_tagged_fields,
500 })
501 }
502}
503
504impl Default for DeleteAclsMatchingAcl {
505 fn default() -> Self {
506 Self {
507 error_code: 0,
508 error_message: Some(Default::default()),
509 resource_type: 0,
510 resource_name: Default::default(),
511 pattern_type: 3,
512 principal: Default::default(),
513 host: Default::default(),
514 operation: 0,
515 permission_type: 0,
516 unknown_tagged_fields: BTreeMap::new(),
517 }
518 }
519}
520
521impl Message for DeleteAclsMatchingAcl {
522 const VERSIONS: VersionRange = VersionRange { min: 0, max: 3 };
523 const DEPRECATED_VERSIONS: Option<VersionRange> = None;
524}
525
526#[non_exhaustive]
528#[derive(Debug, Clone, PartialEq)]
529pub struct DeleteAclsResponse {
530 pub throttle_time_ms: i32,
534
535 pub filter_results: Vec<DeleteAclsFilterResult>,
539
540 pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
542}
543
544impl DeleteAclsResponse {
545 pub fn with_throttle_time_ms(mut self, value: i32) -> Self {
551 self.throttle_time_ms = value;
552 self
553 }
554 pub fn with_filter_results(mut self, value: Vec<DeleteAclsFilterResult>) -> Self {
560 self.filter_results = value;
561 self
562 }
563 pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
565 self.unknown_tagged_fields = value;
566 self
567 }
568 pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
570 self.unknown_tagged_fields.insert(key, value);
571 self
572 }
573}
574
575#[cfg(feature = "broker")]
576impl Encodable for DeleteAclsResponse {
577 fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
578 if version < 0 || version > 3 {
579 bail!("specified version not supported by this message type");
580 }
581 types::Int32.encode(buf, &self.throttle_time_ms)?;
582 if version >= 2 {
583 types::CompactArray(types::Struct { version }).encode(buf, &self.filter_results)?;
584 } else {
585 types::Array(types::Struct { version }).encode(buf, &self.filter_results)?;
586 }
587 if version >= 2 {
588 let num_tagged_fields = self.unknown_tagged_fields.len();
589 if num_tagged_fields > std::u32::MAX as usize {
590 bail!(
591 "Too many tagged fields to encode ({} fields)",
592 num_tagged_fields
593 );
594 }
595 types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
596
597 write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
598 }
599 Ok(())
600 }
601 fn compute_size(&self, version: i16) -> Result<usize> {
602 let mut total_size = 0;
603 total_size += types::Int32.compute_size(&self.throttle_time_ms)?;
604 if version >= 2 {
605 total_size += types::CompactArray(types::Struct { version })
606 .compute_size(&self.filter_results)?;
607 } else {
608 total_size +=
609 types::Array(types::Struct { version }).compute_size(&self.filter_results)?;
610 }
611 if version >= 2 {
612 let num_tagged_fields = self.unknown_tagged_fields.len();
613 if num_tagged_fields > std::u32::MAX as usize {
614 bail!(
615 "Too many tagged fields to encode ({} fields)",
616 num_tagged_fields
617 );
618 }
619 total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
620
621 total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
622 }
623 Ok(total_size)
624 }
625}
626
627#[cfg(feature = "client")]
628impl Decodable for DeleteAclsResponse {
629 fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
630 if version < 0 || version > 3 {
631 bail!("specified version not supported by this message type");
632 }
633 let throttle_time_ms = types::Int32.decode(buf)?;
634 let filter_results = if version >= 2 {
635 types::CompactArray(types::Struct { version }).decode(buf)?
636 } else {
637 types::Array(types::Struct { version }).decode(buf)?
638 };
639 let mut unknown_tagged_fields = BTreeMap::new();
640 if version >= 2 {
641 let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
642 for _ in 0..num_tagged_fields {
643 let tag: u32 = types::UnsignedVarInt.decode(buf)?;
644 let size: u32 = types::UnsignedVarInt.decode(buf)?;
645 let unknown_value = buf.try_get_bytes(size as usize)?;
646 unknown_tagged_fields.insert(tag as i32, unknown_value);
647 }
648 }
649 Ok(Self {
650 throttle_time_ms,
651 filter_results,
652 unknown_tagged_fields,
653 })
654 }
655}
656
657impl Default for DeleteAclsResponse {
658 fn default() -> Self {
659 Self {
660 throttle_time_ms: 0,
661 filter_results: Default::default(),
662 unknown_tagged_fields: BTreeMap::new(),
663 }
664 }
665}
666
667impl Message for DeleteAclsResponse {
668 const VERSIONS: VersionRange = VersionRange { min: 0, max: 3 };
669 const DEPRECATED_VERSIONS: Option<VersionRange> = None;
670}
671
672impl HeaderVersion for DeleteAclsResponse {
673 fn header_version(version: i16) -> i16 {
674 if version >= 2 {
675 1
676 } else {
677 0
678 }
679 }
680}