kafka_wire_protocol/schema/txn_offset_commit_request/
v3.rs

1// This file was generated. Do not edit.
2
3use std::io::{Read, Result, Write};
4
5use serde::{Deserialize, Serialize};
6#[cfg(test)] use proptest_derive::Arbitrary;
7
8use crate::arrays::{read_array, write_array};
9use crate::markers::{ApiMessage, Request};
10use crate::readable_writable::{Readable, Writable};
11use crate::tagged_fields::{RawTaggedField, read_tagged_fields, write_tagged_fields};
12#[cfg(test)] use crate::test_utils::proptest_strategies;
13
14/// TxnOffsetCommitRequest, version 3.
15#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
16#[cfg_attr(test, derive(Arbitrary))]
17pub struct TxnOffsetCommitRequest {
18    /// The ID of the transaction.
19    #[cfg_attr(test, proptest(strategy = "proptest_strategies::string()"))]
20    pub transactional_id: String,
21    /// The ID of the group.
22    #[cfg_attr(test, proptest(strategy = "proptest_strategies::string()"))]
23    pub group_id: String,
24    /// The current producer ID in use by the transactional ID.
25    pub producer_id: i64,
26    /// The current epoch associated with the producer ID.
27    pub producer_epoch: i16,
28    /// The generation of the consumer.
29    pub generation_id: i32,
30    /// The member ID assigned by the group coordinator.
31    #[cfg_attr(test, proptest(strategy = "proptest_strategies::string()"))]
32    pub member_id: String,
33    /// The unique identifier of the consumer instance provided by end user.
34    #[cfg_attr(test, proptest(strategy = "proptest_strategies::optional_string()"))]
35    pub group_instance_id: Option<String>,
36    /// Each topic that we want to commit offsets for.
37    #[cfg_attr(test, proptest(strategy = "proptest_strategies::vec()"))]
38    pub topics: Vec<TxnOffsetCommitRequestTopic>,
39    /// Unknown tagged fields.
40    #[cfg_attr(test, proptest(strategy = "proptest_strategies::unknown_tagged_fields()"))]
41    pub _unknown_tagged_fields: Vec<RawTaggedField>,
42}
43
44impl ApiMessage for TxnOffsetCommitRequest {
45    fn api_key(&self) -> i16 {
46        28
47    }
48    
49    fn version(&self) -> i16 {
50        3
51    }
52}
53
54impl Request for TxnOffsetCommitRequest { }
55
56impl Default for TxnOffsetCommitRequest {
57    fn default() -> Self {
58        TxnOffsetCommitRequest {
59            transactional_id: String::from(""),
60            group_id: String::from(""),
61            producer_id: 0_i64,
62            producer_epoch: 0_i16,
63            generation_id: -1_i32,
64            member_id: String::from(""),
65            group_instance_id: None,
66            topics: Vec::<TxnOffsetCommitRequestTopic>::new(),
67            _unknown_tagged_fields: Vec::new(),
68        }
69    }
70}
71
72impl TxnOffsetCommitRequest {
73    pub fn new<S1: AsRef<str>, S2: AsRef<str>, S3: AsRef<str>, S4: AsRef<str>>(transactional_id: S1, group_id: S2, producer_id: i64, producer_epoch: i16, generation_id: i32, member_id: S3, group_instance_id: Option<S4>, topics: Vec<TxnOffsetCommitRequestTopic>) -> Self {
74        Self {
75            transactional_id: transactional_id.as_ref().to_string(),
76            group_id: group_id.as_ref().to_string(),
77            producer_id,
78            producer_epoch,
79            generation_id,
80            member_id: member_id.as_ref().to_string(),
81            group_instance_id: group_instance_id.map(|s| s.as_ref().to_string()),
82            topics,
83            _unknown_tagged_fields: vec![],
84        }
85    }
86}
87
88#[cfg(test)]
89mod tests_txn_offset_commit_request_new_and_default {
90    use super::*;
91    
92    #[test]
93    fn test() {
94        let d = TxnOffsetCommitRequest::new(
95            String::from(""),
96            String::from(""),
97            0_i64,
98            0_i16,
99            -1_i32,
100            String::from(""),
101            None::<String>,
102            Vec::<TxnOffsetCommitRequestTopic>::new(),
103        );
104        assert_eq!(d, TxnOffsetCommitRequest::default());
105    }
106}
107
108impl Readable for TxnOffsetCommitRequest {
109    fn read(#[allow(unused)] input: &mut impl Read) -> Result<Self> {
110        let transactional_id = String::read_ext(input, "transactional_id", true)?;
111        let group_id = String::read_ext(input, "group_id", true)?;
112        let producer_id = i64::read(input)?;
113        let producer_epoch = i16::read(input)?;
114        let generation_id = i32::read(input)?;
115        let member_id = String::read_ext(input, "member_id", true)?;
116        let group_instance_id = Option::<String>::read_ext(input, "group_instance_id", true)?;
117        let topics = read_array::<TxnOffsetCommitRequestTopic>(input, "topics", true)?;
118        let tagged_fields_callback = |tag: i32, _: &[u8]| {
119            match tag {
120                _ => Ok(false)
121            }
122        };
123        let _unknown_tagged_fields = read_tagged_fields(input, tagged_fields_callback)?;
124        Ok(TxnOffsetCommitRequest {
125            transactional_id, group_id, producer_id, producer_epoch, generation_id, member_id, group_instance_id, topics, _unknown_tagged_fields
126        })
127    }
128}
129
130impl Writable for TxnOffsetCommitRequest {
131    fn write(&self, #[allow(unused)] output: &mut impl Write) -> Result<()> {
132        self.transactional_id.write_ext(output, "self.transactional_id", true)?;
133        self.group_id.write_ext(output, "self.group_id", true)?;
134        self.producer_id.write(output)?;
135        self.producer_epoch.write(output)?;
136        self.generation_id.write(output)?;
137        self.member_id.write_ext(output, "self.member_id", true)?;
138        self.group_instance_id.write_ext(output, "self.group_instance_id", true)?;
139        write_array(output, "self.topics", &self.topics, true)?;
140        write_tagged_fields(output, &[], &self._unknown_tagged_fields)?;
141        Ok(())
142    }
143}
144
145/// TxnOffsetCommitRequestTopic, version 3.
146#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
147#[cfg_attr(test, derive(Arbitrary))]
148pub struct TxnOffsetCommitRequestTopic {
149    /// The topic name.
150    #[cfg_attr(test, proptest(strategy = "proptest_strategies::string()"))]
151    pub name: String,
152    /// The partitions inside the topic that we want to commit offsets for.
153    #[cfg_attr(test, proptest(strategy = "proptest_strategies::vec()"))]
154    pub partitions: Vec<TxnOffsetCommitRequestPartition>,
155    /// Unknown tagged fields.
156    #[cfg_attr(test, proptest(strategy = "proptest_strategies::unknown_tagged_fields()"))]
157    pub _unknown_tagged_fields: Vec<RawTaggedField>,
158}
159
160impl Default for TxnOffsetCommitRequestTopic {
161    fn default() -> Self {
162        TxnOffsetCommitRequestTopic {
163            name: String::from(""),
164            partitions: Vec::<TxnOffsetCommitRequestPartition>::new(),
165            _unknown_tagged_fields: Vec::new(),
166        }
167    }
168}
169
170impl TxnOffsetCommitRequestTopic {
171    pub fn new<S1: AsRef<str>>(name: S1, partitions: Vec<TxnOffsetCommitRequestPartition>) -> Self {
172        Self {
173            name: name.as_ref().to_string(),
174            partitions,
175            _unknown_tagged_fields: vec![],
176        }
177    }
178}
179
180#[cfg(test)]
181mod tests_txn_offset_commit_request_topic_new_and_default {
182    use super::*;
183    
184    #[test]
185    fn test() {
186        let d = TxnOffsetCommitRequestTopic::new(
187            String::from(""),
188            Vec::<TxnOffsetCommitRequestPartition>::new(),
189        );
190        assert_eq!(d, TxnOffsetCommitRequestTopic::default());
191    }
192}
193
194impl Readable for TxnOffsetCommitRequestTopic {
195    fn read(#[allow(unused)] input: &mut impl Read) -> Result<Self> {
196        let name = String::read_ext(input, "name", true)?;
197        let partitions = read_array::<TxnOffsetCommitRequestPartition>(input, "partitions", true)?;
198        let tagged_fields_callback = |tag: i32, _: &[u8]| {
199            match tag {
200                _ => Ok(false)
201            }
202        };
203        let _unknown_tagged_fields = read_tagged_fields(input, tagged_fields_callback)?;
204        Ok(TxnOffsetCommitRequestTopic {
205            name, partitions, _unknown_tagged_fields
206        })
207    }
208}
209
210impl Writable for TxnOffsetCommitRequestTopic {
211    fn write(&self, #[allow(unused)] output: &mut impl Write) -> Result<()> {
212        self.name.write_ext(output, "self.name", true)?;
213        write_array(output, "self.partitions", &self.partitions, true)?;
214        write_tagged_fields(output, &[], &self._unknown_tagged_fields)?;
215        Ok(())
216    }
217}
218
219/// TxnOffsetCommitRequestPartition, version 3.
220#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
221#[cfg_attr(test, derive(Arbitrary))]
222pub struct TxnOffsetCommitRequestPartition {
223    /// The index of the partition within the topic.
224    pub partition_index: i32,
225    /// The message offset to be committed.
226    pub committed_offset: i64,
227    /// The leader epoch of the last consumed record.
228    pub committed_leader_epoch: i32,
229    /// Any associated metadata the client wants to keep.
230    #[cfg_attr(test, proptest(strategy = "proptest_strategies::optional_string()"))]
231    pub committed_metadata: Option<String>,
232    /// Unknown tagged fields.
233    #[cfg_attr(test, proptest(strategy = "proptest_strategies::unknown_tagged_fields()"))]
234    pub _unknown_tagged_fields: Vec<RawTaggedField>,
235}
236
237impl Default for TxnOffsetCommitRequestPartition {
238    fn default() -> Self {
239        TxnOffsetCommitRequestPartition {
240            partition_index: 0_i32,
241            committed_offset: 0_i64,
242            committed_leader_epoch: -1_i32,
243            committed_metadata: Some(String::from("")),
244            _unknown_tagged_fields: Vec::new(),
245        }
246    }
247}
248
249impl TxnOffsetCommitRequestPartition {
250    pub fn new<S1: AsRef<str>>(partition_index: i32, committed_offset: i64, committed_leader_epoch: i32, committed_metadata: Option<S1>) -> Self {
251        Self {
252            partition_index,
253            committed_offset,
254            committed_leader_epoch,
255            committed_metadata: committed_metadata.map(|s| s.as_ref().to_string()),
256            _unknown_tagged_fields: vec![],
257        }
258    }
259}
260
261#[cfg(test)]
262mod tests_txn_offset_commit_request_partition_new_and_default {
263    use super::*;
264    
265    #[test]
266    fn test() {
267        let d = TxnOffsetCommitRequestPartition::new(
268            0_i32,
269            0_i64,
270            -1_i32,
271            Some(String::from("")),
272        );
273        assert_eq!(d, TxnOffsetCommitRequestPartition::default());
274    }
275}
276
277impl Readable for TxnOffsetCommitRequestPartition {
278    fn read(#[allow(unused)] input: &mut impl Read) -> Result<Self> {
279        let partition_index = i32::read(input)?;
280        let committed_offset = i64::read(input)?;
281        let committed_leader_epoch = i32::read(input)?;
282        let committed_metadata = Option::<String>::read_ext(input, "committed_metadata", true)?;
283        let tagged_fields_callback = |tag: i32, _: &[u8]| {
284            match tag {
285                _ => Ok(false)
286            }
287        };
288        let _unknown_tagged_fields = read_tagged_fields(input, tagged_fields_callback)?;
289        Ok(TxnOffsetCommitRequestPartition {
290            partition_index, committed_offset, committed_leader_epoch, committed_metadata, _unknown_tagged_fields
291        })
292    }
293}
294
295impl Writable for TxnOffsetCommitRequestPartition {
296    fn write(&self, #[allow(unused)] output: &mut impl Write) -> Result<()> {
297        self.partition_index.write(output)?;
298        self.committed_offset.write(output)?;
299        self.committed_leader_epoch.write(output)?;
300        self.committed_metadata.write_ext(output, "self.committed_metadata", true)?;
301        write_tagged_fields(output, &[], &self._unknown_tagged_fields)?;
302        Ok(())
303    }
304}
305
306#[cfg(test)]
307mod tests {
308    use super::*;
309    use proptest::prelude::*;
310    
311    #[test]
312    fn test_java_default() {
313        crate::test_utils::test_java_default::<TxnOffsetCommitRequest>("TxnOffsetCommitRequest", 3);
314    }
315    
316    proptest! {
317        #[test]
318        fn test_serde(data: TxnOffsetCommitRequest) {
319            crate::test_utils::test_serde(&data)?;
320        }
321    }
322    
323    proptest! {
324        #[test]
325        fn test_java_arbitrary(data: TxnOffsetCommitRequest) {
326            crate::test_utils::test_java_arbitrary(&data, "TxnOffsetCommitRequest", 3);
327        }
328    }
329}
kafka_wire_protocol/schema/txn_offset_commit_request/v3.rs

kafka_wire_protocol/schema/txn_offset_commit_request/
v3.rs
