kafka_protocol/messages/
alter_replica_log_dirs_request.rs

1//! AlterReplicaLogDirsRequest
2//!
3//! See the schema for this message [here](https://github.com/apache/kafka/blob/trunk/clients/src/main/resources/common/message/AlterReplicaLogDirsRequest.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-2
21#[non_exhaustive]
22#[derive(Debug, Clone, PartialEq)]
23pub struct AlterReplicaLogDir {
24    /// The absolute directory path.
25    ///
26    /// Supported API versions: 0-2
27    pub path: StrBytes,
28
29    /// The topics to add to the directory.
30    ///
31    /// Supported API versions: 0-2
32    pub topics: Vec<AlterReplicaLogDirTopic>,
33
34    /// Other tagged fields
35    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
36}
37
38impl AlterReplicaLogDir {
39    /// Sets `path` to the passed value.
40    ///
41    /// The absolute directory path.
42    ///
43    /// Supported API versions: 0-2
44    pub fn with_path(mut self, value: StrBytes) -> Self {
45        self.path = value;
46        self
47    }
48    /// Sets `topics` to the passed value.
49    ///
50    /// The topics to add to the directory.
51    ///
52    /// Supported API versions: 0-2
53    pub fn with_topics(mut self, value: Vec<AlterReplicaLogDirTopic>) -> Self {
54        self.topics = 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 AlterReplicaLogDir {
71    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
72        if version >= 2 {
73            types::CompactString.encode(buf, &self.path)?;
74        } else {
75            types::String.encode(buf, &self.path)?;
76        }
77        if version >= 2 {
78            types::CompactArray(types::Struct { version }).encode(buf, &self.topics)?;
79        } else {
80            types::Array(types::Struct { version }).encode(buf, &self.topics)?;
81        }
82        if version >= 2 {
83            let num_tagged_fields = self.unknown_tagged_fields.len();
84            if num_tagged_fields > std::u32::MAX as usize {
85                bail!(
86                    "Too many tagged fields to encode ({} fields)",
87                    num_tagged_fields
88                );
89            }
90            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
91
92            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
93        }
94        Ok(())
95    }
96    fn compute_size(&self, version: i16) -> Result<usize> {
97        let mut total_size = 0;
98        if version >= 2 {
99            total_size += types::CompactString.compute_size(&self.path)?;
100        } else {
101            total_size += types::String.compute_size(&self.path)?;
102        }
103        if version >= 2 {
104            total_size +=
105                types::CompactArray(types::Struct { version }).compute_size(&self.topics)?;
106        } else {
107            total_size += types::Array(types::Struct { version }).compute_size(&self.topics)?;
108        }
109        if version >= 2 {
110            let num_tagged_fields = self.unknown_tagged_fields.len();
111            if num_tagged_fields > std::u32::MAX as usize {
112                bail!(
113                    "Too many tagged fields to encode ({} fields)",
114                    num_tagged_fields
115                );
116            }
117            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
118
119            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
120        }
121        Ok(total_size)
122    }
123}
124
125#[cfg(feature = "broker")]
126impl Decodable for AlterReplicaLogDir {
127    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
128        let path = if version >= 2 {
129            types::CompactString.decode(buf)?
130        } else {
131            types::String.decode(buf)?
132        };
133        let topics = if version >= 2 {
134            types::CompactArray(types::Struct { version }).decode(buf)?
135        } else {
136            types::Array(types::Struct { version }).decode(buf)?
137        };
138        let mut unknown_tagged_fields = BTreeMap::new();
139        if version >= 2 {
140            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
141            for _ in 0..num_tagged_fields {
142                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
143                let size: u32 = types::UnsignedVarInt.decode(buf)?;
144                let unknown_value = buf.try_get_bytes(size as usize)?;
145                unknown_tagged_fields.insert(tag as i32, unknown_value);
146            }
147        }
148        Ok(Self {
149            path,
150            topics,
151            unknown_tagged_fields,
152        })
153    }
154}
155
156impl Default for AlterReplicaLogDir {
157    fn default() -> Self {
158        Self {
159            path: Default::default(),
160            topics: Default::default(),
161            unknown_tagged_fields: BTreeMap::new(),
162        }
163    }
164}
165
166impl Message for AlterReplicaLogDir {
167    const VERSIONS: VersionRange = VersionRange { min: 0, max: 2 };
168    const DEPRECATED_VERSIONS: Option<VersionRange> = Some(VersionRange { min: 0, max: 0 });
169}
170
171/// Valid versions: 0-2
172#[non_exhaustive]
173#[derive(Debug, Clone, PartialEq)]
174pub struct AlterReplicaLogDirTopic {
175    /// The topic name.
176    ///
177    /// Supported API versions: 0-2
178    pub name: super::TopicName,
179
180    /// The partition indexes.
181    ///
182    /// Supported API versions: 0-2
183    pub partitions: Vec<i32>,
184
185    /// Other tagged fields
186    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
187}
188
189impl AlterReplicaLogDirTopic {
190    /// Sets `name` to the passed value.
191    ///
192    /// The topic name.
193    ///
194    /// Supported API versions: 0-2
195    pub fn with_name(mut self, value: super::TopicName) -> Self {
196        self.name = value;
197        self
198    }
199    /// Sets `partitions` to the passed value.
200    ///
201    /// The partition indexes.
202    ///
203    /// Supported API versions: 0-2
204    pub fn with_partitions(mut self, value: Vec<i32>) -> Self {
205        self.partitions = value;
206        self
207    }
208    /// Sets unknown_tagged_fields to the passed value.
209    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
210        self.unknown_tagged_fields = value;
211        self
212    }
213    /// Inserts an entry into unknown_tagged_fields.
214    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
215        self.unknown_tagged_fields.insert(key, value);
216        self
217    }
218}
219
220#[cfg(feature = "client")]
221impl Encodable for AlterReplicaLogDirTopic {
222    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
223        if version >= 2 {
224            types::CompactString.encode(buf, &self.name)?;
225        } else {
226            types::String.encode(buf, &self.name)?;
227        }
228        if version >= 2 {
229            types::CompactArray(types::Int32).encode(buf, &self.partitions)?;
230        } else {
231            types::Array(types::Int32).encode(buf, &self.partitions)?;
232        }
233        if version >= 2 {
234            let num_tagged_fields = self.unknown_tagged_fields.len();
235            if num_tagged_fields > std::u32::MAX as usize {
236                bail!(
237                    "Too many tagged fields to encode ({} fields)",
238                    num_tagged_fields
239                );
240            }
241            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
242
243            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
244        }
245        Ok(())
246    }
247    fn compute_size(&self, version: i16) -> Result<usize> {
248        let mut total_size = 0;
249        if version >= 2 {
250            total_size += types::CompactString.compute_size(&self.name)?;
251        } else {
252            total_size += types::String.compute_size(&self.name)?;
253        }
254        if version >= 2 {
255            total_size += types::CompactArray(types::Int32).compute_size(&self.partitions)?;
256        } else {
257            total_size += types::Array(types::Int32).compute_size(&self.partitions)?;
258        }
259        if version >= 2 {
260            let num_tagged_fields = self.unknown_tagged_fields.len();
261            if num_tagged_fields > std::u32::MAX as usize {
262                bail!(
263                    "Too many tagged fields to encode ({} fields)",
264                    num_tagged_fields
265                );
266            }
267            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
268
269            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
270        }
271        Ok(total_size)
272    }
273}
274
275#[cfg(feature = "broker")]
276impl Decodable for AlterReplicaLogDirTopic {
277    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
278        let name = if version >= 2 {
279            types::CompactString.decode(buf)?
280        } else {
281            types::String.decode(buf)?
282        };
283        let partitions = if version >= 2 {
284            types::CompactArray(types::Int32).decode(buf)?
285        } else {
286            types::Array(types::Int32).decode(buf)?
287        };
288        let mut unknown_tagged_fields = BTreeMap::new();
289        if version >= 2 {
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            name,
300            partitions,
301            unknown_tagged_fields,
302        })
303    }
304}
305
306impl Default for AlterReplicaLogDirTopic {
307    fn default() -> Self {
308        Self {
309            name: Default::default(),
310            partitions: Default::default(),
311            unknown_tagged_fields: BTreeMap::new(),
312        }
313    }
314}
315
316impl Message for AlterReplicaLogDirTopic {
317    const VERSIONS: VersionRange = VersionRange { min: 0, max: 2 };
318    const DEPRECATED_VERSIONS: Option<VersionRange> = Some(VersionRange { min: 0, max: 0 });
319}
320
321/// Valid versions: 0-2
322#[non_exhaustive]
323#[derive(Debug, Clone, PartialEq)]
324pub struct AlterReplicaLogDirsRequest {
325    /// The alterations to make for each directory.
326    ///
327    /// Supported API versions: 0-2
328    pub dirs: Vec<AlterReplicaLogDir>,
329
330    /// Other tagged fields
331    pub unknown_tagged_fields: BTreeMap<i32, Bytes>,
332}
333
334impl AlterReplicaLogDirsRequest {
335    /// Sets `dirs` to the passed value.
336    ///
337    /// The alterations to make for each directory.
338    ///
339    /// Supported API versions: 0-2
340    pub fn with_dirs(mut self, value: Vec<AlterReplicaLogDir>) -> Self {
341        self.dirs = value;
342        self
343    }
344    /// Sets unknown_tagged_fields to the passed value.
345    pub fn with_unknown_tagged_fields(mut self, value: BTreeMap<i32, Bytes>) -> Self {
346        self.unknown_tagged_fields = value;
347        self
348    }
349    /// Inserts an entry into unknown_tagged_fields.
350    pub fn with_unknown_tagged_field(mut self, key: i32, value: Bytes) -> Self {
351        self.unknown_tagged_fields.insert(key, value);
352        self
353    }
354}
355
356#[cfg(feature = "client")]
357impl Encodable for AlterReplicaLogDirsRequest {
358    fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<()> {
359        if version >= 2 {
360            types::CompactArray(types::Struct { version }).encode(buf, &self.dirs)?;
361        } else {
362            types::Array(types::Struct { version }).encode(buf, &self.dirs)?;
363        }
364        if version >= 2 {
365            let num_tagged_fields = self.unknown_tagged_fields.len();
366            if num_tagged_fields > std::u32::MAX as usize {
367                bail!(
368                    "Too many tagged fields to encode ({} fields)",
369                    num_tagged_fields
370                );
371            }
372            types::UnsignedVarInt.encode(buf, num_tagged_fields as u32)?;
373
374            write_unknown_tagged_fields(buf, 0.., &self.unknown_tagged_fields)?;
375        }
376        Ok(())
377    }
378    fn compute_size(&self, version: i16) -> Result<usize> {
379        let mut total_size = 0;
380        if version >= 2 {
381            total_size +=
382                types::CompactArray(types::Struct { version }).compute_size(&self.dirs)?;
383        } else {
384            total_size += types::Array(types::Struct { version }).compute_size(&self.dirs)?;
385        }
386        if version >= 2 {
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            total_size += types::UnsignedVarInt.compute_size(num_tagged_fields as u32)?;
395
396            total_size += compute_unknown_tagged_fields_size(&self.unknown_tagged_fields)?;
397        }
398        Ok(total_size)
399    }
400}
401
402#[cfg(feature = "broker")]
403impl Decodable for AlterReplicaLogDirsRequest {
404    fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self> {
405        let dirs = if version >= 2 {
406            types::CompactArray(types::Struct { version }).decode(buf)?
407        } else {
408            types::Array(types::Struct { version }).decode(buf)?
409        };
410        let mut unknown_tagged_fields = BTreeMap::new();
411        if version >= 2 {
412            let num_tagged_fields = types::UnsignedVarInt.decode(buf)?;
413            for _ in 0..num_tagged_fields {
414                let tag: u32 = types::UnsignedVarInt.decode(buf)?;
415                let size: u32 = types::UnsignedVarInt.decode(buf)?;
416                let unknown_value = buf.try_get_bytes(size as usize)?;
417                unknown_tagged_fields.insert(tag as i32, unknown_value);
418            }
419        }
420        Ok(Self {
421            dirs,
422            unknown_tagged_fields,
423        })
424    }
425}
426
427impl Default for AlterReplicaLogDirsRequest {
428    fn default() -> Self {
429        Self {
430            dirs: Default::default(),
431            unknown_tagged_fields: BTreeMap::new(),
432        }
433    }
434}
435
436impl Message for AlterReplicaLogDirsRequest {
437    const VERSIONS: VersionRange = VersionRange { min: 0, max: 2 };
438    const DEPRECATED_VERSIONS: Option<VersionRange> = Some(VersionRange { min: 0, max: 0 });
439}
440
441impl HeaderVersion for AlterReplicaLogDirsRequest {
442    fn header_version(version: i16) -> i16 {
443        if version >= 2 {
444            2
445        } else {
446            1
447        }
448    }
449}
kafka_protocol/messages/alter_replica_log_dirs_request.rs

kafka_protocol/messages/
alter_replica_log_dirs_request.rs
