kafka_wire_protocol/schema/init_producer_id_response/
v4.rs1use std::io::{Read, Result, Write};
4
5use serde::{Deserialize, Serialize};
6#[cfg(test)] use proptest_derive::Arbitrary;
7
8use crate::markers::{ApiMessage, Response};
9use crate::readable_writable::{Readable, Writable};
10use crate::tagged_fields::{RawTaggedField, read_tagged_fields, write_tagged_fields};
11#[cfg(test)] use crate::test_utils::proptest_strategies;
12
13#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
15#[cfg_attr(test, derive(Arbitrary))]
16pub struct InitProducerIdResponse {
17 pub throttle_time_ms: i32,
19 pub error_code: i16,
21 pub producer_id: i64,
23 pub producer_epoch: i16,
25 #[cfg_attr(test, proptest(strategy = "proptest_strategies::unknown_tagged_fields()"))]
27 pub _unknown_tagged_fields: Vec<RawTaggedField>,
28}
29
30impl ApiMessage for InitProducerIdResponse {
31 fn api_key(&self) -> i16 {
32 22
33 }
34
35 fn version(&self) -> i16 {
36 4
37 }
38}
39
40impl Response for InitProducerIdResponse { }
41
42impl Default for InitProducerIdResponse {
43 fn default() -> Self {
44 InitProducerIdResponse {
45 throttle_time_ms: 0_i32,
46 error_code: 0_i16,
47 producer_id: -1_i64,
48 producer_epoch: 0_i16,
49 _unknown_tagged_fields: Vec::new(),
50 }
51 }
52}
53
54impl InitProducerIdResponse {
55 pub fn new(throttle_time_ms: i32, error_code: i16, producer_id: i64, producer_epoch: i16) -> Self {
56 Self {
57 throttle_time_ms,
58 error_code,
59 producer_id,
60 producer_epoch,
61 _unknown_tagged_fields: vec![],
62 }
63 }
64}
65
66#[cfg(test)]
67mod tests_init_producer_id_response_new_and_default {
68 use super::*;
69
70 #[test]
71 fn test() {
72 let d = InitProducerIdResponse::new(
73 0_i32,
74 0_i16,
75 -1_i64,
76 0_i16,
77 );
78 assert_eq!(d, InitProducerIdResponse::default());
79 }
80}
81
82impl Readable for InitProducerIdResponse {
83 fn read(#[allow(unused)] input: &mut impl Read) -> Result<Self> {
84 let throttle_time_ms = i32::read(input)?;
85 let error_code = i16::read(input)?;
86 let producer_id = i64::read(input)?;
87 let producer_epoch = i16::read(input)?;
88 let tagged_fields_callback = |tag: i32, _: &[u8]| {
89 match tag {
90 _ => Ok(false)
91 }
92 };
93 let _unknown_tagged_fields = read_tagged_fields(input, tagged_fields_callback)?;
94 Ok(InitProducerIdResponse {
95 throttle_time_ms, error_code, producer_id, producer_epoch, _unknown_tagged_fields
96 })
97 }
98}
99
100impl Writable for InitProducerIdResponse {
101 fn write(&self, #[allow(unused)] output: &mut impl Write) -> Result<()> {
102 self.throttle_time_ms.write(output)?;
103 self.error_code.write(output)?;
104 self.producer_id.write(output)?;
105 self.producer_epoch.write(output)?;
106 write_tagged_fields(output, &[], &self._unknown_tagged_fields)?;
107 Ok(())
108 }
109}
110
111#[cfg(test)]
112mod tests {
113 use super::*;
114 use proptest::prelude::*;
115
116 #[test]
117 fn test_java_default() {
118 crate::test_utils::test_java_default::<InitProducerIdResponse>("InitProducerIdResponse", 4);
119 }
120
121 proptest! {
122 #[test]
123 fn test_serde(data: InitProducerIdResponse) {
124 crate::test_utils::test_serde(&data)?;
125 }
126 }
127
128 proptest! {
129 #[test]
130 fn test_java_arbitrary(data: InitProducerIdResponse) {
131 crate::test_utils::test_java_arbitrary(&data, "InitProducerIdResponse", 4);
132 }
133 }
134}