kafka_wire_protocol/schema/delete_acls_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/// DeleteAclsRequest, version 3.
15#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
16#[cfg_attr(test, derive(Arbitrary))]
17pub struct DeleteAclsRequest {
18    /// The filters to use when deleting ACLs.
19    #[cfg_attr(test, proptest(strategy = "proptest_strategies::vec()"))]
20    pub filters: Vec<DeleteAclsFilter>,
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 DeleteAclsRequest {
27    fn api_key(&self) -> i16 {
28        31
29    }
30    
31    fn version(&self) -> i16 {
32        3
33    }
34}
35
36impl Request for DeleteAclsRequest { }
37
38impl Default for DeleteAclsRequest {
39    fn default() -> Self {
40        DeleteAclsRequest {
41            filters: Vec::<DeleteAclsFilter>::new(),
42            _unknown_tagged_fields: Vec::new(),
43        }
44    }
45}
46
47impl DeleteAclsRequest {
48    pub fn new(filters: Vec<DeleteAclsFilter>) -> Self {
49        Self {
50            filters,
51            _unknown_tagged_fields: vec![],
52        }
53    }
54}
55
56#[cfg(test)]
57mod tests_delete_acls_request_new_and_default {
58    use super::*;
59    
60    #[test]
61    fn test() {
62        let d = DeleteAclsRequest::new(
63            Vec::<DeleteAclsFilter>::new(),
64        );
65        assert_eq!(d, DeleteAclsRequest::default());
66    }
67}
68
69impl Readable for DeleteAclsRequest {
70    fn read(#[allow(unused)] input: &mut impl Read) -> Result<Self> {
71        let filters = read_array::<DeleteAclsFilter>(input, "filters", 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(DeleteAclsRequest {
79            filters, _unknown_tagged_fields
80        })
81    }
82}
83
84impl Writable for DeleteAclsRequest {
85    fn write(&self, #[allow(unused)] output: &mut impl Write) -> Result<()> {
86        write_array(output, "self.filters", &self.filters, true)?;
87        write_tagged_fields(output, &[], &self._unknown_tagged_fields)?;
88        Ok(())
89    }
90}
91
92/// DeleteAclsFilter, version 3.
93#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
94#[cfg_attr(test, derive(Arbitrary))]
95pub struct DeleteAclsFilter {
96    /// The resource type.
97    pub resource_type_filter: i8,
98    /// The resource name.
99    #[cfg_attr(test, proptest(strategy = "proptest_strategies::optional_string()"))]
100    pub resource_name_filter: Option<String>,
101    /// The pattern type.
102    pub pattern_type_filter: i8,
103    /// The principal filter, or null to accept all principals.
104    #[cfg_attr(test, proptest(strategy = "proptest_strategies::optional_string()"))]
105    pub principal_filter: Option<String>,
106    /// The host filter, or null to accept all hosts.
107    #[cfg_attr(test, proptest(strategy = "proptest_strategies::optional_string()"))]
108    pub host_filter: Option<String>,
109    /// The ACL operation.
110    pub operation: i8,
111    /// The permission type.
112    pub permission_type: i8,
113    /// Unknown tagged fields.
114    #[cfg_attr(test, proptest(strategy = "proptest_strategies::unknown_tagged_fields()"))]
115    pub _unknown_tagged_fields: Vec<RawTaggedField>,
116}
117
118impl Default for DeleteAclsFilter {
119    fn default() -> Self {
120        DeleteAclsFilter {
121            resource_type_filter: 0_i8,
122            resource_name_filter: Some(String::from("")),
123            pattern_type_filter: 3_i8,
124            principal_filter: Some(String::from("")),
125            host_filter: Some(String::from("")),
126            operation: 0_i8,
127            permission_type: 0_i8,
128            _unknown_tagged_fields: Vec::new(),
129        }
130    }
131}
132
133impl DeleteAclsFilter {
134    pub fn new<S1: AsRef<str>, S2: AsRef<str>, S3: AsRef<str>>(resource_type_filter: i8, resource_name_filter: Option<S1>, pattern_type_filter: i8, principal_filter: Option<S2>, host_filter: Option<S3>, operation: i8, permission_type: i8) -> Self {
135        Self {
136            resource_type_filter,
137            resource_name_filter: resource_name_filter.map(|s| s.as_ref().to_string()),
138            pattern_type_filter,
139            principal_filter: principal_filter.map(|s| s.as_ref().to_string()),
140            host_filter: host_filter.map(|s| s.as_ref().to_string()),
141            operation,
142            permission_type,
143            _unknown_tagged_fields: vec![],
144        }
145    }
146}
147
148#[cfg(test)]
149mod tests_delete_acls_filter_new_and_default {
150    use super::*;
151    
152    #[test]
153    fn test() {
154        let d = DeleteAclsFilter::new(
155            0_i8,
156            Some(String::from("")),
157            3_i8,
158            Some(String::from("")),
159            Some(String::from("")),
160            0_i8,
161            0_i8,
162        );
163        assert_eq!(d, DeleteAclsFilter::default());
164    }
165}
166
167impl Readable for DeleteAclsFilter {
168    fn read(#[allow(unused)] input: &mut impl Read) -> Result<Self> {
169        let resource_type_filter = i8::read(input)?;
170        let resource_name_filter = Option::<String>::read_ext(input, "resource_name_filter", true)?;
171        let pattern_type_filter = i8::read(input)?;
172        let principal_filter = Option::<String>::read_ext(input, "principal_filter", true)?;
173        let host_filter = Option::<String>::read_ext(input, "host_filter", true)?;
174        let operation = i8::read(input)?;
175        let permission_type = i8::read(input)?;
176        let tagged_fields_callback = |tag: i32, _: &[u8]| {
177            match tag {
178                _ => Ok(false)
179            }
180        };
181        let _unknown_tagged_fields = read_tagged_fields(input, tagged_fields_callback)?;
182        Ok(DeleteAclsFilter {
183            resource_type_filter, resource_name_filter, pattern_type_filter, principal_filter, host_filter, operation, permission_type, _unknown_tagged_fields
184        })
185    }
186}
187
188impl Writable for DeleteAclsFilter {
189    fn write(&self, #[allow(unused)] output: &mut impl Write) -> Result<()> {
190        self.resource_type_filter.write(output)?;
191        self.resource_name_filter.write_ext(output, "self.resource_name_filter", true)?;
192        self.pattern_type_filter.write(output)?;
193        self.principal_filter.write_ext(output, "self.principal_filter", true)?;
194        self.host_filter.write_ext(output, "self.host_filter", true)?;
195        self.operation.write(output)?;
196        self.permission_type.write(output)?;
197        write_tagged_fields(output, &[], &self._unknown_tagged_fields)?;
198        Ok(())
199    }
200}
201
202#[cfg(test)]
203mod tests {
204    use super::*;
205    use proptest::prelude::*;
206    
207    #[test]
208    fn test_java_default() {
209        crate::test_utils::test_java_default::<DeleteAclsRequest>("DeleteAclsRequest", 3);
210    }
211    
212    proptest! {
213        #[test]
214        fn test_serde(data: DeleteAclsRequest) {
215            crate::test_utils::test_serde(&data)?;
216        }
217    }
218    
219    proptest! {
220        #[test]
221        fn test_java_arbitrary(data: DeleteAclsRequest) {
222            crate::test_utils::test_java_arbitrary(&data, "DeleteAclsRequest", 3);
223        }
224    }
225}
kafka_wire_protocol/schema/delete_acls_request/v3.rs

kafka_wire_protocol/schema/delete_acls_request/
v3.rs
