krabka_protocol/opt/rustwide/workdir/generated/
BrokerHeartbeatRequest.borrowed.rs

1// AUTO-GENERATED by krabka-protocol-codegen against a9ce3221537b8653448750697915607dc7936cf3. Do not edit.
2use bytes::BufMut;
3
4use crate::{
5    DecodeBorrow, Encode, ProtocolError, UnknownTaggedFields,
6    primitives::fixed::{get_bool, get_i32, get_i64, put_bool, put_i32, put_i64},
7    tagged_fields::{WriteTaggedFields, encode_to_bytes, read_tagged_fields, tagged_fields_len},
8};
9pub const API_KEY: i16 = 63;
10pub const MIN_VERSION: i16 = 0;
11pub const MAX_VERSION: i16 = 2;
12pub const LATEST_STABLE_VERSION: i16 = 2;
13pub const FLEXIBLE_MIN: i16 = 0;
14#[inline]
15#[must_use]
16pub fn is_flexible(version: i16) -> bool {
17    version >= FLEXIBLE_MIN
18}
19#[derive(Debug, Clone, PartialEq, Eq)]
20pub struct BrokerHeartbeatRequest {
21    pub broker_id: i32,
22    pub broker_epoch: i64,
23    pub current_metadata_offset: i64,
24    pub want_fence: bool,
25    pub want_shut_down: bool,
26    pub offline_log_dirs: Vec<crate::primitives::uuid::Uuid>,
27    pub cordoned_log_dirs: Option<Vec<crate::primitives::uuid::Uuid>>,
28    pub unknown_tagged_fields: UnknownTaggedFields,
29}
30impl Default for BrokerHeartbeatRequest {
31    fn default() -> Self {
32        Self {
33            broker_id: 0i32,
34            broker_epoch: -1i64,
35            current_metadata_offset: 0i64,
36            want_fence: false,
37            want_shut_down: false,
38            offline_log_dirs: Vec::new(),
39            cordoned_log_dirs: None,
40            unknown_tagged_fields: UnknownTaggedFields::default(),
41        }
42    }
43}
44impl BrokerHeartbeatRequest {
45    /// # Panics
46    ///
47    /// Panics if a records field contains an invalid encoded record batch.
48    #[must_use]
49    pub fn to_owned(&self) -> crate::owned::broker_heartbeat_request::BrokerHeartbeatRequest {
50        crate::owned::broker_heartbeat_request::BrokerHeartbeatRequest {
51            broker_id: (self.broker_id),
52            broker_epoch: (self.broker_epoch),
53            current_metadata_offset: (self.current_metadata_offset),
54            want_fence: (self.want_fence),
55            want_shut_down: (self.want_shut_down),
56            offline_log_dirs: (self.offline_log_dirs).clone(),
57            cordoned_log_dirs: (self.cordoned_log_dirs).clone(),
58            unknown_tagged_fields: self.unknown_tagged_fields.clone(),
59        }
60    }
61}
62impl Encode for BrokerHeartbeatRequest {
63    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
64        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
65            return Err(ProtocolError::UnsupportedVersion {
66                api_key: API_KEY,
67                version,
68            });
69        }
70        let flex = is_flexible(version);
71        if version >= 0 {
72            put_i32(buf, self.broker_id);
73        }
74        if version >= 0 {
75            put_i64(buf, self.broker_epoch);
76        }
77        if version >= 0 {
78            put_i64(buf, self.current_metadata_offset);
79        }
80        if version >= 0 {
81            put_bool(buf, self.want_fence);
82        }
83        if version >= 0 {
84            put_bool(buf, self.want_shut_down);
85        }
86        if flex {
87            let mut tagged = WriteTaggedFields::new();
88            if version >= 1 && !(crate::codegen_helpers::is_default(&self.offline_log_dirs)) {
89                let payload = encode_to_bytes(
90                    {
91                        let prefix = crate::primitives::array::array_len_prefix_len(
92                            (self.offline_log_dirs).len(),
93                            flex,
94                        );
95                        let body: usize = (self.offline_log_dirs).iter().map(|_| 16).sum();
96                        prefix + body
97                    },
98                    |b| {
99                        {
100                            crate::primitives::array::put_array_len(
101                                b,
102                                (self.offline_log_dirs).len(),
103                                flex,
104                            );
105                            for it in &self.offline_log_dirs {
106                                crate::primitives::uuid::put_uuid(b, *it);
107                            }
108                        };
109                        Ok(())
110                    },
111                );
112                tagged.add(0, payload);
113            }
114            if version >= 2 && self.cordoned_log_dirs.is_some() {
115                let payload = encode_to_bytes(
116                    {
117                        let opt: Option<&Vec<_>> = (self.cordoned_log_dirs).as_ref();
118                        let prefix = crate::primitives::array::nullable_array_len_prefix_len(
119                            opt.map(std::vec::Vec::len),
120                            flex,
121                        );
122                        let body: usize = opt.map_or(0, |v| v.iter().map(|_| 16).sum());
123                        prefix + body
124                    },
125                    |b| {
126                        {
127                            let len = (self.cordoned_log_dirs).as_ref().map(Vec::len);
128                            crate::primitives::array::put_nullable_array_len(b, len, flex);
129                            if let Some(v) = &self.cordoned_log_dirs {
130                                for it in v {
131                                    crate::primitives::uuid::put_uuid(b, *it);
132                                }
133                            }
134                        };
135                        Ok(())
136                    },
137                );
138                tagged.add(1, payload);
139            }
140            tagged.write(buf, &self.unknown_tagged_fields);
141        }
142        Ok(())
143    }
144    fn encoded_len(&self, version: i16) -> usize {
145        let flex = is_flexible(version);
146        let mut n: usize = 0;
147        if version >= 0 {
148            n += 4;
149        }
150        if version >= 0 {
151            n += 8;
152        }
153        if version >= 0 {
154            n += 8;
155        }
156        if version >= 0 {
157            n += 1;
158        }
159        if version >= 0 {
160            n += 1;
161        }
162        if flex {
163            let mut known_pairs: Vec<(u32, usize)> = Vec::new();
164            if version >= 1 && !(crate::codegen_helpers::is_default(&self.offline_log_dirs)) {
165                known_pairs.push((0, {
166                    let prefix = crate::primitives::array::array_len_prefix_len(
167                        (self.offline_log_dirs).len(),
168                        flex,
169                    );
170                    let body: usize = (self.offline_log_dirs).iter().map(|_| 16).sum();
171                    prefix + body
172                }));
173            }
174            if version >= 2 && self.cordoned_log_dirs.is_some() {
175                known_pairs.push((1, {
176                    let opt: Option<&Vec<_>> = (self.cordoned_log_dirs).as_ref();
177                    let prefix = crate::primitives::array::nullable_array_len_prefix_len(
178                        opt.map(std::vec::Vec::len),
179                        flex,
180                    );
181                    let body: usize = opt.map_or(0, |v| v.iter().map(|_| 16).sum());
182                    prefix + body
183                }));
184            }
185            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
186        }
187        n
188    }
189}
190impl<'de> DecodeBorrow<'de> for BrokerHeartbeatRequest {
191    fn decode_borrow(buf: &mut &'de [u8], version: i16) -> Result<Self, ProtocolError> {
192        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
193            return Err(ProtocolError::UnsupportedVersion {
194                api_key: API_KEY,
195                version,
196            });
197        }
198        let flex = is_flexible(version);
199        let mut out = Self::default();
200        if version >= 0 {
201            out.broker_id = get_i32(buf)?;
202        }
203        if version >= 0 {
204            out.broker_epoch = get_i64(buf)?;
205        }
206        if version >= 0 {
207            out.current_metadata_offset = get_i64(buf)?;
208        }
209        if version >= 0 {
210            out.want_fence = get_bool(buf)?;
211        }
212        if version >= 0 {
213            out.want_shut_down = get_bool(buf)?;
214        }
215        if flex {
216            let mut tag_offline_log_dirs = None;
217            let mut tag_cordoned_log_dirs = None;
218            out.unknown_tagged_fields = read_tagged_fields(buf, |tag, payload| match tag {
219                0 if version >= 1 => {
220                    tag_offline_log_dirs = Some({
221                        let b: &mut &[u8] = payload;
222                        {
223                            let n = crate::primitives::array::get_array_len(b, flex)?;
224                            let mut v = Vec::with_capacity(n);
225                            for _ in 0..n {
226                                v.push(crate::primitives::uuid::get_uuid(b)?);
227                            }
228                            v
229                        }
230                    });
231                    Ok(true)
232                }
233                0 => Err(ProtocolError::TagNotValidForVersion { tag: 0, version }),
234                1 if version >= 2 => {
235                    tag_cordoned_log_dirs = Some({
236                        let b: &mut &[u8] = payload;
237                        {
238                            let opt = crate::primitives::array::get_nullable_array_len(b, flex)?;
239                            match opt {
240                                None => None,
241                                Some(n) => {
242                                    let mut v = Vec::with_capacity(n);
243                                    for _ in 0..n {
244                                        v.push(crate::primitives::uuid::get_uuid(b)?);
245                                    }
246                                    Some(v)
247                                }
248                            }
249                        }
250                    });
251                    Ok(true)
252                }
253                1 => Err(ProtocolError::TagNotValidForVersion { tag: 1, version }),
254                _ => Ok(false),
255            })?;
256            if let Some(v) = tag_offline_log_dirs {
257                out.offline_log_dirs = v;
258            }
259            if let Some(v) = tag_cordoned_log_dirs {
260                out.cordoned_log_dirs = v;
261            }
262        }
263        Ok(out)
264    }
265}
266#[cfg(test)]
267impl BrokerHeartbeatRequest {
268    #[must_use]
269    pub fn populated(version: i16) -> Self {
270        let mut m = Self::default();
271        if version >= 0 {
272            m.broker_id = 1i32;
273        }
274        if version >= 0 {
275            m.broker_epoch = 1i64;
276        }
277        if version >= 0 {
278            m.current_metadata_offset = 1i64;
279        }
280        if version >= 0 {
281            m.want_fence = true;
282        }
283        if version >= 0 {
284            m.want_shut_down = true;
285        }
286        if version >= 1 {
287            m.offline_log_dirs = vec![crate::primitives::uuid::Uuid([1u8; 16])];
288        }
289        if version >= 2 {
290            m.cordoned_log_dirs = Some(vec![crate::primitives::uuid::Uuid([1u8; 16])]);
291        }
292        m
293    }
294}
krabka_protocol/opt/rustwide/workdir/generated/BrokerHeartbeatRequest.borrowed.rs

krabka_protocol/opt/rustwide/workdir/generated/
BrokerHeartbeatRequest.borrowed.rs
