kafka_wire_protocol/schema/describe_producers_request/
v0.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/// DescribeProducersRequest, version 0.
15#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
16#[cfg_attr(test, derive(Arbitrary))]
17pub struct DescribeProducersRequest {
18    /// The topics to list producers for.
19    #[cfg_attr(test, proptest(strategy = "proptest_strategies::vec()"))]
20    pub topics: Vec<TopicRequest>,
21    /// Unknown tagged fields.
22    #[cfg_attr(test, proptest(strategy = "proptest_strategies::unknown_tagged_fields()"))]
23    pub _unknown_tagged_fields: Vec<RawTaggedField>,
24}
25
26impl ApiMessage for DescribeProducersRequest {
27    fn api_key(&self) -> i16 {
28        61
29    }
30    
31    fn version(&self) -> i16 {
32        0
33    }
34}
35
36impl Request for DescribeProducersRequest { }
37
38impl Default for DescribeProducersRequest {
39    fn default() -> Self {
40        DescribeProducersRequest {
41            topics: Vec::<TopicRequest>::new(),
42            _unknown_tagged_fields: Vec::new(),
43        }
44    }
45}
46
47impl DescribeProducersRequest {
48    pub fn new(topics: Vec<TopicRequest>) -> Self {
49        Self {
50            topics,
51            _unknown_tagged_fields: vec![],
52        }
53    }
54}
55
56#[cfg(test)]
57mod tests_describe_producers_request_new_and_default {
58    use super::*;
59    
60    #[test]
61    fn test() {
62        let d = DescribeProducersRequest::new(
63            Vec::<TopicRequest>::new(),
64        );
65        assert_eq!(d, DescribeProducersRequest::default());
66    }
67}
68
69impl Readable for DescribeProducersRequest {
70    fn read(#[allow(unused)] input: &mut impl Read) -> Result<Self> {
71        let topics = read_array::<TopicRequest>(input, "topics", true)?;
72        let tagged_fields_callback = |tag: i32, _: &[u8]| {
73            match tag {
74                _ => Ok(false)
75            }
76        };
77        let _unknown_tagged_fields = read_tagged_fields(input, tagged_fields_callback)?;
78        Ok(DescribeProducersRequest {
79            topics, _unknown_tagged_fields
80        })
81    }
82}
83
84impl Writable for DescribeProducersRequest {
85    fn write(&self, #[allow(unused)] output: &mut impl Write) -> Result<()> {
86        write_array(output, "self.topics", &self.topics, true)?;
87        write_tagged_fields(output, &[], &self._unknown_tagged_fields)?;
88        Ok(())
89    }
90}
91
92/// TopicRequest, version 0.
93#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
94#[cfg_attr(test, derive(Arbitrary))]
95pub struct TopicRequest {
96    /// The topic name.
97    #[cfg_attr(test, proptest(strategy = "proptest_strategies::string()"))]
98    pub name: String,
99    /// The indexes of the partitions to list producers for.
100    #[cfg_attr(test, proptest(strategy = "proptest_strategies::vec()"))]
101    pub partition_indexes: Vec<i32>,
102    /// Unknown tagged fields.
103    #[cfg_attr(test, proptest(strategy = "proptest_strategies::unknown_tagged_fields()"))]
104    pub _unknown_tagged_fields: Vec<RawTaggedField>,
105}
106
107impl Default for TopicRequest {
108    fn default() -> Self {
109        TopicRequest {
110            name: String::from(""),
111            partition_indexes: Vec::<i32>::new(),
112            _unknown_tagged_fields: Vec::new(),
113        }
114    }
115}
116
117impl TopicRequest {
118    pub fn new<S1: AsRef<str>>(name: S1, partition_indexes: Vec<i32>) -> Self {
119        Self {
120            name: name.as_ref().to_string(),
121            partition_indexes,
122            _unknown_tagged_fields: vec![],
123        }
124    }
125}
126
127#[cfg(test)]
128mod tests_topic_request_new_and_default {
129    use super::*;
130    
131    #[test]
132    fn test() {
133        let d = TopicRequest::new(
134            String::from(""),
135            Vec::<i32>::new(),
136        );
137        assert_eq!(d, TopicRequest::default());
138    }
139}
140
141impl Readable for TopicRequest {
142    fn read(#[allow(unused)] input: &mut impl Read) -> Result<Self> {
143        let name = String::read_ext(input, "name", true)?;
144        let partition_indexes = read_array::<i32>(input, "partition_indexes", true)?;
145        let tagged_fields_callback = |tag: i32, _: &[u8]| {
146            match tag {
147                _ => Ok(false)
148            }
149        };
150        let _unknown_tagged_fields = read_tagged_fields(input, tagged_fields_callback)?;
151        Ok(TopicRequest {
152            name, partition_indexes, _unknown_tagged_fields
153        })
154    }
155}
156
157impl Writable for TopicRequest {
158    fn write(&self, #[allow(unused)] output: &mut impl Write) -> Result<()> {
159        self.name.write_ext(output, "self.name", true)?;
160        write_array(output, "self.partition_indexes", &self.partition_indexes, true)?;
161        write_tagged_fields(output, &[], &self._unknown_tagged_fields)?;
162        Ok(())
163    }
164}
165
166#[cfg(test)]
167mod tests {
168    use super::*;
169    use proptest::prelude::*;
170    
171    #[test]
172    fn test_java_default() {
173        crate::test_utils::test_java_default::<DescribeProducersRequest>("DescribeProducersRequest", 0);
174    }
175    
176    proptest! {
177        #[test]
178        fn test_serde(data: DescribeProducersRequest) {
179            crate::test_utils::test_serde(&data)?;
180        }
181    }
182    
183    proptest! {
184        #[test]
185        fn test_java_arbitrary(data: DescribeProducersRequest) {
186            crate::test_utils::test_java_arbitrary(&data, "DescribeProducersRequest", 0);
187        }
188    }
189}