libp2p_kad/generated/dht/
pb.rs

1// Automatically generated rust module for 'dht.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 Record {
19    pub key: Vec<u8>,
20    pub value: Vec<u8>,
21    pub timeReceived: String,
22    pub publisher: Vec<u8>,
23    pub ttl: u32,
24}
25
26impl<'a> MessageRead<'a> for Record {
27    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
28        let mut msg = Self::default();
29        while !r.is_eof() {
30            match r.next_tag(bytes) {
31                Ok(10) => msg.key = r.read_bytes(bytes)?.to_owned(),
32                Ok(18) => msg.value = r.read_bytes(bytes)?.to_owned(),
33                Ok(42) => msg.timeReceived = r.read_string(bytes)?.to_owned(),
34                Ok(5330) => msg.publisher = r.read_bytes(bytes)?.to_owned(),
35                Ok(6216) => msg.ttl = r.read_uint32(bytes)?,
36                Ok(t) => { r.read_unknown(bytes, t)?; }
37                Err(e) => return Err(e),
38            }
39        }
40        Ok(msg)
41    }
42}
43
44impl MessageWrite for Record {
45    fn get_size(&self) -> usize {
46        0
47        + if self.key.is_empty() { 0 } else { 1 + sizeof_len((&self.key).len()) }
48        + if self.value.is_empty() { 0 } else { 1 + sizeof_len((&self.value).len()) }
49        + if self.timeReceived == String::default() { 0 } else { 1 + sizeof_len((&self.timeReceived).len()) }
50        + if self.publisher.is_empty() { 0 } else { 2 + sizeof_len((&self.publisher).len()) }
51        + if self.ttl == 0u32 { 0 } else { 2 + sizeof_varint(*(&self.ttl) as u64) }
52    }
53
54    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
55        if !self.key.is_empty() { w.write_with_tag(10, |w| w.write_bytes(&**&self.key))?; }
56        if !self.value.is_empty() { w.write_with_tag(18, |w| w.write_bytes(&**&self.value))?; }
57        if self.timeReceived != String::default() { w.write_with_tag(42, |w| w.write_string(&**&self.timeReceived))?; }
58        if !self.publisher.is_empty() { w.write_with_tag(5330, |w| w.write_bytes(&**&self.publisher))?; }
59        if self.ttl != 0u32 { w.write_with_tag(6216, |w| w.write_uint32(*&self.ttl))?; }
60        Ok(())
61    }
62}
63
64#[allow(clippy::derive_partial_eq_without_eq)]
65#[derive(Debug, Default, PartialEq, Clone)]
66pub struct Message {
67    pub type_pb: dht::pb::mod_Message::MessageType,
68    pub clusterLevelRaw: i32,
69    pub key: Vec<u8>,
70    pub record: Option<dht::pb::Record>,
71    pub closerPeers: Vec<dht::pb::mod_Message::Peer>,
72    pub providerPeers: Vec<dht::pb::mod_Message::Peer>,
73}
74
75impl<'a> MessageRead<'a> for Message {
76    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
77        let mut msg = Self::default();
78        while !r.is_eof() {
79            match r.next_tag(bytes) {
80                Ok(8) => msg.type_pb = r.read_enum(bytes)?,
81                Ok(80) => msg.clusterLevelRaw = r.read_int32(bytes)?,
82                Ok(18) => msg.key = r.read_bytes(bytes)?.to_owned(),
83                Ok(26) => msg.record = Some(r.read_message::<dht::pb::Record>(bytes)?),
84                Ok(66) => msg.closerPeers.push(r.read_message::<dht::pb::mod_Message::Peer>(bytes)?),
85                Ok(74) => msg.providerPeers.push(r.read_message::<dht::pb::mod_Message::Peer>(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 Message {
95    fn get_size(&self) -> usize {
96        0
97        + if self.type_pb == dht::pb::mod_Message::MessageType::PUT_VALUE { 0 } else { 1 + sizeof_varint(*(&self.type_pb) as u64) }
98        + if self.clusterLevelRaw == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.clusterLevelRaw) as u64) }
99        + if self.key.is_empty() { 0 } else { 1 + sizeof_len((&self.key).len()) }
100        + self.record.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
101        + self.closerPeers.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
102        + self.providerPeers.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
103    }
104
105    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
106        if self.type_pb != dht::pb::mod_Message::MessageType::PUT_VALUE { w.write_with_tag(8, |w| w.write_enum(*&self.type_pb as i32))?; }
107        if self.clusterLevelRaw != 0i32 { w.write_with_tag(80, |w| w.write_int32(*&self.clusterLevelRaw))?; }
108        if !self.key.is_empty() { w.write_with_tag(18, |w| w.write_bytes(&**&self.key))?; }
109        if let Some(ref s) = self.record { w.write_with_tag(26, |w| w.write_message(s))?; }
110        for s in &self.closerPeers { w.write_with_tag(66, |w| w.write_message(s))?; }
111        for s in &self.providerPeers { w.write_with_tag(74, |w| w.write_message(s))?; }
112        Ok(())
113    }
114}
115
116pub mod mod_Message {
117
118use super::*;
119
120#[allow(clippy::derive_partial_eq_without_eq)]
121#[derive(Debug, Default, PartialEq, Clone)]
122pub struct Peer {
123    pub id: Vec<u8>,
124    pub addrs: Vec<Vec<u8>>,
125    pub connection: dht::pb::mod_Message::ConnectionType,
126}
127
128impl<'a> MessageRead<'a> for Peer {
129    fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
130        let mut msg = Self::default();
131        while !r.is_eof() {
132            match r.next_tag(bytes) {
133                Ok(10) => msg.id = r.read_bytes(bytes)?.to_owned(),
134                Ok(18) => msg.addrs.push(r.read_bytes(bytes)?.to_owned()),
135                Ok(24) => msg.connection = r.read_enum(bytes)?,
136                Ok(t) => { r.read_unknown(bytes, t)?; }
137                Err(e) => return Err(e),
138            }
139        }
140        Ok(msg)
141    }
142}
143
144impl MessageWrite for Peer {
145    fn get_size(&self) -> usize {
146        0
147        + if self.id.is_empty() { 0 } else { 1 + sizeof_len((&self.id).len()) }
148        + self.addrs.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
149        + if self.connection == dht::pb::mod_Message::ConnectionType::NOT_CONNECTED { 0 } else { 1 + sizeof_varint(*(&self.connection) as u64) }
150    }
151
152    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
153        if !self.id.is_empty() { w.write_with_tag(10, |w| w.write_bytes(&**&self.id))?; }
154        for s in &self.addrs { w.write_with_tag(18, |w| w.write_bytes(&**s))?; }
155        if self.connection != dht::pb::mod_Message::ConnectionType::NOT_CONNECTED { w.write_with_tag(24, |w| w.write_enum(*&self.connection as i32))?; }
156        Ok(())
157    }
158}
159
160#[derive(Debug, PartialEq, Eq, Clone, Copy)]
161pub enum MessageType {
162    PUT_VALUE = 0,
163    GET_VALUE = 1,
164    ADD_PROVIDER = 2,
165    GET_PROVIDERS = 3,
166    FIND_NODE = 4,
167    PING = 5,
168}
169
170impl Default for MessageType {
171    fn default() -> Self {
172        MessageType::PUT_VALUE
173    }
174}
175
176impl From<i32> for MessageType {
177    fn from(i: i32) -> Self {
178        match i {
179            0 => MessageType::PUT_VALUE,
180            1 => MessageType::GET_VALUE,
181            2 => MessageType::ADD_PROVIDER,
182            3 => MessageType::GET_PROVIDERS,
183            4 => MessageType::FIND_NODE,
184            5 => MessageType::PING,
185            _ => Self::default(),
186        }
187    }
188}
189
190impl<'a> From<&'a str> for MessageType {
191    fn from(s: &'a str) -> Self {
192        match s {
193            "PUT_VALUE" => MessageType::PUT_VALUE,
194            "GET_VALUE" => MessageType::GET_VALUE,
195            "ADD_PROVIDER" => MessageType::ADD_PROVIDER,
196            "GET_PROVIDERS" => MessageType::GET_PROVIDERS,
197            "FIND_NODE" => MessageType::FIND_NODE,
198            "PING" => MessageType::PING,
199            _ => Self::default(),
200        }
201    }
202}
203
204#[derive(Debug, PartialEq, Eq, Clone, Copy)]
205pub enum ConnectionType {
206    NOT_CONNECTED = 0,
207    CONNECTED = 1,
208    CAN_CONNECT = 2,
209    CANNOT_CONNECT = 3,
210}
211
212impl Default for ConnectionType {
213    fn default() -> Self {
214        ConnectionType::NOT_CONNECTED
215    }
216}
217
218impl From<i32> for ConnectionType {
219    fn from(i: i32) -> Self {
220        match i {
221            0 => ConnectionType::NOT_CONNECTED,
222            1 => ConnectionType::CONNECTED,
223            2 => ConnectionType::CAN_CONNECT,
224            3 => ConnectionType::CANNOT_CONNECT,
225            _ => Self::default(),
226        }
227    }
228}
229
230impl<'a> From<&'a str> for ConnectionType {
231    fn from(s: &'a str) -> Self {
232        match s {
233            "NOT_CONNECTED" => ConnectionType::NOT_CONNECTED,
234            "CONNECTED" => ConnectionType::CONNECTED,
235            "CAN_CONNECT" => ConnectionType::CAN_CONNECT,
236            "CANNOT_CONNECT" => ConnectionType::CANNOT_CONNECT,
237            _ => Self::default(),
238        }
239    }
240}
241
242}
243
libp2p_kad/generated/dht/pb.rs

libp2p_kad/generated/dht/
pb.rs
