libp2p_rendezvous/generated/rendezvous/
pb.rs

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

libp2p_rendezvous/generated/rendezvous/
pb.rs
