kafka_wire_protocol/schema/api_versions_response/
v1.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, Response};
10use crate::readable_writable::{Readable, Writable};
11#[cfg(test)] use crate::test_utils::proptest_strategies;
12
13/// ApiVersionsResponse, version 1.
14#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
15#[cfg_attr(test, derive(Arbitrary))]
16pub struct ApiVersionsResponse {
17    /// The top-level error code.
18    pub error_code: i16,
19    /// The APIs supported by the broker.
20    #[cfg_attr(test, proptest(strategy = "proptest_strategies::vec()"))]
21    pub api_keys: Vec<ApiVersion>,
22    /// 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.
23    pub throttle_time_ms: i32,
24}
25
26impl ApiMessage for ApiVersionsResponse {
27    fn api_key(&self) -> i16 {
28        18
29    }
30    
31    fn version(&self) -> i16 {
32        1
33    }
34}
35
36impl Response for ApiVersionsResponse { }
37
38impl Default for ApiVersionsResponse {
39    fn default() -> Self {
40        ApiVersionsResponse {
41            error_code: 0_i16,
42            api_keys: Vec::<ApiVersion>::new(),
43            throttle_time_ms: 0_i32,
44        }
45    }
46}
47
48impl ApiVersionsResponse {
49    pub fn new(error_code: i16, api_keys: Vec<ApiVersion>, throttle_time_ms: i32) -> Self {
50        Self {
51            error_code,
52            api_keys,
53            throttle_time_ms,
54        }
55    }
56}
57
58#[cfg(test)]
59mod tests_api_versions_response_new_and_default {
60    use super::*;
61    
62    #[test]
63    fn test() {
64        let d = ApiVersionsResponse::new(
65            0_i16,
66            Vec::<ApiVersion>::new(),
67            0_i32,
68        );
69        assert_eq!(d, ApiVersionsResponse::default());
70    }
71}
72
73impl Readable for ApiVersionsResponse {
74    fn read(#[allow(unused)] input: &mut impl Read) -> Result<Self> {
75        let error_code = i16::read(input)?;
76        let api_keys = read_array::<ApiVersion>(input, "api_keys", false)?;
77        let throttle_time_ms = i32::read(input)?;
78        Ok(ApiVersionsResponse {
79            error_code, api_keys, throttle_time_ms
80        })
81    }
82}
83
84impl Writable for ApiVersionsResponse {
85    fn write(&self, #[allow(unused)] output: &mut impl Write) -> Result<()> {
86        self.error_code.write(output)?;
87        write_array(output, "self.api_keys", &self.api_keys, false)?;
88        self.throttle_time_ms.write(output)?;
89        Ok(())
90    }
91}
92
93/// ApiVersion, version 1.
94#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
95#[cfg_attr(test, derive(Arbitrary))]
96pub struct ApiVersion {
97    /// The API index.
98    pub api_key: i16,
99    /// The minimum supported version, inclusive.
100    pub min_version: i16,
101    /// The maximum supported version, inclusive.
102    pub max_version: i16,
103}
104
105impl Default for ApiVersion {
106    fn default() -> Self {
107        ApiVersion {
108            api_key: 0_i16,
109            min_version: 0_i16,
110            max_version: 0_i16,
111        }
112    }
113}
114
115impl ApiVersion {
116    pub fn new(api_key: i16, min_version: i16, max_version: i16) -> Self {
117        Self {
118            api_key,
119            min_version,
120            max_version,
121        }
122    }
123}
124
125#[cfg(test)]
126mod tests_api_version_new_and_default {
127    use super::*;
128    
129    #[test]
130    fn test() {
131        let d = ApiVersion::new(
132            0_i16,
133            0_i16,
134            0_i16,
135        );
136        assert_eq!(d, ApiVersion::default());
137    }
138}
139
140impl Readable for ApiVersion {
141    fn read(#[allow(unused)] input: &mut impl Read) -> Result<Self> {
142        let api_key = i16::read(input)?;
143        let min_version = i16::read(input)?;
144        let max_version = i16::read(input)?;
145        Ok(ApiVersion {
146            api_key, min_version, max_version
147        })
148    }
149}
150
151impl Writable for ApiVersion {
152    fn write(&self, #[allow(unused)] output: &mut impl Write) -> Result<()> {
153        self.api_key.write(output)?;
154        self.min_version.write(output)?;
155        self.max_version.write(output)?;
156        Ok(())
157    }
158}
159
160#[cfg(test)]
161mod tests {
162    use super::*;
163    use proptest::prelude::*;
164    
165    #[test]
166    fn test_java_default() {
167        crate::test_utils::test_java_default::<ApiVersionsResponse>("ApiVersionsResponse", 1);
168    }
169    
170    proptest! {
171        #[test]
172        fn test_serde(data: ApiVersionsResponse) {
173            crate::test_utils::test_serde(&data)?;
174        }
175    }
176    
177    proptest! {
178        #[test]
179        fn test_java_arbitrary(data: ApiVersionsResponse) {
180            crate::test_utils::test_java_arbitrary(&data, "ApiVersionsResponse", 1);
181        }
182    }
183}
kafka_wire_protocol/schema/api_versions_response/v1.rs

kafka_wire_protocol/schema/api_versions_response/
v1.rs
