kacrab_protocol/generated/
delete_topics_response.rs

1//! Generated from DeleteTopicsResponse.json - DO NOT EDIT
2#![allow(
3    missing_docs,
4    clippy::all,
5    clippy::pedantic,
6    clippy::nursery,
7    clippy::arithmetic_side_effects,
8    reason = "Generated protocol modules mirror Kafka's schema shape and intentionally trade \
9              hand-written lint style for reproducible wire-code output."
10)]
11use bytes::{Bytes, BytesMut};
12
13use crate::*;
14
15#[derive(Debug, Clone, PartialEq)]
16pub struct DeleteTopicsResponseData {
17    /// The duration in milliseconds for which the request was throttled due to a quota violation,
18    /// or zero if the request did not violate any quota.
19    pub throttle_time_ms: i32,
20    /// The results for each topic we tried to delete.
21    pub responses: Vec<DeletableTopicResult>,
22    pub _unknown_tagged_fields: Vec<RawTaggedField>,
23}
24impl Default for DeleteTopicsResponseData {
25    fn default() -> Self {
26        Self {
27            throttle_time_ms: 0_i32,
28            responses: Vec::new(),
29            _unknown_tagged_fields: Vec::new(),
30        }
31    }
32}
33impl DeleteTopicsResponseData {
34    pub fn with_throttle_time_ms(mut self, value: i32) -> Self {
35        self.throttle_time_ms = value;
36        self
37    }
38    pub fn with_responses(mut self, value: Vec<DeletableTopicResult>) -> Self {
39        self.responses = value;
40        self
41    }
42    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
43        if version < 1 || version > 6 {
44            return Err(UnsupportedVersion::new(20, version).into());
45        }
46        let throttle_time_ms;
47        let responses;
48        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
49        throttle_time_ms = read_i32(buf)?;
50        if version >= 4 {
51            responses = {
52                let len = read_compact_array_length(buf)?;
53                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
54                for _ in 0..len {
55                    arr.push(DeletableTopicResult::read(buf, version)?);
56                }
57                arr
58            };
59        } else {
60            responses = {
61                let len = read_array_length(buf)?;
62                let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
63                for _ in 0..len {
64                    arr.push(DeletableTopicResult::read(buf, version)?);
65                }
66                arr
67            };
68        }
69        if version >= 4 {
70            let tagged_fields = read_tagged_fields(buf)?;
71            for field in &tagged_fields {
72                match field.tag {
73                    _ => {
74                        _unknown_tagged_fields.push(field.clone());
75                    },
76                }
77            }
78        }
79        Ok(Self {
80            throttle_time_ms,
81            responses,
82            _unknown_tagged_fields,
83        })
84    }
85    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
86        if version < 1 || version > 6 {
87            return Err(UnsupportedVersion::new(20, version).into());
88        }
89        write_i32(buf, self.throttle_time_ms);
90        if version >= 4 {
91            write_compact_array_length(buf, self.responses.len() as i32);
92            for el in &self.responses {
93                el.write(buf, version)?;
94            }
95        } else {
96            write_array_length(buf, self.responses.len() as i32);
97            for el in &self.responses {
98                el.write(buf, version)?;
99            }
100        }
101        if version >= 4 {
102            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
103            all_tags.sort_by_key(|f| f.tag);
104            write_tagged_fields(buf, &all_tags)?;
105        }
106        Ok(())
107    }
108    pub fn encoded_len(&self, version: i16) -> Result<usize> {
109        if version < 1 || version > 6 {
110            return Err(UnsupportedVersion::new(20, version).into());
111        }
112        let mut len: usize = 0;
113        len += 4;
114        if version >= 4 {
115            len += compact_array_length_len(self.responses.len() as i32);
116            for el in &self.responses {
117                len += el.encoded_len(version)?;
118            }
119        } else {
120            len += array_length_len();
121            for el in &self.responses {
122                len += el.encoded_len(version)?;
123            }
124        }
125        if version >= 4 {
126            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
127            all_tags.sort_by_key(|f| f.tag);
128            len += tagged_fields_len(&all_tags)?;
129        }
130        Ok(len)
131    }
132}
133#[derive(Debug, Clone, PartialEq)]
134pub struct DeletableTopicResult {
135    /// The topic name.
136    pub name: Option<KafkaString>,
137    /// The unique topic ID.
138    pub topic_id: KafkaUuid,
139    /// The deletion error, or 0 if the deletion succeeded.
140    pub error_code: i16,
141    /// The error message, or null if there was no error.
142    pub error_message: Option<KafkaString>,
143    pub _unknown_tagged_fields: Vec<RawTaggedField>,
144}
145impl Default for DeletableTopicResult {
146    fn default() -> Self {
147        Self {
148            name: None,
149            topic_id: KafkaUuid::ZERO,
150            error_code: 0_i16,
151            error_message: None,
152            _unknown_tagged_fields: Vec::new(),
153        }
154    }
155}
156impl DeletableTopicResult {
157    pub fn with_name(mut self, value: Option<KafkaString>) -> Self {
158        self.name = value;
159        self
160    }
161    pub fn with_topic_id(mut self, value: KafkaUuid) -> Self {
162        self.topic_id = value;
163        self
164    }
165    pub fn with_error_code(mut self, value: i16) -> Self {
166        self.error_code = value;
167        self
168    }
169    pub fn with_error_message(mut self, value: Option<KafkaString>) -> Self {
170        self.error_message = value;
171        self
172    }
173    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
174        let name;
175        let mut topic_id = KafkaUuid::ZERO;
176        let error_code;
177        let mut error_message = None;
178        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
179        if version >= 6 {
180            name = read_compact_nullable_string(buf)?;
181        } else {
182            if version >= 4 {
183                name = Some(read_compact_string(buf)?);
184            } else {
185                name = Some(read_string(buf)?);
186            }
187        }
188        if version >= 6 {
189            topic_id = read_uuid(buf)?;
190        }
191        error_code = read_i16(buf)?;
192        if version >= 5 {
193            error_message = read_compact_nullable_string(buf)?;
194        }
195        if version >= 4 {
196            let tagged_fields = read_tagged_fields(buf)?;
197            for field in &tagged_fields {
198                match field.tag {
199                    _ => {
200                        _unknown_tagged_fields.push(field.clone());
201                    },
202                }
203            }
204        }
205        Ok(Self {
206            name,
207            topic_id,
208            error_code,
209            error_message,
210            _unknown_tagged_fields,
211        })
212    }
213    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
214        if version >= 6 {
215            write_compact_nullable_string(buf, self.name.as_ref())?;
216        } else {
217            {
218                let _nn_default = KafkaString::default();
219                let _nn_val = self.name.as_ref().unwrap_or(&_nn_default);
220                if version >= 4 {
221                    write_compact_string(buf, _nn_val)?;
222                } else {
223                    write_string(buf, _nn_val)?;
224                }
225            }
226        }
227        if version >= 6 {
228            write_uuid(buf, &self.topic_id);
229        } else if self.topic_id != KafkaUuid::ZERO {
230            return Err(UnsupportedFieldVersion::new(20, "topic_id", version).into());
231        }
232        write_i16(buf, self.error_code);
233        if version >= 5 {
234            write_compact_nullable_string(buf, self.error_message.as_ref())?;
235        } else if self.error_message != None {
236            return Err(UnsupportedFieldVersion::new(20, "error_message", version).into());
237        }
238        if version >= 4 {
239            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
240            all_tags.sort_by_key(|f| f.tag);
241            write_tagged_fields(buf, &all_tags)?;
242        }
243        Ok(())
244    }
245    pub fn encoded_len(&self, version: i16) -> Result<usize> {
246        let mut len: usize = 0;
247        if version >= 6 {
248            len += compact_nullable_string_len(self.name.as_ref())?;
249        } else {
250            let _nn_default = KafkaString::default();
251            let _nn_val = self.name.as_ref().unwrap_or(&_nn_default);
252            if version >= 4 {
253                len += compact_string_len(_nn_val)?;
254            } else {
255                len += string_len(_nn_val)?;
256            }
257        }
258        if version >= 6 {
259            len += 16;
260        } else if self.topic_id != KafkaUuid::ZERO {
261            return Err(UnsupportedFieldVersion::new(20, "topic_id", version).into());
262        }
263        len += 2;
264        if version >= 5 {
265            len += compact_nullable_string_len(self.error_message.as_ref())?;
266        } else if self.error_message != None {
267            return Err(UnsupportedFieldVersion::new(20, "error_message", version).into());
268        }
269        if version >= 4 {
270            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
271            all_tags.sort_by_key(|f| f.tag);
272            len += tagged_fields_len(&all_tags)?;
273        }
274        Ok(len)
275    }
276}
kacrab_protocol/generated/delete_topics_response.rs

kacrab_protocol/generated/
delete_topics_response.rs
