krabka_protocol/opt/rustwide/workdir/generated/
ListTransactionsResponse.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_i64, put_i16, put_i32, put_i64},
10        string_bytes::{
11            compact_string_len, get_compact_string_owned, get_string_owned, put_compact_string,
12            put_string, string_len,
13        },
14    },
15    tagged_fields::{WriteTaggedFields, read_tagged_fields, tagged_fields_len},
16};
17pub const API_KEY: i16 = 66;
18pub const MIN_VERSION: i16 = 0;
19pub const MAX_VERSION: i16 = 2;
20pub const FLEXIBLE_MIN: i16 = 0;
21#[inline]
22#[must_use]
23pub fn is_flexible(version: i16) -> bool {
24    version >= FLEXIBLE_MIN
25}
26#[derive(Debug, Clone, PartialEq, Eq, Default)]
27pub struct ListTransactionsResponse {
28    pub throttle_time_ms: i32,
29    pub error_code: i16,
30    pub unknown_state_filters: Vec<String>,
31    pub transaction_states: Vec<TransactionState>,
32    pub unknown_tagged_fields: UnknownTaggedFields,
33}
34impl Encode for ListTransactionsResponse {
35    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
36        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
37            return Err(ProtocolError::UnsupportedVersion {
38                api_key: API_KEY,
39                version,
40            });
41        }
42        let flex = is_flexible(version);
43        if version >= 0 {
44            put_i32(buf, self.throttle_time_ms);
45        }
46        if version >= 0 {
47            put_i16(buf, self.error_code);
48        }
49        if version >= 0 {
50            {
51                put_array_len(buf, (self.unknown_state_filters).len(), flex)?;
52                for it in &self.unknown_state_filters {
53                    if flex {
54                        put_compact_string(buf, it)?;
55                    } else {
56                        put_string(buf, it)?;
57                    }
58                }
59            }
60        }
61        if version >= 0 {
62            {
63                put_array_len(buf, (self.transaction_states).len(), flex)?;
64                for it in &self.transaction_states {
65                    it.encode(buf, version)?;
66                }
67            }
68        }
69        if flex {
70            let tagged = WriteTaggedFields::new();
71            tagged.write(buf, &self.unknown_tagged_fields)?;
72        }
73        Ok(())
74    }
75    fn encoded_len(&self, version: i16) -> usize {
76        let flex = is_flexible(version);
77        let mut n: usize = 0;
78        if version >= 0 {
79            n += 4;
80        }
81        if version >= 0 {
82            n += 2;
83        }
84        if version >= 0 {
85            n += {
86                let prefix = array_len_prefix_len((self.unknown_state_filters).len(), flex);
87                let body: usize = (self.unknown_state_filters)
88                    .iter()
89                    .map(|it| {
90                        if flex {
91                            compact_string_len(it)
92                        } else {
93                            string_len(it)
94                        }
95                    })
96                    .sum();
97                prefix + body
98            };
99        }
100        if version >= 0 {
101            n += {
102                let prefix = array_len_prefix_len((self.transaction_states).len(), flex);
103                let body: usize = (self.transaction_states)
104                    .iter()
105                    .map(|it| it.encoded_len(version))
106                    .sum();
107                prefix + body
108            };
109        }
110        if flex {
111            let known_pairs: Vec<(u32, usize)> = Vec::new();
112            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
113        }
114        n
115    }
116}
117impl Decode<'_> for ListTransactionsResponse {
118    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
119        if !(MIN_VERSION..=MAX_VERSION).contains(&version) {
120            return Err(ProtocolError::UnsupportedVersion {
121                api_key: API_KEY,
122                version,
123            });
124        }
125        let flex = is_flexible(version);
126        let mut out = Self::default();
127        if version >= 0 {
128            out.throttle_time_ms = get_i32(buf)?;
129        }
130        if version >= 0 {
131            out.error_code = get_i16(buf)?;
132        }
133        if version >= 0 {
134            out.unknown_state_filters = {
135                let n = get_array_len(buf, flex)?;
136                let mut v = Vec::with_capacity(n);
137                for _ in 0..n {
138                    v.push(if flex {
139                        get_compact_string_owned(buf)?
140                    } else {
141                        get_string_owned(buf)?
142                    });
143                }
144                v
145            };
146        }
147        if version >= 0 {
148            out.transaction_states = {
149                let n = get_array_len(buf, flex)?;
150                let mut v = Vec::with_capacity(n);
151                for _ in 0..n {
152                    v.push(TransactionState::decode(buf, version)?);
153                }
154                v
155            };
156        }
157        if flex {
158            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
159        }
160        Ok(out)
161    }
162}
163#[cfg(test)]
164impl ListTransactionsResponse {
165    #[must_use]
166    pub fn populated(version: i16) -> Self {
167        let mut m = Self::default();
168        if version >= 0 {
169            m.throttle_time_ms = 1i32;
170        }
171        if version >= 0 {
172            m.error_code = 1i16;
173        }
174        if version >= 0 {
175            m.unknown_state_filters = vec!["x".to_owned()];
176        }
177        if version >= 0 {
178            m.transaction_states = vec![TransactionState::populated(version)];
179        }
180        m
181    }
182}
183#[derive(Debug, Clone, PartialEq, Eq, Default)]
184pub struct TransactionState {
185    pub transactional_id: String,
186    pub producer_id: i64,
187    pub transaction_state: String,
188    pub unknown_tagged_fields: UnknownTaggedFields,
189}
190impl Encode for TransactionState {
191    fn encode<B: BufMut>(&self, buf: &mut B, version: i16) -> Result<(), ProtocolError> {
192        let flex = version >= 0;
193        if version >= 0 {
194            if flex {
195                put_compact_string(buf, &self.transactional_id)?;
196            } else {
197                put_string(buf, &self.transactional_id)?;
198            }
199        }
200        if version >= 0 {
201            put_i64(buf, self.producer_id);
202        }
203        if version >= 0 {
204            if flex {
205                put_compact_string(buf, &self.transaction_state)?;
206            } else {
207                put_string(buf, &self.transaction_state)?;
208            }
209        }
210        if flex {
211            let tagged = WriteTaggedFields::new();
212            tagged.write(buf, &self.unknown_tagged_fields)?;
213        }
214        Ok(())
215    }
216    fn encoded_len(&self, version: i16) -> usize {
217        let flex = version >= 0;
218        let mut n: usize = 0;
219        if version >= 0 {
220            n += if flex {
221                compact_string_len(&self.transactional_id)
222            } else {
223                string_len(&self.transactional_id)
224            };
225        }
226        if version >= 0 {
227            n += 8;
228        }
229        if version >= 0 {
230            n += if flex {
231                compact_string_len(&self.transaction_state)
232            } else {
233                string_len(&self.transaction_state)
234            };
235        }
236        if flex {
237            let known_pairs: Vec<(u32, usize)> = Vec::new();
238            n += tagged_fields_len(&known_pairs, &self.unknown_tagged_fields);
239        }
240        n
241    }
242}
243impl Decode<'_> for TransactionState {
244    fn decode<B: Buf>(buf: &mut B, version: i16) -> Result<Self, ProtocolError> {
245        let flex = version >= 0;
246        let mut out = Self::default();
247        if version >= 0 {
248            out.transactional_id = if flex {
249                get_compact_string_owned(buf)?
250            } else {
251                get_string_owned(buf)?
252            };
253        }
254        if version >= 0 {
255            out.producer_id = get_i64(buf)?;
256        }
257        if version >= 0 {
258            out.transaction_state = if flex {
259                get_compact_string_owned(buf)?
260            } else {
261                get_string_owned(buf)?
262            };
263        }
264        if flex {
265            out.unknown_tagged_fields = read_tagged_fields(buf, |_tag, _payload| Ok(false))?;
266        }
267        Ok(out)
268    }
269}
270#[cfg(test)]
271impl TransactionState {
272    #[must_use]
273    pub fn populated(version: i16) -> Self {
274        let mut m = Self::default();
275        if version >= 0 {
276            m.transactional_id = "x".to_owned();
277        }
278        if version >= 0 {
279            m.producer_id = 1i64;
280        }
281        if version >= 0 {
282            m.transaction_state = "x".to_owned();
283        }
284        m
285    }
286}
287/// Default JSON payload matching `Self::default()` for JVM oracle differential testing.
288/// Only includes fields valid for the given version.
289#[must_use]
290#[allow(unused_comparisons)]
291pub fn default_json(_version: i16) -> ::serde_json::Value {
292    let mut obj = ::serde_json::Map::new();
293    obj.insert("throttleTimeMs".to_owned(), ::serde_json::json!(0));
294    obj.insert("errorCode".to_owned(), ::serde_json::json!(0));
295    obj.insert(
296        "unknownStateFilters".to_owned(),
297        ::serde_json::Value::Array(vec![]),
298    );
299    obj.insert(
300        "transactionStates".to_owned(),
301        ::serde_json::Value::Array(vec![]),
302    );
303    ::serde_json::Value::Object(obj)
304}
krabka_protocol/opt/rustwide/workdir/generated/ListTransactionsResponse.owned.rs

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