kacrab-protocol 0.1.1

Kafka wire protocol types — generated from upstream message schemas by `kacrab-codegen`.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

//! Generated from ListTransactionsRequest.json - DO NOT EDIT
#![allow(
    missing_docs,
    clippy::all,
    clippy::pedantic,
    clippy::nursery,
    clippy::arithmetic_side_effects,
    reason = "Generated protocol modules mirror Kafka's schema shape and intentionally trade \
              hand-written lint style for reproducible wire-code output."
)]
use bytes::{Bytes, BytesMut};

use crate::*;

#[derive(Debug, Clone, PartialEq)]
pub struct ListTransactionsRequestData {
    /// The transaction states to filter by: if empty, all transactions are returned; if non-empty,
    /// then only transactions matching one of the filtered states will be returned.
    pub state_filters: Vec<KafkaString>,
    /// The producerIds to filter by: if empty, all transactions will be returned; if non-empty,
    /// only transactions which match one of the filtered producerIds will be returned.
    pub producer_id_filters: Vec<i64>,
    /// Duration (in millis) to filter by: if < 0, all transactions will be returned; otherwise,
    /// only transactions running longer than this duration will be returned.
    pub duration_filter: i64,
    /// The transactional ID regular expression pattern to filter by: if it is empty or null, all
    /// transactions are returned; Otherwise then only the transactions matching the given regular
    /// expression will be returned.
    pub transactional_id_pattern: Option<KafkaString>,
    pub _unknown_tagged_fields: Vec<RawTaggedField>,
}
impl Default for ListTransactionsRequestData {
    fn default() -> Self {
        Self {
            state_filters: Vec::new(),
            producer_id_filters: Vec::new(),
            duration_filter: -1i64,
            transactional_id_pattern: None,
            _unknown_tagged_fields: Vec::new(),
        }
    }
}
impl ListTransactionsRequestData {
    pub fn with_state_filters(mut self, value: Vec<KafkaString>) -> Self {
        self.state_filters = value;
        self
    }
    pub fn with_producer_id_filters(mut self, value: Vec<i64>) -> Self {
        self.producer_id_filters = value;
        self
    }
    pub fn with_duration_filter(mut self, value: i64) -> Self {
        self.duration_filter = value;
        self
    }
    pub fn with_transactional_id_pattern(mut self, value: Option<KafkaString>) -> Self {
        self.transactional_id_pattern = value;
        self
    }
    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
        if version < 0 || version > 2 {
            return Err(UnsupportedVersion::new(66, version).into());
        }
        let state_filters;
        let producer_id_filters;
        let mut duration_filter = -1i64;
        let mut transactional_id_pattern = None;
        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
        state_filters = {
            let len = read_compact_array_length(buf)?;
            let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
            for _ in 0..len {
                arr.push(read_compact_string(buf)?);
            }
            arr
        };
        producer_id_filters = {
            let len = read_compact_array_length(buf)?;
            let mut arr = Vec::with_capacity(array_read_capacity(len, (buf).len()));
            for _ in 0..len {
                arr.push(read_i64(buf)?);
            }
            arr
        };
        if version >= 1 {
            duration_filter = read_i64(buf)?;
        }
        if version >= 2 {
            transactional_id_pattern = read_compact_nullable_string(buf)?;
        }
        let tagged_fields = read_tagged_fields(buf)?;
        for field in &tagged_fields {
            match field.tag {
                _ => {
                    _unknown_tagged_fields.push(field.clone());
                },
            }
        }
        Ok(Self {
            state_filters,
            producer_id_filters,
            duration_filter,
            transactional_id_pattern,
            _unknown_tagged_fields,
        })
    }
    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
        if version < 0 || version > 2 {
            return Err(UnsupportedVersion::new(66, version).into());
        }
        write_compact_array_length(buf, self.state_filters.len() as i32);
        for el in &self.state_filters {
            write_compact_string(buf, el)?;
        }
        write_compact_array_length(buf, self.producer_id_filters.len() as i32);
        for el in &self.producer_id_filters {
            write_i64(buf, *el);
        }
        if version >= 1 {
            write_i64(buf, self.duration_filter);
        } else if self.duration_filter != -1i64 {
            return Err(UnsupportedFieldVersion::new(66, "duration_filter", version).into());
        }
        if version >= 2 {
            write_compact_nullable_string(buf, self.transactional_id_pattern.as_ref())?;
        } else if self.transactional_id_pattern != None {
            return Err(
                UnsupportedFieldVersion::new(66, "transactional_id_pattern", version).into(),
            );
        }
        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
        all_tags.sort_by_key(|f| f.tag);
        write_tagged_fields(buf, &all_tags)?;
        Ok(())
    }
    pub fn encoded_len(&self, version: i16) -> Result<usize> {
        if version < 0 || version > 2 {
            return Err(UnsupportedVersion::new(66, version).into());
        }
        let mut len: usize = 0;
        len += compact_array_length_len(self.state_filters.len() as i32);
        for el in &self.state_filters {
            len += compact_string_len(el)?;
        }
        len += compact_array_length_len(self.producer_id_filters.len() as i32);
        len += self.producer_id_filters.len() * 8usize;
        if version >= 1 {
            len += 8;
        } else if self.duration_filter != -1i64 {
            return Err(UnsupportedFieldVersion::new(66, "duration_filter", version).into());
        }
        if version >= 2 {
            len += compact_nullable_string_len(self.transactional_id_pattern.as_ref())?;
        } else if self.transactional_id_pattern != None {
            return Err(
                UnsupportedFieldVersion::new(66, "transactional_id_pattern", version).into(),
            );
        }
        let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
        all_tags.sort_by_key(|f| f.tag);
        len += tagged_fields_len(&all_tags)?;
        Ok(len)
    }
}