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 AlterConfigsRequest {
24 pub resources: Vec<AlterConfigsResource>,
28
29 pub validate_only: bool,
33
34 pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
36}
37
38impl AlterConfigsRequest {
39 pub fn with_resources(mut self, value: Vec<AlterConfigsResource>) -> Self {
45 self.resources = 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 AlterConfigsRequest {
71 fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
72 if version < 0 || version > 2 {
73 bail!("specified version not supported by this message type");
74 }
75 if version >= 2 {
76 types::CompactArray(types::Struct { version }).encode(buf, &self.resources)?;
77 } else {
78 types::Array(types::Struct { version }).encode(buf, &self.resources)?;
79 }
80 types::Boolean.encode(buf, &self.validate_only)?;
81 if version >= 2 {
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 >= 2 {
98 total_size +=
99 types::CompactArray(types::Struct { version }).compute_size(&self.resources)?;
100 } else {
101 total_size += types::Array(types::Struct { version }).compute_size(&self.resources)?;
102 }
103 total_size += types::Boolean.compute_size(&self.validate_only)?;
104 if version >= 2 {
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 AlterConfigsRequest {
122 fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
123 if version < 0 || version > 2 {
124 bail!("specified version not supported by this message type");
125 }
126 let resources = if version >= 2 {
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 >= 2 {
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 resources,
144 validate_only,
145 unknown_tagged_fields,
146 })
147 }
148}
149
150impl Default for AlterConfigsRequest {
151 fn default() -> Self {
152 Self {
153 resources: Default::default(),
154 validate_only: false,
155 unknown_tagged_fields: BTreeMap::new(),
156 }
157 }
158}
159
160impl Message for AlterConfigsRequest {
161 const VERSIONS: VersionRange = VersionRange { min: 0, max: 2 };
162 const DEPRECATED_VERSIONS: Option<VersionRange> = None;
163}
164
165#[non_exhaustive]
167#[derive(Debug, Clone, PartialEq)]
168pub struct AlterConfigsResource {
169 pub resource_type: i8,
173
174 pub resource_name: StrBytes,
178
179 pub configs: Vec<AlterableConfig>,
183
184 pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
186}
187
188impl AlterConfigsResource {
189 pub fn with_resource_type(mut self, value: i8) -> Self {
195 self.resource_type = value;
196 self
197 }
198 pub fn with_resource_name(mut self, value: StrBytes) -> Self {
204 self.resource_name = value;
205 self
206 }
207 pub fn with_configs(mut self, value: Vec<AlterableConfig>) -> Self {
213 self.configs = value;
214 self
215 }
216 pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
218 self.unknown_tagged_fields = value;
219 self
220 }
221 pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
223 self.unknown_tagged_fields.insert(key, value);
224 self
225 }
226}
227
228#[cfg(feature = "client")]
229impl Encodable for AlterConfigsResource {
230 fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
231 if version < 0 || version > 2 {
232 bail!("specified version not supported by this message type");
233 }
234 types::Int8.encode(buf, &self.resource_type)?;
235 if version >= 2 {
236 types::CompactString.encode(buf, &self.resource_name)?;
237 } else {
238 types::String.encode(buf, &self.resource_name)?;
239 }
240 if version >= 2 {
241 types::CompactArray(types::Struct { version }).encode(buf, &self.configs)?;
242 } else {
243 types::Array(types::Struct { version }).encode(buf, &self.configs)?;
244 }
245 if version >= 2 {
246 let num_tagged_fields = self.unknown_tagged_fields.len();
247 if num_tagged_fields > std::u32::MAX as usize {
248 bail!(
249 "Too many tagged fields to encode ({} fields)",
250 num_tagged_fields
251 );
252 }
253 types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
254
255 write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
256 }
257 Ok(())
258 }
259 fn compute_size(&self, version: i16) -> Result<usize> {
260 let mut total_size = 0;
261 total_size += types::Int8.compute_size(&self.resource_type)?;
262 if version >= 2 {
263 total_size += types::CompactString.compute_size(&self.resource_name)?;
264 } else {
265 total_size += types::String.compute_size(&self.resource_name)?;
266 }
267 if version >= 2 {
268 total_size +=
269 types::CompactArray(types::Struct { version }).compute_size(&self.configs)?;
270 } else {
271 total_size += types::Array(types::Struct { version }).compute_size(&self.configs)?;
272 }
273 if version >= 2 {
274 let num_tagged_fields = self.unknown_tagged_fields.len();
275 if num_tagged_fields > std::u32::MAX as usize {
276 bail!(
277 "Too many tagged fields to encode ({} fields)",
278 num_tagged_fields
279 );
280 }
281 total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
282
283 total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
284 }
285 Ok(total_size)
286 }
287}
288
289#[cfg(feature = "broker")]
290impl Decodable for AlterConfigsResource {
291 fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
292 if version < 0 || version > 2 {
293 bail!("specified version not supported by this message type");
294 }
295 let resource_type = types::Int8.decode(buf)?;
296 let resource_name = if version >= 2 {
297 types::CompactString.decode(buf)?
298 } else {
299 types::String.decode(buf)?
300 };
301 let configs = if version >= 2 {
302 types::CompactArray(types::Struct { version }).decode(buf)?
303 } else {
304 types::Array(types::Struct { version }).decode(buf)?
305 };
306 let mut unknown_tagged_fields = BTreeMap::new();
307 if version >= 2 {
308 let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
309 for _ in 0..num_tagged_fields {
310 let tag: u32 = types::UnsignedVarInt.decode(buf)?;
311 let size: u32 = types::UnsignedVarInt.decode(buf)?;
312 let unknown_value = buf.try_get_bytes(size as usize)?;
313 unknown_tagged_fields.insert(tag as i32, unknown_value);
314 }
315 }
316 Ok(Self {
317 resource_type,
318 resource_name,
319 configs,
320 unknown_tagged_fields,
321 })
322 }
323}
324
325impl Default for AlterConfigsResource {
326 fn default() -> Self {
327 Self {
328 resource_type: 0,
329 resource_name: Default::default(),
330 configs: Default::default(),
331 unknown_tagged_fields: BTreeMap::new(),
332 }
333 }
334}
335
336impl Message for AlterConfigsResource {
337 const VERSIONS: VersionRange = VersionRange { min: 0, max: 2 };
338 const DEPRECATED_VERSIONS: Option<VersionRange> = None;
339}
340
341#[non_exhaustive]
343#[derive(Debug, Clone, PartialEq)]
344pub struct AlterableConfig {
345 pub name: StrBytes,
349
350 pub value: Option<StrBytes>,
354
355 pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
357}
358
359impl AlterableConfig {
360 pub fn with_name(mut self, value: StrBytes) -> Self {
366 self.name = value;
367 self
368 }
369 pub fn with_value(mut self, value: Option<StrBytes>) -> Self {
375 self.value = value;
376 self
377 }
378 pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
380 self.unknown_tagged_fields = value;
381 self
382 }
383 pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
385 self.unknown_tagged_fields.insert(key, value);
386 self
387 }
388}
389
390#[cfg(feature = "client")]
391impl Encodable for AlterableConfig {
392 fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
393 if version < 0 || version > 2 {
394 bail!("specified version not supported by this message type");
395 }
396 if version >= 2 {
397 types::CompactString.encode(buf, &self.name)?;
398 } else {
399 types::String.encode(buf, &self.name)?;
400 }
401 if version >= 2 {
402 types::CompactString.encode(buf, &self.value)?;
403 } else {
404 types::String.encode(buf, &self.value)?;
405 }
406 if version >= 2 {
407 let num_tagged_fields = self.unknown_tagged_fields.len();
408 if num_tagged_fields > std::u32::MAX as usize {
409 bail!(
410 "Too many tagged fields to encode ({} fields)",
411 num_tagged_fields
412 );
413 }
414 types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
415
416 write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
417 }
418 Ok(())
419 }
420 fn compute_size(&self, version: i16) -> Result<usize> {
421 let mut total_size = 0;
422 if version >= 2 {
423 total_size += types::CompactString.compute_size(&self.name)?;
424 } else {
425 total_size += types::String.compute_size(&self.name)?;
426 }
427 if version >= 2 {
428 total_size += types::CompactString.compute_size(&self.value)?;
429 } else {
430 total_size += types::String.compute_size(&self.value)?;
431 }
432 if version >= 2 {
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 total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
441
442 total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
443 }
444 Ok(total_size)
445 }
446}
447
448#[cfg(feature = "broker")]
449impl Decodable for AlterableConfig {
450 fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
451 if version < 0 || version > 2 {
452 bail!("specified version not supported by this message type");
453 }
454 let name = if version >= 2 {
455 types::CompactString.decode(buf)?
456 } else {
457 types::String.decode(buf)?
458 };
459 let value = if version >= 2 {
460 types::CompactString.decode(buf)?
461 } else {
462 types::String.decode(buf)?
463 };
464 let mut unknown_tagged_fields = BTreeMap::new();
465 if version >= 2 {
466 let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
467 for _ in 0..num_tagged_fields {
468 let tag: u32 = types::UnsignedVarInt.decode(buf)?;
469 let size: u32 = types::UnsignedVarInt.decode(buf)?;
470 let unknown_value = buf.try_get_bytes(size as usize)?;
471 unknown_tagged_fields.insert(tag as i32, unknown_value);
472 }
473 }
474 Ok(Self {
475 name,
476 value,
477 unknown_tagged_fields,
478 })
479 }
480}
481
482impl Default for AlterableConfig {
483 fn default() -> Self {
484 Self {
485 name: Default::default(),
486 value: Some(Default::default()),
487 unknown_tagged_fields: BTreeMap::new(),
488 }
489 }
490}
491
492impl Message for AlterableConfig {
493 const VERSIONS: VersionRange = VersionRange { min: 0, max: 2 };
494 const DEPRECATED_VERSIONS: Option<VersionRange> = None;
495}
496
497impl HeaderVersion for AlterConfigsRequest {
498 fn header_version(version: i16) -> i16 {
499 if version >= 2 {
500 2
501 } else {
502 1
503 }
504 }
505}