libp2p_relay/generated/message_v2/
pb.rs

1// Automatically generated rust module for 'message.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::super::*;
15
16#[derive(Debug, PartialEq, Eq, Clone, Copy)]
17pub enum Status {
18    OK = 100,
19    RESERVATION_REFUSED = 200,
20    RESOURCE_LIMIT_EXCEEDED = 201,
21    PERMISSION_DENIED = 202,
22    CONNECTION_FAILED = 203,
23    NO_RESERVATION = 204,
24    MALFORMED_MESSAGE = 400,
25    UNEXPECTED_MESSAGE = 401,
26}
27
28impl Default for Status {
29    fn default() -> Self {
30        Status::OK
31    }
32}
33
34impl From<i32> for Status {
35    fn from(i: i32) -> Self {
36        match i {
37            100 => Status::OK,
38            200 => Status::RESERVATION_REFUSED,
39            201 => Status::RESOURCE_LIMIT_EXCEEDED,
40            202 => Status::PERMISSION_DENIED,
41            203 => Status::CONNECTION_FAILED,
42            204 => Status::NO_RESERVATION,
43            400 => Status::MALFORMED_MESSAGE,
44            401 => Status::UNEXPECTED_MESSAGE,
45            _ => Self::default(),
46        }
47    }
48}
49
50impl<'a> From<&'a str> for Status {
51    fn from(s: &'a str) -> Self {
52        match s {
53            "OK" => Status::OK,
54            "RESERVATION_REFUSED" => Status::RESERVATION_REFUSED,
55            "RESOURCE_LIMIT_EXCEEDED" => Status::RESOURCE_LIMIT_EXCEEDED,
56            "PERMISSION_DENIED" => Status::PERMISSION_DENIED,
57            "CONNECTION_FAILED" => Status::CONNECTION_FAILED,
58            "NO_RESERVATION" => Status::NO_RESERVATION,
59            "MALFORMED_MESSAGE" => Status::MALFORMED_MESSAGE,
60            "UNEXPECTED_MESSAGE" => Status::UNEXPECTED_MESSAGE,
61            _ => Self::default(),
62        }
63    }
64}
65
66#[allow(clippy::derive_partial_eq_without_eq)]
67#[derive(Debug, Default, PartialEq, Clone)]
68pub struct HopMessage {
69    pub type_pb: message_v2::pb::mod_HopMessage::Type,
70    pub peer: Option<message_v2::pb::Peer>,
71    pub reservation: Option<message_v2::pb::Reservation>,
72    pub limit: Option<message_v2::pb::Limit>,
73    pub status: Option<message_v2::pb::Status>,
74}
75
76impl<'a> MessageRead<'a> for HopMessage {
77    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
78        let mut msg = Self::default();
79        while !r.is_eof() {
80            match r.next_tag(bytes) {
81                Ok(8) => msg.type_pb = r.read_enum(bytes)?,
82                Ok(18) => msg.peer = Some(r.read_message::<message_v2::pb::Peer>(bytes)?),
83                Ok(26) => msg.reservation = Some(r.read_message::<message_v2::pb::Reservation>(bytes)?),
84                Ok(34) => msg.limit = Some(r.read_message::<message_v2::pb::Limit>(bytes)?),
85                Ok(40) => msg.status = Some(r.read_enum(bytes)?),
86                Ok(t) => { r.read_unknown(bytes, t)?; }
87                Err(e) => return Err(e),
88            }
89        }
90        Ok(msg)
91    }
92}
93
94impl MessageWrite for HopMessage {
95    fn get_size(&self) -> usize {
96        0
97        + 1 + sizeof_varint(*(&self.type_pb) as u64)
98        + self.peer.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
99        + self.reservation.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
100        + self.limit.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
101        + self.status.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
102    }
103
104    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
105        w.write_with_tag(8, |w| w.write_enum(*&self.type_pb as i32))?;
106        if let Some(ref s) = self.peer { w.write_with_tag(18, |w| w.write_message(s))?; }
107        if let Some(ref s) = self.reservation { w.write_with_tag(26, |w| w.write_message(s))?; }
108        if let Some(ref s) = self.limit { w.write_with_tag(34, |w| w.write_message(s))?; }
109        if let Some(ref s) = self.status { w.write_with_tag(40, |w| w.write_enum(*s as i32))?; }
110        Ok(())
111    }
112}
113
114pub mod mod_HopMessage {
115
116
117#[derive(Debug, PartialEq, Eq, Clone, Copy)]
118pub enum Type {
119    RESERVE = 0,
120    CONNECT = 1,
121    STATUS = 2,
122}
123
124impl Default for Type {
125    fn default() -> Self {
126        Type::RESERVE
127    }
128}
129
130impl From<i32> for Type {
131    fn from(i: i32) -> Self {
132        match i {
133            0 => Type::RESERVE,
134            1 => Type::CONNECT,
135            2 => Type::STATUS,
136            _ => Self::default(),
137        }
138    }
139}
140
141impl<'a> From<&'a str> for Type {
142    fn from(s: &'a str) -> Self {
143        match s {
144            "RESERVE" => Type::RESERVE,
145            "CONNECT" => Type::CONNECT,
146            "STATUS" => Type::STATUS,
147            _ => Self::default(),
148        }
149    }
150}
151
152}
153
154#[allow(clippy::derive_partial_eq_without_eq)]
155#[derive(Debug, Default, PartialEq, Clone)]
156pub struct StopMessage {
157    pub type_pb: message_v2::pb::mod_StopMessage::Type,
158    pub peer: Option<message_v2::pb::Peer>,
159    pub limit: Option<message_v2::pb::Limit>,
160    pub status: Option<message_v2::pb::Status>,
161}
162
163impl<'a> MessageRead<'a> for StopMessage {
164    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
165        let mut msg = Self::default();
166        while !r.is_eof() {
167            match r.next_tag(bytes) {
168                Ok(8) => msg.type_pb = r.read_enum(bytes)?,
169                Ok(18) => msg.peer = Some(r.read_message::<message_v2::pb::Peer>(bytes)?),
170                Ok(26) => msg.limit = Some(r.read_message::<message_v2::pb::Limit>(bytes)?),
171                Ok(32) => msg.status = Some(r.read_enum(bytes)?),
172                Ok(t) => { r.read_unknown(bytes, t)?; }
173                Err(e) => return Err(e),
174            }
175        }
176        Ok(msg)
177    }
178}
179
180impl MessageWrite for StopMessage {
181    fn get_size(&self) -> usize {
182        0
183        + 1 + sizeof_varint(*(&self.type_pb) as u64)
184        + self.peer.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
185        + self.limit.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
186        + self.status.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
187    }
188
189    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
190        w.write_with_tag(8, |w| w.write_enum(*&self.type_pb as i32))?;
191        if let Some(ref s) = self.peer { w.write_with_tag(18, |w| w.write_message(s))?; }
192        if let Some(ref s) = self.limit { w.write_with_tag(26, |w| w.write_message(s))?; }
193        if let Some(ref s) = self.status { w.write_with_tag(32, |w| w.write_enum(*s as i32))?; }
194        Ok(())
195    }
196}
197
198pub mod mod_StopMessage {
199
200
201#[derive(Debug, PartialEq, Eq, Clone, Copy)]
202pub enum Type {
203    CONNECT = 0,
204    STATUS = 1,
205}
206
207impl Default for Type {
208    fn default() -> Self {
209        Type::CONNECT
210    }
211}
212
213impl From<i32> for Type {
214    fn from(i: i32) -> Self {
215        match i {
216            0 => Type::CONNECT,
217            1 => Type::STATUS,
218            _ => Self::default(),
219        }
220    }
221}
222
223impl<'a> From<&'a str> for Type {
224    fn from(s: &'a str) -> Self {
225        match s {
226            "CONNECT" => Type::CONNECT,
227            "STATUS" => Type::STATUS,
228            _ => Self::default(),
229        }
230    }
231}
232
233}
234
235#[allow(clippy::derive_partial_eq_without_eq)]
236#[derive(Debug, Default, PartialEq, Clone)]
237pub struct Peer {
238    pub id: Vec<u8>,
239    pub addrs: Vec<Vec<u8>>,
240}
241
242impl<'a> MessageRead<'a> for Peer {
243    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
244        let mut msg = Self::default();
245        while !r.is_eof() {
246            match r.next_tag(bytes) {
247                Ok(10) => msg.id = r.read_bytes(bytes)?.to_owned(),
248                Ok(18) => msg.addrs.push(r.read_bytes(bytes)?.to_owned()),
249                Ok(t) => { r.read_unknown(bytes, t)?; }
250                Err(e) => return Err(e),
251            }
252        }
253        Ok(msg)
254    }
255}
256
257impl MessageWrite for Peer {
258    fn get_size(&self) -> usize {
259        0
260        + 1 + sizeof_len((&self.id).len())
261        + self.addrs.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
262    }
263
264    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
265        w.write_with_tag(10, |w| w.write_bytes(&**&self.id))?;
266        for s in &self.addrs { w.write_with_tag(18, |w| w.write_bytes(&**s))?; }
267        Ok(())
268    }
269}
270
271#[allow(clippy::derive_partial_eq_without_eq)]
272#[derive(Debug, Default, PartialEq, Clone)]
273pub struct Reservation {
274    pub expire: u64,
275    pub addrs: Vec<Vec<u8>>,
276    pub voucher: Option<Vec<u8>>,
277}
278
279impl<'a> MessageRead<'a> for Reservation {
280    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
281        let mut msg = Self::default();
282        while !r.is_eof() {
283            match r.next_tag(bytes) {
284                Ok(8) => msg.expire = r.read_uint64(bytes)?,
285                Ok(18) => msg.addrs.push(r.read_bytes(bytes)?.to_owned()),
286                Ok(26) => msg.voucher = Some(r.read_bytes(bytes)?.to_owned()),
287                Ok(t) => { r.read_unknown(bytes, t)?; }
288                Err(e) => return Err(e),
289            }
290        }
291        Ok(msg)
292    }
293}
294
295impl MessageWrite for Reservation {
296    fn get_size(&self) -> usize {
297        0
298        + 1 + sizeof_varint(*(&self.expire) as u64)
299        + self.addrs.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
300        + self.voucher.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
301    }
302
303    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
304        w.write_with_tag(8, |w| w.write_uint64(*&self.expire))?;
305        for s in &self.addrs { w.write_with_tag(18, |w| w.write_bytes(&**s))?; }
306        if let Some(ref s) = self.voucher { w.write_with_tag(26, |w| w.write_bytes(&**s))?; }
307        Ok(())
308    }
309}
310
311#[allow(clippy::derive_partial_eq_without_eq)]
312#[derive(Debug, Default, PartialEq, Clone)]
313pub struct Limit {
314    pub duration: Option<u32>,
315    pub data: Option<u64>,
316}
317
318impl<'a> MessageRead<'a> for Limit {
319    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
320        let mut msg = Self::default();
321        while !r.is_eof() {
322            match r.next_tag(bytes) {
323                Ok(8) => msg.duration = Some(r.read_uint32(bytes)?),
324                Ok(16) => msg.data = Some(r.read_uint64(bytes)?),
325                Ok(t) => { r.read_unknown(bytes, t)?; }
326                Err(e) => return Err(e),
327            }
328        }
329        Ok(msg)
330    }
331}
332
333impl MessageWrite for Limit {
334    fn get_size(&self) -> usize {
335        0
336        + self.duration.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
337        + self.data.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
338    }
339
340    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
341        if let Some(ref s) = self.duration { w.write_with_tag(8, |w| w.write_uint32(*s))?; }
342        if let Some(ref s) = self.data { w.write_with_tag(16, |w| w.write_uint64(*s))?; }
343        Ok(())
344    }
345}
346
libp2p_relay/generated/message_v2/pb.rs

libp2p_relay/generated/message_v2/
pb.rs
