kacrab_protocol/generated/
sasl_authenticate_response.rs

1//! Generated from SaslAuthenticateResponse.json - DO NOT EDIT
2#![allow(
3    missing_docs,
4    clippy::all,
5    clippy::pedantic,
6    clippy::nursery,
7    clippy::arithmetic_side_effects,
8    reason = "Generated protocol modules mirror Kafka's schema shape and intentionally trade \
9              hand-written lint style for reproducible wire-code output."
10)]
11use bytes::{Bytes, BytesMut};
12
13use crate::*;
14
15#[derive(Debug, Clone, PartialEq)]
16pub struct SaslAuthenticateResponseData {
17    /// The error code, or 0 if there was no error.
18    pub error_code: i16,
19    /// The error message, or null if there was no error.
20    pub error_message: Option<KafkaString>,
21    /// The SASL authentication bytes from the server, as defined by the SASL mechanism.
22    pub auth_bytes: Bytes,
23    /// Number of milliseconds after which only re-authentication over the existing connection to
24    /// create a new session can occur.
25    pub session_lifetime_ms: i64,
26    pub _unknown_tagged_fields: Vec<RawTaggedField>,
27}
28impl Default for SaslAuthenticateResponseData {
29    fn default() -> Self {
30        Self {
31            error_code: 0_i16,
32            error_message: None,
33            auth_bytes: Bytes::new(),
34            session_lifetime_ms: 0i64,
35            _unknown_tagged_fields: Vec::new(),
36        }
37    }
38}
39impl SaslAuthenticateResponseData {
40    pub fn with_error_code(mut self, value: i16) -> Self {
41        self.error_code = value;
42        self
43    }
44    pub fn with_error_message(mut self, value: Option<KafkaString>) -> Self {
45        self.error_message = value;
46        self
47    }
48    pub fn with_auth_bytes(mut self, value: Bytes) -> Self {
49        self.auth_bytes = value;
50        self
51    }
52    pub fn with_session_lifetime_ms(mut self, value: i64) -> Self {
53        self.session_lifetime_ms = value;
54        self
55    }
56    pub fn read(buf: &mut Bytes, version: i16) -> Result<Self> {
57        if version < 0 || version > 2 {
58            return Err(UnsupportedVersion::new(36, version).into());
59        }
60        let error_code;
61        let error_message;
62        let auth_bytes;
63        let mut session_lifetime_ms = 0i64;
64        let mut _unknown_tagged_fields: Vec<RawTaggedField> = Vec::new();
65        error_code = read_i16(buf)?;
66        if version >= 2 {
67            error_message = read_compact_nullable_string(buf)?;
68        } else {
69            error_message = read_nullable_string(buf)?;
70        }
71        if version >= 2 {
72            auth_bytes = read_compact_bytes(buf)?;
73        } else {
74            auth_bytes = read_bytes(buf)?;
75        }
76        if version >= 1 {
77            session_lifetime_ms = read_i64(buf)?;
78        }
79        if version >= 2 {
80            let tagged_fields = read_tagged_fields(buf)?;
81            for field in &tagged_fields {
82                match field.tag {
83                    _ => {
84                        _unknown_tagged_fields.push(field.clone());
85                    },
86                }
87            }
88        }
89        Ok(Self {
90            error_code,
91            error_message,
92            auth_bytes,
93            session_lifetime_ms,
94            _unknown_tagged_fields,
95        })
96    }
97    pub fn write(&self, buf: &mut BytesMut, version: i16) -> Result<()> {
98        if version < 0 || version > 2 {
99            return Err(UnsupportedVersion::new(36, version).into());
100        }
101        write_i16(buf, self.error_code);
102        if version >= 2 {
103            write_compact_nullable_string(buf, self.error_message.as_ref())?;
104        } else {
105            write_nullable_string(buf, self.error_message.as_ref())?;
106        }
107        if version >= 2 {
108            write_compact_bytes(buf, &self.auth_bytes)?;
109        } else {
110            write_bytes(buf, &self.auth_bytes)?;
111        }
112        if version >= 1 {
113            write_i64(buf, self.session_lifetime_ms);
114        } else if self.session_lifetime_ms != 0i64 {
115            return Err(UnsupportedFieldVersion::new(36, "session_lifetime_ms", version).into());
116        }
117        if version >= 2 {
118            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
119            all_tags.sort_by_key(|f| f.tag);
120            write_tagged_fields(buf, &all_tags)?;
121        }
122        Ok(())
123    }
124    pub fn encoded_len(&self, version: i16) -> Result<usize> {
125        if version < 0 || version > 2 {
126            return Err(UnsupportedVersion::new(36, version).into());
127        }
128        let mut len: usize = 0;
129        len += 2;
130        if version >= 2 {
131            len += compact_nullable_string_len(self.error_message.as_ref())?;
132        } else {
133            len += nullable_string_len(self.error_message.as_ref())?;
134        }
135        if version >= 2 {
136            len += compact_bytes_len(&self.auth_bytes)?;
137        } else {
138            len += bytes_len(&self.auth_bytes)?;
139        }
140        if version >= 1 {
141            len += 8;
142        } else if self.session_lifetime_ms != 0i64 {
143            return Err(UnsupportedFieldVersion::new(36, "session_lifetime_ms", version).into());
144        }
145        if version >= 2 {
146            let mut all_tags: Vec<RawTaggedField> = self._unknown_tagged_fields.clone();
147            all_tags.sort_by_key(|f| f.tag);
148            len += tagged_fields_len(&all_tags)?;
149        }
150        Ok(len)
151    }
152}
kacrab_protocol/generated/sasl_authenticate_response.rs

kacrab_protocol/generated/
sasl_authenticate_response.rs
