kafka_wire_protocol/schema/init_producer_id_response/
v4.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::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/// InitProducerIdResponse, version 4.
14#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
15#[cfg_attr(test, derive(Arbitrary))]
16pub struct InitProducerIdResponse {
17    /// The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota.
18    pub throttle_time_ms: i32,
19    /// The error code, or 0 if there was no error.
20    pub error_code: i16,
21    /// The current producer id.
22    pub producer_id: i64,
23    /// The current epoch associated with the producer id.
24    pub producer_epoch: i16,
25    /// Unknown tagged fields.
26    #[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}