rusp_lib/
usp_record.rs

1// Automatically generated rust module for 'usp-record-1-4.proto' file
2
3#![allow(non_snake_case)]
4#![allow(non_upper_case_globals)]
5#![allow(non_camel_case_types)]
6#![allow(unused_imports)]
7#![allow(unknown_lints)]
8#![allow(clippy::all)]
9#![cfg_attr(rustfmt, rustfmt_skip)]
10
11
12use quick_protobuf::{MessageInfo, MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result};
13use quick_protobuf::sizeofs::*;
14use super::*;
15
16#[allow(clippy::derive_partial_eq_without_eq)]
17#[derive(Debug, Default, PartialEq, Clone)]
18pub struct Record {
19    pub version: String,
20    pub to_id: String,
21    pub from_id: String,
22    pub payload_security: usp_record::mod_Record::PayloadSecurity,
23    pub mac_signature: Vec<u8>,
24    pub sender_cert: Vec<u8>,
25    pub record_type: usp_record::mod_Record::OneOfrecord_type,
26}
27
28impl<'a> MessageRead<'a> for Record {
29    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
30        let mut msg = Self::default();
31        while !r.is_eof() {
32            match r.next_tag(bytes) {
33                Ok(10) => msg.version = r.read_string(bytes)?.to_owned(),
34                Ok(18) => msg.to_id = r.read_string(bytes)?.to_owned(),
35                Ok(26) => msg.from_id = r.read_string(bytes)?.to_owned(),
36                Ok(32) => msg.payload_security = r.read_enum(bytes)?,
37                Ok(42) => msg.mac_signature = r.read_bytes(bytes)?.to_owned(),
38                Ok(50) => msg.sender_cert = r.read_bytes(bytes)?.to_owned(),
39                Ok(58) => msg.record_type = usp_record::mod_Record::OneOfrecord_type::no_session_context(r.read_message::<usp_record::NoSessionContextRecord>(bytes)?),
40                Ok(66) => msg.record_type = usp_record::mod_Record::OneOfrecord_type::session_context(r.read_message::<usp_record::SessionContextRecord>(bytes)?),
41                Ok(74) => msg.record_type = usp_record::mod_Record::OneOfrecord_type::websocket_connect(r.read_message::<usp_record::WebSocketConnectRecord>(bytes)?),
42                Ok(82) => msg.record_type = usp_record::mod_Record::OneOfrecord_type::mqtt_connect(r.read_message::<usp_record::MQTTConnectRecord>(bytes)?),
43                Ok(90) => msg.record_type = usp_record::mod_Record::OneOfrecord_type::stomp_connect(r.read_message::<usp_record::STOMPConnectRecord>(bytes)?),
44                Ok(98) => msg.record_type = usp_record::mod_Record::OneOfrecord_type::disconnect(r.read_message::<usp_record::DisconnectRecord>(bytes)?),
45                Ok(106) => msg.record_type = usp_record::mod_Record::OneOfrecord_type::uds_connect(r.read_message::<usp_record::UDSConnectRecord>(bytes)?),
46                Ok(t) => { r.read_unknown(bytes, t)?; }
47                Err(e) => return Err(e),
48            }
49        }
50        Ok(msg)
51    }
52}
53
54impl MessageWrite for Record {
55    fn get_size(&self) -> usize {
56        0
57        + if self.version == String::default() { 0 } else { 1 + sizeof_len((&self.version).len()) }
58        + if self.to_id == String::default() { 0 } else { 1 + sizeof_len((&self.to_id).len()) }
59        + if self.from_id == String::default() { 0 } else { 1 + sizeof_len((&self.from_id).len()) }
60        + if self.payload_security == usp_record::mod_Record::PayloadSecurity::PLAINTEXT { 0 } else { 1 + sizeof_varint(*(&self.payload_security) as u64) }
61        + if self.mac_signature.is_empty() { 0 } else { 1 + sizeof_len((&self.mac_signature).len()) }
62        + if self.sender_cert.is_empty() { 0 } else { 1 + sizeof_len((&self.sender_cert).len()) }
63        + match self.record_type {
64            usp_record::mod_Record::OneOfrecord_type::no_session_context(ref m) => 1 + sizeof_len((m).get_size()),
65            usp_record::mod_Record::OneOfrecord_type::session_context(ref m) => 1 + sizeof_len((m).get_size()),
66            usp_record::mod_Record::OneOfrecord_type::websocket_connect(ref m) => 1 + sizeof_len((m).get_size()),
67            usp_record::mod_Record::OneOfrecord_type::mqtt_connect(ref m) => 1 + sizeof_len((m).get_size()),
68            usp_record::mod_Record::OneOfrecord_type::stomp_connect(ref m) => 1 + sizeof_len((m).get_size()),
69            usp_record::mod_Record::OneOfrecord_type::disconnect(ref m) => 1 + sizeof_len((m).get_size()),
70            usp_record::mod_Record::OneOfrecord_type::uds_connect(ref m) => 1 + sizeof_len((m).get_size()),
71            usp_record::mod_Record::OneOfrecord_type::None => 0,
72    }    }
73
74    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
75        if self.version != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.version))?; }
76        if self.to_id != String::default() { w.write_with_tag(18, |w| w.write_string(&**&self.to_id))?; }
77        if self.from_id != String::default() { w.write_with_tag(26, |w| w.write_string(&**&self.from_id))?; }
78        if self.payload_security != usp_record::mod_Record::PayloadSecurity::PLAINTEXT { w.write_with_tag(32, |w| w.write_enum(*&self.payload_security as i32))?; }
79        if !self.mac_signature.is_empty() { w.write_with_tag(42, |w| w.write_bytes(&**&self.mac_signature))?; }
80        if !self.sender_cert.is_empty() { w.write_with_tag(50, |w| w.write_bytes(&**&self.sender_cert))?; }
81        match self.record_type {            usp_record::mod_Record::OneOfrecord_type::no_session_context(ref m) => { w.write_with_tag(58, |w| w.write_message(m))? },
82            usp_record::mod_Record::OneOfrecord_type::session_context(ref m) => { w.write_with_tag(66, |w| w.write_message(m))? },
83            usp_record::mod_Record::OneOfrecord_type::websocket_connect(ref m) => { w.write_with_tag(74, |w| w.write_message(m))? },
84            usp_record::mod_Record::OneOfrecord_type::mqtt_connect(ref m) => { w.write_with_tag(82, |w| w.write_message(m))? },
85            usp_record::mod_Record::OneOfrecord_type::stomp_connect(ref m) => { w.write_with_tag(90, |w| w.write_message(m))? },
86            usp_record::mod_Record::OneOfrecord_type::disconnect(ref m) => { w.write_with_tag(98, |w| w.write_message(m))? },
87            usp_record::mod_Record::OneOfrecord_type::uds_connect(ref m) => { w.write_with_tag(106, |w| w.write_message(m))? },
88            usp_record::mod_Record::OneOfrecord_type::None => {},
89    }        Ok(())
90    }
91}
92
93pub mod mod_Record {
94
95use super::*;
96
97#[derive(Debug, PartialEq, Eq, Clone, Copy)]
98pub enum PayloadSecurity {
99    PLAINTEXT = 0,
100    TLS12 = 1,
101}
102
103impl Default for PayloadSecurity {
104    fn default() -> Self {
105        PayloadSecurity::PLAINTEXT
106    }
107}
108
109impl From<i32> for PayloadSecurity {
110    fn from(i: i32) -> Self {
111        match i {
112            0 => PayloadSecurity::PLAINTEXT,
113            1 => PayloadSecurity::TLS12,
114            _ => Self::default(),
115        }
116    }
117}
118
119impl<'a> From<&'a str> for PayloadSecurity {
120    fn from(s: &'a str) -> Self {
121        match s {
122            "PLAINTEXT" => PayloadSecurity::PLAINTEXT,
123            "TLS12" => PayloadSecurity::TLS12,
124            _ => Self::default(),
125        }
126    }
127}
128
129#[derive(Debug, PartialEq, Clone)]
130pub enum OneOfrecord_type {
131    no_session_context(usp_record::NoSessionContextRecord),
132    session_context(usp_record::SessionContextRecord),
133    websocket_connect(usp_record::WebSocketConnectRecord),
134    mqtt_connect(usp_record::MQTTConnectRecord),
135    stomp_connect(usp_record::STOMPConnectRecord),
136    disconnect(usp_record::DisconnectRecord),
137    uds_connect(usp_record::UDSConnectRecord),
138    None,
139}
140
141impl Default for OneOfrecord_type {
142    fn default() -> Self {
143        OneOfrecord_type::None
144    }
145}
146
147}
148
149#[allow(clippy::derive_partial_eq_without_eq)]
150#[derive(Debug, Default, PartialEq, Clone)]
151pub struct NoSessionContextRecord {
152    pub payload: Vec<u8>,
153}
154
155impl<'a> MessageRead<'a> for NoSessionContextRecord {
156    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
157        let mut msg = Self::default();
158        while !r.is_eof() {
159            match r.next_tag(bytes) {
160                Ok(18) => msg.payload = r.read_bytes(bytes)?.to_owned(),
161                Ok(t) => { r.read_unknown(bytes, t)?; }
162                Err(e) => return Err(e),
163            }
164        }
165        Ok(msg)
166    }
167}
168
169impl MessageWrite for NoSessionContextRecord {
170    fn get_size(&self) -> usize {
171        0
172        + if self.payload.is_empty() { 0 } else { 1 + sizeof_len((&self.payload).len()) }
173    }
174
175    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
176        if !self.payload.is_empty() { w.write_with_tag(18, |w| w.write_bytes(&**&self.payload))?; }
177        Ok(())
178    }
179}
180
181#[allow(clippy::derive_partial_eq_without_eq)]
182#[derive(Debug, Default, PartialEq, Clone)]
183pub struct SessionContextRecord {
184    pub session_id: u64,
185    pub sequence_id: u64,
186    pub expected_id: u64,
187    pub retransmit_id: u64,
188    pub payload_sar_state: usp_record::mod_SessionContextRecord::PayloadSARState,
189    pub payloadrec_sar_state: usp_record::mod_SessionContextRecord::PayloadSARState,
190    pub payload: Vec<Vec<u8>>,
191}
192
193impl<'a> MessageRead<'a> for SessionContextRecord {
194    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
195        let mut msg = Self::default();
196        while !r.is_eof() {
197            match r.next_tag(bytes) {
198                Ok(8) => msg.session_id = r.read_uint64(bytes)?,
199                Ok(16) => msg.sequence_id = r.read_uint64(bytes)?,
200                Ok(24) => msg.expected_id = r.read_uint64(bytes)?,
201                Ok(32) => msg.retransmit_id = r.read_uint64(bytes)?,
202                Ok(40) => msg.payload_sar_state = r.read_enum(bytes)?,
203                Ok(48) => msg.payloadrec_sar_state = r.read_enum(bytes)?,
204                Ok(58) => msg.payload.push(r.read_bytes(bytes)?.to_owned()),
205                Ok(t) => { r.read_unknown(bytes, t)?; }
206                Err(e) => return Err(e),
207            }
208        }
209        Ok(msg)
210    }
211}
212
213impl MessageWrite for SessionContextRecord {
214    fn get_size(&self) -> usize {
215        0
216        + if self.session_id == 0u64 { 0 } else { 1 + sizeof_varint(*(&self.session_id) as u64) }
217        + if self.sequence_id == 0u64 { 0 } else { 1 + sizeof_varint(*(&self.sequence_id) as u64) }
218        + if self.expected_id == 0u64 { 0 } else { 1 + sizeof_varint(*(&self.expected_id) as u64) }
219        + if self.retransmit_id == 0u64 { 0 } else { 1 + sizeof_varint(*(&self.retransmit_id) as u64) }
220        + if self.payload_sar_state == usp_record::mod_SessionContextRecord::PayloadSARState::NONE { 0 } else { 1 + sizeof_varint(*(&self.payload_sar_state) as u64) }
221        + if self.payloadrec_sar_state == usp_record::mod_SessionContextRecord::PayloadSARState::NONE { 0 } else { 1 + sizeof_varint(*(&self.payloadrec_sar_state) as u64) }
222        + self.payload.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
223    }
224
225    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
226        if self.session_id != 0u64 { w.write_with_tag(8, |w| w.write_uint64(*&self.session_id))?; }
227        if self.sequence_id != 0u64 { w.write_with_tag(16, |w| w.write_uint64(*&self.sequence_id))?; }
228        if self.expected_id != 0u64 { w.write_with_tag(24, |w| w.write_uint64(*&self.expected_id))?; }
229        if self.retransmit_id != 0u64 { w.write_with_tag(32, |w| w.write_uint64(*&self.retransmit_id))?; }
230        if self.payload_sar_state != usp_record::mod_SessionContextRecord::PayloadSARState::NONE { w.write_with_tag(40, |w| w.write_enum(*&self.payload_sar_state as i32))?; }
231        if self.payloadrec_sar_state != usp_record::mod_SessionContextRecord::PayloadSARState::NONE { w.write_with_tag(48, |w| w.write_enum(*&self.payloadrec_sar_state as i32))?; }
232        for s in &self.payload { w.write_with_tag(58, |w| w.write_bytes(&**s))?; }
233        Ok(())
234    }
235}
236
237pub mod mod_SessionContextRecord {
238
239
240#[derive(Debug, PartialEq, Eq, Clone, Copy)]
241pub enum PayloadSARState {
242    NONE = 0,
243    BEGIN = 1,
244    INPROCESS = 2,
245    COMPLETE = 3,
246}
247
248impl Default for PayloadSARState {
249    fn default() -> Self {
250        PayloadSARState::NONE
251    }
252}
253
254impl From<i32> for PayloadSARState {
255    fn from(i: i32) -> Self {
256        match i {
257            0 => PayloadSARState::NONE,
258            1 => PayloadSARState::BEGIN,
259            2 => PayloadSARState::INPROCESS,
260            3 => PayloadSARState::COMPLETE,
261            _ => Self::default(),
262        }
263    }
264}
265
266impl<'a> From<&'a str> for PayloadSARState {
267    fn from(s: &'a str) -> Self {
268        match s {
269            "NONE" => PayloadSARState::NONE,
270            "BEGIN" => PayloadSARState::BEGIN,
271            "INPROCESS" => PayloadSARState::INPROCESS,
272            "COMPLETE" => PayloadSARState::COMPLETE,
273            _ => Self::default(),
274        }
275    }
276}
277
278}
279
280#[allow(clippy::derive_partial_eq_without_eq)]
281#[derive(Debug, Default, PartialEq, Clone)]
282pub struct WebSocketConnectRecord { }
283
284impl<'a> MessageRead<'a> for WebSocketConnectRecord {
285    fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
286        r.read_to_end();
287        Ok(Self::default())
288    }
289}
290
291impl MessageWrite for WebSocketConnectRecord { }
292
293#[allow(clippy::derive_partial_eq_without_eq)]
294#[derive(Debug, Default, PartialEq, Clone)]
295pub struct MQTTConnectRecord {
296    pub version: usp_record::mod_MQTTConnectRecord::MQTTVersion,
297    pub subscribed_topic: String,
298}
299
300impl<'a> MessageRead<'a> for MQTTConnectRecord {
301    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
302        let mut msg = Self::default();
303        while !r.is_eof() {
304            match r.next_tag(bytes) {
305                Ok(8) => msg.version = r.read_enum(bytes)?,
306                Ok(18) => msg.subscribed_topic = r.read_string(bytes)?.to_owned(),
307                Ok(t) => { r.read_unknown(bytes, t)?; }
308                Err(e) => return Err(e),
309            }
310        }
311        Ok(msg)
312    }
313}
314
315impl MessageWrite for MQTTConnectRecord {
316    fn get_size(&self) -> usize {
317        0
318        + if self.version == usp_record::mod_MQTTConnectRecord::MQTTVersion::V3_1_1 { 0 } else { 1 + sizeof_varint(*(&self.version) as u64) }
319        + if self.subscribed_topic == String::default() { 0 } else { 1 + sizeof_len((&self.subscribed_topic).len()) }
320    }
321
322    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
323        if self.version != usp_record::mod_MQTTConnectRecord::MQTTVersion::V3_1_1 { w.write_with_tag(8, |w| w.write_enum(*&self.version as i32))?; }
324        if self.subscribed_topic != String::default() { w.write_with_tag(18, |w| w.write_string(&**&self.subscribed_topic))?; }
325        Ok(())
326    }
327}
328
329pub mod mod_MQTTConnectRecord {
330
331
332#[derive(Debug, PartialEq, Eq, Clone, Copy)]
333pub enum MQTTVersion {
334    V3_1_1 = 0,
335    V5 = 1,
336}
337
338impl Default for MQTTVersion {
339    fn default() -> Self {
340        MQTTVersion::V3_1_1
341    }
342}
343
344impl From<i32> for MQTTVersion {
345    fn from(i: i32) -> Self {
346        match i {
347            0 => MQTTVersion::V3_1_1,
348            1 => MQTTVersion::V5,
349            _ => Self::default(),
350        }
351    }
352}
353
354impl<'a> From<&'a str> for MQTTVersion {
355    fn from(s: &'a str) -> Self {
356        match s {
357            "V3_1_1" => MQTTVersion::V3_1_1,
358            "V5" => MQTTVersion::V5,
359            _ => Self::default(),
360        }
361    }
362}
363
364}
365
366#[allow(clippy::derive_partial_eq_without_eq)]
367#[derive(Debug, Default, PartialEq, Clone)]
368pub struct STOMPConnectRecord {
369    pub version: usp_record::mod_STOMPConnectRecord::STOMPVersion,
370    pub subscribed_destination: String,
371}
372
373impl<'a> MessageRead<'a> for STOMPConnectRecord {
374    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
375        let mut msg = Self::default();
376        while !r.is_eof() {
377            match r.next_tag(bytes) {
378                Ok(8) => msg.version = r.read_enum(bytes)?,
379                Ok(18) => msg.subscribed_destination = r.read_string(bytes)?.to_owned(),
380                Ok(t) => { r.read_unknown(bytes, t)?; }
381                Err(e) => return Err(e),
382            }
383        }
384        Ok(msg)
385    }
386}
387
388impl MessageWrite for STOMPConnectRecord {
389    fn get_size(&self) -> usize {
390        0
391        + if self.version == usp_record::mod_STOMPConnectRecord::STOMPVersion::V1_2 { 0 } else { 1 + sizeof_varint(*(&self.version) as u64) }
392        + if self.subscribed_destination == String::default() { 0 } else { 1 + sizeof_len((&self.subscribed_destination).len()) }
393    }
394
395    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
396        if self.version != usp_record::mod_STOMPConnectRecord::STOMPVersion::V1_2 { w.write_with_tag(8, |w| w.write_enum(*&self.version as i32))?; }
397        if self.subscribed_destination != String::default() { w.write_with_tag(18, |w| w.write_string(&**&self.subscribed_destination))?; }
398        Ok(())
399    }
400}
401
402pub mod mod_STOMPConnectRecord {
403
404
405#[derive(Debug, PartialEq, Eq, Clone, Copy)]
406pub enum STOMPVersion {
407    V1_2 = 0,
408}
409
410impl Default for STOMPVersion {
411    fn default() -> Self {
412        STOMPVersion::V1_2
413    }
414}
415
416impl From<i32> for STOMPVersion {
417    fn from(i: i32) -> Self {
418        match i {
419            0 => STOMPVersion::V1_2,
420            _ => Self::default(),
421        }
422    }
423}
424
425impl<'a> From<&'a str> for STOMPVersion {
426    fn from(s: &'a str) -> Self {
427        match s {
428            "V1_2" => STOMPVersion::V1_2,
429            _ => Self::default(),
430        }
431    }
432}
433
434}
435
436#[allow(clippy::derive_partial_eq_without_eq)]
437#[derive(Debug, Default, PartialEq, Clone)]
438pub struct UDSConnectRecord { }
439
440impl<'a> MessageRead<'a> for UDSConnectRecord {
441    fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
442        r.read_to_end();
443        Ok(Self::default())
444    }
445}
446
447impl MessageWrite for UDSConnectRecord { }
448
449#[allow(clippy::derive_partial_eq_without_eq)]
450#[derive(Debug, Default, PartialEq, Clone)]
451pub struct DisconnectRecord {
452    pub reason: String,
453    pub reason_code: u32,
454}
455
456impl<'a> MessageRead<'a> for DisconnectRecord {
457    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
458        let mut msg = Self::default();
459        while !r.is_eof() {
460            match r.next_tag(bytes) {
461                Ok(10) => msg.reason = r.read_string(bytes)?.to_owned(),
462                Ok(21) => msg.reason_code = r.read_fixed32(bytes)?,
463                Ok(t) => { r.read_unknown(bytes, t)?; }
464                Err(e) => return Err(e),
465            }
466        }
467        Ok(msg)
468    }
469}
470
471impl MessageWrite for DisconnectRecord {
472    fn get_size(&self) -> usize {
473        0
474        + if self.reason == String::default() { 0 } else { 1 + sizeof_len((&self.reason).len()) }
475        + if self.reason_code == 0u32 { 0 } else { 1 + 4 }
476    }
477
478    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
479        if self.reason != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.reason))?; }
480        if self.reason_code != 0u32 { w.write_with_tag(21, |w| w.write_fixed32(*&self.reason_code))?; }
481        Ok(())
482    }
483}
484
rusp_lib/usp_record.rs

rusp_lib/
usp_record.rs
