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
#![allow(unused)]
use std::borrow::Borrow;
use std::collections::BTreeMap;
use bytes::Bytes;
use log::error;
use uuid::Uuid;
use crate::protocol::{
Encodable, Decodable, MapEncodable, MapDecodable, Encoder, Decoder, EncodeError, DecodeError, Message, HeaderVersion, VersionRange,
types, write_unknown_tagged_fields, compute_unknown_tagged_fields_size, StrBytes, buf::{ByteBuf, ByteBufMut}
};
#[derive(Debug, Clone, PartialEq, derive_builder::Builder)]
pub struct TopicPartition {
pub partitions: Vec<i32>,
}
impl MapEncodable for TopicPartition {
type Key = super::TopicName;
fn encode<B: ByteBufMut>(&self, key: &Self::Key, buf: &mut B, version: i16) -> Result<(), EncodeError> {
types::String.encode(buf, key)?;
types::Array(types::Int32).encode(buf, &self.partitions)?;
Ok(())
}
fn compute_size(&self, key: &Self::Key, version: i16) -> Result<usize, EncodeError> {
let mut total_size = 0;
total_size += types::String.compute_size(key)?;
total_size += types::Array(types::Int32).compute_size(&self.partitions)?;
Ok(total_size)
}
}
impl MapDecodable for TopicPartition {
type Key = super::TopicName;
fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<(Self::Key, Self), DecodeError> {
let key_field = types::String.decode(buf)?;
let partitions = types::Array(types::Int32).decode(buf)?;
Ok((key_field, Self {
partitions,
}))
}
}
impl Default for TopicPartition {
fn default() -> Self {
Self {
partitions: Default::default(),
}
}
}
impl Message for TopicPartition {
const VERSIONS: VersionRange = VersionRange { min: 0, max: 1 };
}
#[derive(Debug, Clone, PartialEq, derive_builder::Builder)]
pub struct ConsumerProtocolAssignment {
pub assigned_partitions: indexmap::IndexMap<super::TopicName, TopicPartition>,
pub user_data: Option<Bytes>,
}
impl Encodable for ConsumerProtocolAssignment {
fn encode<B: ByteBufMut>(&self, buf: &mut B, version: i16) -> Result<(), EncodeError> {
types::Array(types::Struct { version }).encode(buf, &self.assigned_partitions)?;
types::Bytes.encode(buf, &self.user_data)?;
Ok(())
}
fn compute_size(&self, version: i16) -> Result<usize, EncodeError> {
let mut total_size = 0;
total_size += types::Array(types::Struct { version }).compute_size(&self.assigned_partitions)?;
total_size += types::Bytes.compute_size(&self.user_data)?;
Ok(total_size)
}
}
impl Decodable for ConsumerProtocolAssignment {
fn decode<B: ByteBuf>(buf: &mut B, version: i16) -> Result<Self, DecodeError> {
let assigned_partitions = types::Array(types::Struct { version }).decode(buf)?;
let user_data = types::Bytes.decode(buf)?;
Ok(Self {
assigned_partitions,
user_data,
})
}
}
impl Default for ConsumerProtocolAssignment {
fn default() -> Self {
Self {
assigned_partitions: Default::default(),
user_data: None,
}
}
}
impl Message for ConsumerProtocolAssignment {
const VERSIONS: VersionRange = VersionRange { min: 0, max: 1 };
}