krabka_protocol/opt/rustwide/workdir/generated/
UpdateRaftVoterRequest.owned.rs

1// AUTO-GENERATED by krabka-protocol-codegen against a9ce3221537b8653448750697915607dc7936cf3. Do not edit.
2
3use bytes::{Buf, BufMut};
4
5use crate::{
6    Decode, Encode, ProtocolError, UnknownTaggedFields,
7    primitives::{
8        array::{array_len_prefix_len, get_array_len, put_array_len},
9        fixed::{get_i16, get_i32, get_u16, put_i16, put_i32, put_u16},
10        string_bytes::{
11            compact_nullable_string_len, compact_string_len, get_compact_nullable_string_owned,
12            get_compact_string_owned, get_nullable_string_owned, get_string_owned,
13            nullable_string_len, put_compact_nullable_string, put_compact_string,
14            put_nullable_string, put_string, string_len,
15        },
16        uuid::{Uuid, get_uuid, put_uuid},
17    },
18    tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
19};
20pub const API_KEY: i16 = 82;
21pub const MIN_VERSION: i16 = 0;
22pub const MAX_VERSION: i16 = 0;
23pub const LATEST_STABLE_VERSION: i16 = 0;
24pub const FLEXIBLE_MIN: i16 = 0;
25#[inline]
26#[must_use]
27pub fn is_flexible(version: i16) -> bool {
28    version >= FLEXIBLE_MIN
29}
30#[derive(Debug, Clone, PartialEq, Eq)]
31pub struct UpdateRaftVoterRequest {
32    pub cluster_id: Option<String>,
33    pub current_leader_epoch: i32,
34    pub voter_id: i32,
35    pub voter_directory_id: Uuid,
36    pub listeners: Vec<Listener>,
37    pub k_raft_version_feature: KRaftVersionFeature,
38    pub unknown_tagged_fields: UnknownTaggedFields,
39}
40impl Default for UpdateRaftVoterRequest {
41    fn default() -> Self {
42        Self {
43            cluster_id: Some(String::new()),
44            current_leader_epoch: 0i32,
45            voter_id: 0i32,
46            voter_directory_id: Uuid::default(),
47            listeners: Vec::new(),
48            k_raft_version_feature: KRaftVersionFeature::default(),
49            unknown_tagged_fields: UnknownTaggedFields::default(),
50        }
51    }
52}
53impl Encode for UpdateRaftVoterRequest {
54    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
55        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
56            return Err(ProtocolError::UnsupportedVersion {
57                api_key: API_KEY,
58                version,
59            });
60        }
61        let flex = is_flexible(version);
62        if version >= 0 {
63            if flex {
64                put_compact_nullable_string(buf, self.cluster_id.as_deref())?;
65            } else {
66                put_nullable_string(buf, self.cluster_id.as_deref())?;
67            }
68        }
69        if version >= 0 {
70            put_i32(buf, self.current_leader_epoch);
71        }
72        if version >= 0 {
73            put_i32(buf, self.voter_id);
74        }
75        if version >= 0 {
76            put_uuid(buf, self.voter_directory_id);
77        }
78        if version >= 0 {
79            {
80                put_array_len(buf, (self.listeners).len(), flex)?;
81                for it in &self.listeners {
82                    it.encode(buf, version)?;
83                }
84            }
85        }
86        if version >= 0 {
87            self.k_raft_version_feature.encode(buf, version)?;
88        }
89        if flex {
90            let tagged = WriteTaggedFields::new();
91            tagged.write(buf, &self.unknown_tagged_fields)?;
92        }
93        Ok(())
94    }
95    fn encoded_len(&self, version: i16) -> usize {
96        let flex = is_flexible(version);
97        let mut n: usize = 0;
98        if version >= 0 {
99            n += if flex {
100                compact_nullable_string_len(self.cluster_id.as_deref())
101            } else {
102                nullable_string_len(self.cluster_id.as_deref())
103            };
104        }
105        if version >= 0 {
106            n += 4;
107        }
108        if version >= 0 {
109            n += 4;
110        }
111        if version >= 0 {
112            n += 16;
113        }
114        if version >= 0 {
115            n += {
116                let prefix = array_len_prefix_len((self.listeners).len(), flex);
117                let body: usize = (self.listeners)
118                    .iter()
119                    .map(|it| it.encoded_len(version))
120                    .sum();
121                prefix + body
122            };
123        }
124        if version >= 0 {
125            n += self.k_raft_version_feature.encoded_len(version);
126        }
127        if flex {
128            let known_pairs: Vec<(u32, usize)> = Vec::new();
129            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
130        }
131        n
132    }
133}
134impl Decode<'_> for UpdateRaftVoterRequest {
135    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
136        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
137            return Err(ProtocolError::UnsupportedVersion {
138                api_key: API_KEY,
139                version,
140            });
141        }
142        let flex = is_flexible(version);
143        let mut out = Self::default();
144        if version >= 0 {
145            out.cluster_id = if flex {
146                get_compact_nullable_string_owned(buf)?
147            } else {
148                get_nullable_string_owned(buf)?
149            };
150        }
151        if version >= 0 {
152            out.current_leader_epoch = get_i32(buf)?;
153        }
154        if version >= 0 {
155            out.voter_id = get_i32(buf)?;
156        }
157        if version >= 0 {
158            out.voter_directory_id = get_uuid(buf)?;
159        }
160        if version >= 0 {
161            out.listeners = {
162                let n = get_array_len(buf, flex)?;
163                let mut v = Vec::with_capacity(n);
164                for _ in 0..n {
165                    v.push(Listener::decode(buf, version)?);
166                }
167                v
168            };
169        }
170        if version >= 0 {
171            out.k_raft_version_feature = KRaftVersionFeature::decode(buf, version)?;
172        }
173        if flex {
174            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
175        }
176        Ok(out)
177    }
178}
179#[cfg(test)]
180impl UpdateRaftVoterRequest {
181    #[must_use]
182    pub fn populated(version: i16) -> Self {
183        let mut m = Self::default();
184        if version >= 0 {
185            m.cluster_id = Some("x".to_owned());
186        }
187        if version >= 0 {
188            m.current_leader_epoch = 1i32;
189        }
190        if version >= 0 {
191            m.voter_id = 1i32;
192        }
193        if version >= 0 {
194            m.voter_directory_id = Uuid([1u8; 16]);
195        }
196        if version >= 0 {
197            m.listeners = vec![Listener::populated(version)];
198        }
199        if version >= 0 {
200            m.k_raft_version_feature = KRaftVersionFeature::populated(version);
201        }
202        m
203    }
204}
205#[derive(Debug, Clone, PartialEq, Eq, Default)]
206pub struct Listener {
207    pub name: String,
208    pub host: String,
209    pub port: u16,
210    pub unknown_tagged_fields: UnknownTaggedFields,
211}
212impl Encode for Listener {
213    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
214        let flex = version >= 0;
215        if version >= 0 {
216            if flex {
217                put_compact_string(buf, &self.name)?;
218            } else {
219                put_string(buf, &self.name)?;
220            }
221        }
222        if version >= 0 {
223            if flex {
224                put_compact_string(buf, &self.host)?;
225            } else {
226                put_string(buf, &self.host)?;
227            }
228        }
229        if version >= 0 {
230            put_u16(buf, self.port);
231        }
232        if flex {
233            let tagged = WriteTaggedFields::new();
234            tagged.write(buf, &self.unknown_tagged_fields)?;
235        }
236        Ok(())
237    }
238    fn encoded_len(&self, version: i16) -> usize {
239        let flex = version >= 0;
240        let mut n: usize = 0;
241        if version >= 0 {
242            n += if flex {
243                compact_string_len(&self.name)
244            } else {
245                string_len(&self.name)
246            };
247        }
248        if version >= 0 {
249            n += if flex {
250                compact_string_len(&self.host)
251            } else {
252                string_len(&self.host)
253            };
254        }
255        if version >= 0 {
256            n += 2;
257        }
258        if flex {
259            let known_pairs: Vec<(u32, usize)> = Vec::new();
260            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
261        }
262        n
263    }
264}
265impl Decode<'_> for Listener {
266    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
267        let flex = version >= 0;
268        let mut out = Self::default();
269        if version >= 0 {
270            out.name = if flex {
271                get_compact_string_owned(buf)?
272            } else {
273                get_string_owned(buf)?
274            };
275        }
276        if version >= 0 {
277            out.host = if flex {
278                get_compact_string_owned(buf)?
279            } else {
280                get_string_owned(buf)?
281            };
282        }
283        if version >= 0 {
284            out.port = get_u16(buf)?;
285        }
286        if flex {
287            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
288        }
289        Ok(out)
290    }
291}
292#[cfg(test)]
293impl Listener {
294    #[must_use]
295    pub fn populated(version: i16) -> Self {
296        let mut m = Self::default();
297        if version >= 0 {
298            m.name = "x".to_owned();
299        }
300        if version >= 0 {
301            m.host = "x".to_owned();
302        }
303        if version >= 0 {
304            m.port = 1u16;
305        }
306        m
307    }
308}
309#[derive(Debug, Clone, PartialEq, Eq, Default)]
310pub struct KRaftVersionFeature {
311    pub min_supported_version: i16,
312    pub max_supported_version: i16,
313    pub unknown_tagged_fields: UnknownTaggedFields,
314}
315impl Encode for KRaftVersionFeature {
316    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
317        let flex = version >= 0;
318        if version >= 0 {
319            put_i16(buf, self.min_supported_version);
320        }
321        if version >= 0 {
322            put_i16(buf, self.max_supported_version);
323        }
324        if flex {
325            let tagged = WriteTaggedFields::new();
326            tagged.write(buf, &self.unknown_tagged_fields)?;
327        }
328        Ok(())
329    }
330    fn encoded_len(&self, version: i16) -> usize {
331        let flex = version >= 0;
332        let mut n: usize = 0;
333        if version >= 0 {
334            n += 2;
335        }
336        if version >= 0 {
337            n += 2;
338        }
339        if flex {
340            let known_pairs: Vec<(u32, usize)> = Vec::new();
341            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
342        }
343        n
344    }
345}
346impl Decode<'_> for KRaftVersionFeature {
347    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
348        let flex = version >= 0;
349        let mut out = Self::default();
350        if version >= 0 {
351            out.min_supported_version = get_i16(buf)?;
352        }
353        if version >= 0 {
354            out.max_supported_version = get_i16(buf)?;
355        }
356        if flex {
357            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
358        }
359        Ok(out)
360    }
361}
362#[cfg(test)]
363impl KRaftVersionFeature {
364    #[must_use]
365    pub fn populated(version: i16) -> Self {
366        let mut m = Self::default();
367        if version >= 0 {
368            m.min_supported_version = 1i16;
369        }
370        if version >= 0 {
371            m.max_supported_version = 1i16;
372        }
373        m
374    }
375}
376/// Default JSON payload matching `Self::default()` for JVM oracle differential testing.
377/// Only includes fields valid for the given version.
378#[must_use]
379#[allow(unused_comparisons)]
380pub fn default_json(_version: i16) -> ::serde_json::Value {
381    let mut obj = ::serde_json::Map::new();
382    obj.insert(
383        "clusterId".to_owned(),
384        ::serde_json::Value::String(String::new()),
385    );
386    obj.insert("currentLeaderEpoch".to_owned(), ::serde_json::json!(0));
387    obj.insert("voterId".to_owned(), ::serde_json::json!(0));
388    obj.insert(
389        "voterDirectoryId".to_owned(),
390        ::serde_json::Value::String("AAAAAAAAAAAAAAAAAAAAAA".to_owned()),
391    );
392    obj.insert("listeners".to_owned(), ::serde_json::Value::Array(vec![]));
393    obj.insert("kRaftVersionFeature".to_owned(), {
394        let mut m = ::serde_json::Map::new();
395        m.insert("minSupportedVersion".to_owned(), ::serde_json::json!(0));
396        m.insert("maxSupportedVersion".to_owned(), ::serde_json::json!(0));
397        ::serde_json::Value::Object(m)
398    });
399    ::serde_json::Value::Object(obj)
400}
401impl crate::ProtocolRequest for UpdateRaftVoterRequest {
402    const API_KEY: i16 = API_KEY;
403    const MIN_VERSION: i16 = MIN_VERSION;
404    const MAX_VERSION: i16 = MAX_VERSION;
405    const LATEST_STABLE_VERSION: i16 = LATEST_STABLE_VERSION;
406    const FLEXIBLE_MIN: i16 = FLEXIBLE_MIN;
407    type Response = super::update_raft_voter_response::UpdateRaftVoterResponse;
408}
krabka_protocol/opt/rustwide/workdir/generated/UpdateRaftVoterRequest.owned.rs

krabka_protocol/opt/rustwide/workdir/generated/
UpdateRaftVoterRequest.owned.rs
