crabka_protocol/opt/rustwide/workdir/generated/
UpdateRaftVoterResponse.owned.rs1use bytes::{Buf, BufMut};
4
5use crate::primitives::fixed::{get_i16, get_i32, put_i16, put_i32};
6use crate::primitives::string_bytes::{
7 compact_string_len, get_compact_string_owned, get_string_owned,
8 put_compact_string, put_string, string_len,
9};
10use crate::tagged_fields::{encode_to_bytes, read_tagged_fields, tagged_fields_len, WriteTaggedFields};
11use crate::{Decode, Encode, ProtocolError, UnknownTaggedFields};
12
13pub const API_KEY: i16 = 82;
14pub const MIN_VERSION: i16 = 0;
15pub const MAX_VERSION: i16 = 0;
16pub const FLEXIBLE_MIN: i16 = 0;
17
18#[inline]
19fn is_flexible(version: i16) -> bool { version >= FLEXIBLE_MIN }
20
21#[derive(Debug, Clone, PartialEq, Eq, Default)]
22pub struct UpdateRaftVoterResponse {
23 pub throttle_time_ms: i32,
24 pub error_code: i16,
25 pub current_leader: CurrentLeader,
26 pub unknown_tagged_fields: UnknownTaggedFields,
27}
28
29impl Encode for UpdateRaftVoterResponse {
30 fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
31 if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
32 return Err(ProtocolError::UnsupportedVersion { api_key: API_KEY, version });
33 }
34 let flex = is_flexible(version);
35 if version >= 0 { put_i32(buf, self.throttle_time_ms) }
36 if version >= 0 { put_i16(buf, self.error_code) }
37 if flex {
38 let mut tagged = WriteTaggedFields::new();
39 if !(crate::codegen_helpers::is_default(&self.current_leader)) {
40 let payload = encode_to_bytes(self.current_leader.encoded_len(version), |b| { self.current_leader.encode(b, version)?; Ok(()) });
41 tagged.add(0, payload);
42 }
43 tagged.write(buf, &self.unknown_tagged_fields);
44 }
45 Ok(())
46 }
47 fn encoded_len(&self, version: i16) -> usize {
48 let flex = is_flexible(version);
49 let mut n: usize = 0;
50 if version >= 0 { n += 4; }
51 if version >= 0 { n += 2; }
52 if flex {
53 let mut known_pairs: Vec<(u32, usize)> = Vec::new();
54 if !(crate::codegen_helpers::is_default(&self.current_leader)) {
55 known_pairs.push((0, self.current_leader.encoded_len(version)));
56 }
57 n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
58 }
59 n
60 }
61}
62
63impl<'de> Decode<'de> for UpdateRaftVoterResponse {
64 fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
65 if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
66 return Err(ProtocolError::UnsupportedVersion { api_key: API_KEY, version });
67 }
68 let flex = is_flexible(version);
69 let mut out = Self::default();
70 if version >= 0 { out.throttle_time_ms = get_i32(buf)?; }
71 if version >= 0 { out.error_code = get_i16(buf)?; }
72 if flex {
73 let mut tag_current_leader = None;
75 out.unknown_tagged_fields = read_tagged_fields(buf, |tag, payload| {
76 match tag {
77 0 => { tag_current_leader = Some({ let b: &mut &[u8] = payload; CurrentLeader::decode(b, version)? }); Ok(true) }
78 _ => Ok(false),
79 }
80 })?;
81 if let Some(v) = tag_current_leader { out.current_leader = v; }
82 }
83 Ok(out)
84 }
85}
86
87#[derive(Debug, Clone, PartialEq, Eq)]
88pub struct CurrentLeader {
89 pub leader_id: i32,
90 pub leader_epoch: i32,
91 pub host: String,
92 pub port: i32,
93 pub unknown_tagged_fields: UnknownTaggedFields,
94}
95
96impl Default for CurrentLeader {
97 fn default() -> Self {
98 Self {
99 leader_id: -1i32,
100 leader_epoch: -1i32,
101 host: String::new(),
102 port: 0i32,
103 unknown_tagged_fields: Default::default(),
104 }
105 }
106}
107
108impl Encode for CurrentLeader {
109 fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
110 let flex = version >= 0;
111 if version >= 0 { put_i32(buf, self.leader_id) }
112 if version >= 0 { put_i32(buf, self.leader_epoch) }
113 if version >= 0 { if flex { put_compact_string(buf, &self.host) } else { put_string(buf, &self.host) } }
114 if version >= 0 { put_i32(buf, self.port) }
115 if flex {
116 let tagged = WriteTaggedFields::new();
117 tagged.write(buf, &self.unknown_tagged_fields);
118 }
119 Ok(())
120 }
121 fn encoded_len(&self, version: i16) -> usize {
122 let flex = version >= 0;
123 let mut n: usize = 0;
124 if version >= 0 { n += 4; }
125 if version >= 0 { n += 4; }
126 if version >= 0 { n += if flex { compact_string_len(&self.host) } else { string_len(&self.host) }; }
127 if version >= 0 { n += 4; }
128 if flex {
129 let known_pairs: Vec<(u32, usize)> = Vec::new();
130 n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
131 }
132 n
133 }
134}
135
136impl<'de> Decode<'de> for CurrentLeader {
137 fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
138 let flex = version >= 0;
139 let mut out = Self::default();
140 if version >= 0 { out.leader_id = get_i32(buf)?; }
141 if version >= 0 { out.leader_epoch = get_i32(buf)?; }
142 if version >= 0 { out.host = if flex { get_compact_string_owned(buf)? } else { get_string_owned(buf)? }; }
143 if version >= 0 { out.port = get_i32(buf)?; }
144 if flex {
145 out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| {
146 Ok(false)
147 })?;
148 }
149 Ok(out)
150 }
151}
152
153#[must_use]
156#[allow(unused_comparisons)]
157pub fn default_json(version: i16) -> ::serde_json::Value {
158 let mut obj = ::serde_json::Map::new();
159 obj.insert("throttleTimeMs".to_string(), ::serde_json::json!(0));
160 obj.insert("errorCode".to_string(), ::serde_json::json!(0));
161 obj.insert("currentLeader".to_string(), { let mut m = ::serde_json::Map::new(); m.insert("leaderId".to_string(), ::serde_json::json!(-1)); m.insert("leaderEpoch".to_string(), ::serde_json::json!(-1)); m.insert("host".to_string(), ::serde_json::Value::String(String::new())); m.insert("port".to_string(), ::serde_json::json!(0)); ::serde_json::Value::Object(m) });
162 ::serde_json::Value::Object(obj)
163}