1142 lines
40 KiB
Rust
1142 lines
40 KiB
Rust
// This file is generated by rust-protobuf 3.2.0. Do not edit
|
|
// .proto file is parsed by pure
|
|
// @generated
|
|
|
|
// https://github.com/rust-lang/rust-clippy/issues/702
|
|
#![allow(unknown_lints)]
|
|
#![allow(clippy::all)]
|
|
|
|
#![allow(unused_attributes)]
|
|
#![cfg_attr(rustfmt, rustfmt::skip)]
|
|
|
|
#![allow(box_pointers)]
|
|
#![allow(dead_code)]
|
|
#![allow(missing_docs)]
|
|
#![allow(non_camel_case_types)]
|
|
#![allow(non_snake_case)]
|
|
#![allow(non_upper_case_globals)]
|
|
#![allow(trivial_casts)]
|
|
#![allow(unused_results)]
|
|
#![allow(unused_mut)]
|
|
|
|
//! Generated file from `message.proto`
|
|
|
|
/// Generated files are compatible only with the same version
|
|
/// of protobuf runtime.
|
|
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_2_0;
|
|
|
|
#[derive(PartialEq,Clone,Default,Debug)]
|
|
// @@protoc_insertion_point(message:RegistrationRequest)
|
|
pub struct RegistrationRequest {
|
|
// message fields
|
|
// @@protoc_insertion_point(field:RegistrationRequest.token)
|
|
pub token: ::std::string::String,
|
|
// @@protoc_insertion_point(field:RegistrationRequest.mac_address)
|
|
pub mac_address: ::std::string::String,
|
|
// @@protoc_insertion_point(field:RegistrationRequest.name)
|
|
pub name: ::std::string::String,
|
|
// @@protoc_insertion_point(field:RegistrationRequest.is_fast)
|
|
pub is_fast: bool,
|
|
// special fields
|
|
// @@protoc_insertion_point(special_field:RegistrationRequest.special_fields)
|
|
pub special_fields: ::protobuf::SpecialFields,
|
|
}
|
|
|
|
impl<'a> ::std::default::Default for &'a RegistrationRequest {
|
|
fn default() -> &'a RegistrationRequest {
|
|
<RegistrationRequest as ::protobuf::Message>::default_instance()
|
|
}
|
|
}
|
|
|
|
impl RegistrationRequest {
|
|
pub fn new() -> RegistrationRequest {
|
|
::std::default::Default::default()
|
|
}
|
|
|
|
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
|
|
let mut fields = ::std::vec::Vec::with_capacity(4);
|
|
let mut oneofs = ::std::vec::Vec::with_capacity(0);
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"token",
|
|
|m: &RegistrationRequest| { &m.token },
|
|
|m: &mut RegistrationRequest| { &mut m.token },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"mac_address",
|
|
|m: &RegistrationRequest| { &m.mac_address },
|
|
|m: &mut RegistrationRequest| { &mut m.mac_address },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"name",
|
|
|m: &RegistrationRequest| { &m.name },
|
|
|m: &mut RegistrationRequest| { &mut m.name },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"is_fast",
|
|
|m: &RegistrationRequest| { &m.is_fast },
|
|
|m: &mut RegistrationRequest| { &mut m.is_fast },
|
|
));
|
|
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RegistrationRequest>(
|
|
"RegistrationRequest",
|
|
fields,
|
|
oneofs,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::Message for RegistrationRequest {
|
|
const NAME: &'static str = "RegistrationRequest";
|
|
|
|
fn is_initialized(&self) -> bool {
|
|
true
|
|
}
|
|
|
|
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
|
|
while let Some(tag) = is.read_raw_tag_or_eof()? {
|
|
match tag {
|
|
10 => {
|
|
self.token = is.read_string()?;
|
|
},
|
|
18 => {
|
|
self.mac_address = is.read_string()?;
|
|
},
|
|
26 => {
|
|
self.name = is.read_string()?;
|
|
},
|
|
32 => {
|
|
self.is_fast = is.read_bool()?;
|
|
},
|
|
tag => {
|
|
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
|
|
},
|
|
};
|
|
}
|
|
::std::result::Result::Ok(())
|
|
}
|
|
|
|
// Compute sizes of nested messages
|
|
#[allow(unused_variables)]
|
|
fn compute_size(&self) -> u64 {
|
|
let mut my_size = 0;
|
|
if !self.token.is_empty() {
|
|
my_size += ::protobuf::rt::string_size(1, &self.token);
|
|
}
|
|
if !self.mac_address.is_empty() {
|
|
my_size += ::protobuf::rt::string_size(2, &self.mac_address);
|
|
}
|
|
if !self.name.is_empty() {
|
|
my_size += ::protobuf::rt::string_size(3, &self.name);
|
|
}
|
|
if self.is_fast != false {
|
|
my_size += 1 + 1;
|
|
}
|
|
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
|
|
self.special_fields.cached_size().set(my_size as u32);
|
|
my_size
|
|
}
|
|
|
|
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
|
|
if !self.token.is_empty() {
|
|
os.write_string(1, &self.token)?;
|
|
}
|
|
if !self.mac_address.is_empty() {
|
|
os.write_string(2, &self.mac_address)?;
|
|
}
|
|
if !self.name.is_empty() {
|
|
os.write_string(3, &self.name)?;
|
|
}
|
|
if self.is_fast != false {
|
|
os.write_bool(4, self.is_fast)?;
|
|
}
|
|
os.write_unknown_fields(self.special_fields.unknown_fields())?;
|
|
::std::result::Result::Ok(())
|
|
}
|
|
|
|
fn special_fields(&self) -> &::protobuf::SpecialFields {
|
|
&self.special_fields
|
|
}
|
|
|
|
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
|
|
&mut self.special_fields
|
|
}
|
|
|
|
fn new() -> RegistrationRequest {
|
|
RegistrationRequest::new()
|
|
}
|
|
|
|
fn clear(&mut self) {
|
|
self.token.clear();
|
|
self.mac_address.clear();
|
|
self.name.clear();
|
|
self.is_fast = false;
|
|
self.special_fields.clear();
|
|
}
|
|
|
|
fn default_instance() -> &'static RegistrationRequest {
|
|
static instance: RegistrationRequest = RegistrationRequest {
|
|
token: ::std::string::String::new(),
|
|
mac_address: ::std::string::String::new(),
|
|
name: ::std::string::String::new(),
|
|
is_fast: false,
|
|
special_fields: ::protobuf::SpecialFields::new(),
|
|
};
|
|
&instance
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::MessageFull for RegistrationRequest {
|
|
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
|
|
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
|
|
descriptor.get(|| file_descriptor().message_by_package_relative_name("RegistrationRequest").unwrap()).clone()
|
|
}
|
|
}
|
|
|
|
impl ::std::fmt::Display for RegistrationRequest {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
|
|
::protobuf::text_format::fmt(self, f)
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::reflect::ProtobufValue for RegistrationRequest {
|
|
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
|
|
}
|
|
|
|
#[derive(PartialEq,Clone,Default,Debug)]
|
|
// @@protoc_insertion_point(message:RegistrationResponse)
|
|
pub struct RegistrationResponse {
|
|
// message fields
|
|
// @@protoc_insertion_point(field:RegistrationResponse.virtual_ip)
|
|
pub virtual_ip: u32,
|
|
// @@protoc_insertion_point(field:RegistrationResponse.virtual_gateway)
|
|
pub virtual_gateway: u32,
|
|
// @@protoc_insertion_point(field:RegistrationResponse.virtual_netmask)
|
|
pub virtual_netmask: u32,
|
|
// @@protoc_insertion_point(field:RegistrationResponse.epoch)
|
|
pub epoch: u32,
|
|
// @@protoc_insertion_point(field:RegistrationResponse.device_info_list)
|
|
pub device_info_list: ::std::vec::Vec<DeviceInfo>,
|
|
// @@protoc_insertion_point(field:RegistrationResponse.public_ip)
|
|
pub public_ip: u32,
|
|
// @@protoc_insertion_point(field:RegistrationResponse.public_port)
|
|
pub public_port: u32,
|
|
// special fields
|
|
// @@protoc_insertion_point(special_field:RegistrationResponse.special_fields)
|
|
pub special_fields: ::protobuf::SpecialFields,
|
|
}
|
|
|
|
impl<'a> ::std::default::Default for &'a RegistrationResponse {
|
|
fn default() -> &'a RegistrationResponse {
|
|
<RegistrationResponse as ::protobuf::Message>::default_instance()
|
|
}
|
|
}
|
|
|
|
impl RegistrationResponse {
|
|
pub fn new() -> RegistrationResponse {
|
|
::std::default::Default::default()
|
|
}
|
|
|
|
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
|
|
let mut fields = ::std::vec::Vec::with_capacity(7);
|
|
let mut oneofs = ::std::vec::Vec::with_capacity(0);
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"virtual_ip",
|
|
|m: &RegistrationResponse| { &m.virtual_ip },
|
|
|m: &mut RegistrationResponse| { &mut m.virtual_ip },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"virtual_gateway",
|
|
|m: &RegistrationResponse| { &m.virtual_gateway },
|
|
|m: &mut RegistrationResponse| { &mut m.virtual_gateway },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"virtual_netmask",
|
|
|m: &RegistrationResponse| { &m.virtual_netmask },
|
|
|m: &mut RegistrationResponse| { &mut m.virtual_netmask },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"epoch",
|
|
|m: &RegistrationResponse| { &m.epoch },
|
|
|m: &mut RegistrationResponse| { &mut m.epoch },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
|
|
"device_info_list",
|
|
|m: &RegistrationResponse| { &m.device_info_list },
|
|
|m: &mut RegistrationResponse| { &mut m.device_info_list },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"public_ip",
|
|
|m: &RegistrationResponse| { &m.public_ip },
|
|
|m: &mut RegistrationResponse| { &mut m.public_ip },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"public_port",
|
|
|m: &RegistrationResponse| { &m.public_port },
|
|
|m: &mut RegistrationResponse| { &mut m.public_port },
|
|
));
|
|
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RegistrationResponse>(
|
|
"RegistrationResponse",
|
|
fields,
|
|
oneofs,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::Message for RegistrationResponse {
|
|
const NAME: &'static str = "RegistrationResponse";
|
|
|
|
fn is_initialized(&self) -> bool {
|
|
true
|
|
}
|
|
|
|
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
|
|
while let Some(tag) = is.read_raw_tag_or_eof()? {
|
|
match tag {
|
|
13 => {
|
|
self.virtual_ip = is.read_fixed32()?;
|
|
},
|
|
21 => {
|
|
self.virtual_gateway = is.read_fixed32()?;
|
|
},
|
|
29 => {
|
|
self.virtual_netmask = is.read_fixed32()?;
|
|
},
|
|
32 => {
|
|
self.epoch = is.read_uint32()?;
|
|
},
|
|
42 => {
|
|
self.device_info_list.push(is.read_message()?);
|
|
},
|
|
53 => {
|
|
self.public_ip = is.read_fixed32()?;
|
|
},
|
|
56 => {
|
|
self.public_port = is.read_uint32()?;
|
|
},
|
|
tag => {
|
|
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
|
|
},
|
|
};
|
|
}
|
|
::std::result::Result::Ok(())
|
|
}
|
|
|
|
// Compute sizes of nested messages
|
|
#[allow(unused_variables)]
|
|
fn compute_size(&self) -> u64 {
|
|
let mut my_size = 0;
|
|
if self.virtual_ip != 0 {
|
|
my_size += 1 + 4;
|
|
}
|
|
if self.virtual_gateway != 0 {
|
|
my_size += 1 + 4;
|
|
}
|
|
if self.virtual_netmask != 0 {
|
|
my_size += 1 + 4;
|
|
}
|
|
if self.epoch != 0 {
|
|
my_size += ::protobuf::rt::uint32_size(4, self.epoch);
|
|
}
|
|
for value in &self.device_info_list {
|
|
let len = value.compute_size();
|
|
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
|
|
};
|
|
if self.public_ip != 0 {
|
|
my_size += 1 + 4;
|
|
}
|
|
if self.public_port != 0 {
|
|
my_size += ::protobuf::rt::uint32_size(7, self.public_port);
|
|
}
|
|
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
|
|
self.special_fields.cached_size().set(my_size as u32);
|
|
my_size
|
|
}
|
|
|
|
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
|
|
if self.virtual_ip != 0 {
|
|
os.write_fixed32(1, self.virtual_ip)?;
|
|
}
|
|
if self.virtual_gateway != 0 {
|
|
os.write_fixed32(2, self.virtual_gateway)?;
|
|
}
|
|
if self.virtual_netmask != 0 {
|
|
os.write_fixed32(3, self.virtual_netmask)?;
|
|
}
|
|
if self.epoch != 0 {
|
|
os.write_uint32(4, self.epoch)?;
|
|
}
|
|
for v in &self.device_info_list {
|
|
::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
|
|
};
|
|
if self.public_ip != 0 {
|
|
os.write_fixed32(6, self.public_ip)?;
|
|
}
|
|
if self.public_port != 0 {
|
|
os.write_uint32(7, self.public_port)?;
|
|
}
|
|
os.write_unknown_fields(self.special_fields.unknown_fields())?;
|
|
::std::result::Result::Ok(())
|
|
}
|
|
|
|
fn special_fields(&self) -> &::protobuf::SpecialFields {
|
|
&self.special_fields
|
|
}
|
|
|
|
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
|
|
&mut self.special_fields
|
|
}
|
|
|
|
fn new() -> RegistrationResponse {
|
|
RegistrationResponse::new()
|
|
}
|
|
|
|
fn clear(&mut self) {
|
|
self.virtual_ip = 0;
|
|
self.virtual_gateway = 0;
|
|
self.virtual_netmask = 0;
|
|
self.epoch = 0;
|
|
self.device_info_list.clear();
|
|
self.public_ip = 0;
|
|
self.public_port = 0;
|
|
self.special_fields.clear();
|
|
}
|
|
|
|
fn default_instance() -> &'static RegistrationResponse {
|
|
static instance: RegistrationResponse = RegistrationResponse {
|
|
virtual_ip: 0,
|
|
virtual_gateway: 0,
|
|
virtual_netmask: 0,
|
|
epoch: 0,
|
|
device_info_list: ::std::vec::Vec::new(),
|
|
public_ip: 0,
|
|
public_port: 0,
|
|
special_fields: ::protobuf::SpecialFields::new(),
|
|
};
|
|
&instance
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::MessageFull for RegistrationResponse {
|
|
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
|
|
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
|
|
descriptor.get(|| file_descriptor().message_by_package_relative_name("RegistrationResponse").unwrap()).clone()
|
|
}
|
|
}
|
|
|
|
impl ::std::fmt::Display for RegistrationResponse {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
|
|
::protobuf::text_format::fmt(self, f)
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::reflect::ProtobufValue for RegistrationResponse {
|
|
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
|
|
}
|
|
|
|
#[derive(PartialEq,Clone,Default,Debug)]
|
|
// @@protoc_insertion_point(message:DeviceInfo)
|
|
pub struct DeviceInfo {
|
|
// message fields
|
|
// @@protoc_insertion_point(field:DeviceInfo.name)
|
|
pub name: ::std::string::String,
|
|
// @@protoc_insertion_point(field:DeviceInfo.virtual_ip)
|
|
pub virtual_ip: u32,
|
|
// @@protoc_insertion_point(field:DeviceInfo.device_status)
|
|
pub device_status: u32,
|
|
// special fields
|
|
// @@protoc_insertion_point(special_field:DeviceInfo.special_fields)
|
|
pub special_fields: ::protobuf::SpecialFields,
|
|
}
|
|
|
|
impl<'a> ::std::default::Default for &'a DeviceInfo {
|
|
fn default() -> &'a DeviceInfo {
|
|
<DeviceInfo as ::protobuf::Message>::default_instance()
|
|
}
|
|
}
|
|
|
|
impl DeviceInfo {
|
|
pub fn new() -> DeviceInfo {
|
|
::std::default::Default::default()
|
|
}
|
|
|
|
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
|
|
let mut fields = ::std::vec::Vec::with_capacity(3);
|
|
let mut oneofs = ::std::vec::Vec::with_capacity(0);
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"name",
|
|
|m: &DeviceInfo| { &m.name },
|
|
|m: &mut DeviceInfo| { &mut m.name },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"virtual_ip",
|
|
|m: &DeviceInfo| { &m.virtual_ip },
|
|
|m: &mut DeviceInfo| { &mut m.virtual_ip },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"device_status",
|
|
|m: &DeviceInfo| { &m.device_status },
|
|
|m: &mut DeviceInfo| { &mut m.device_status },
|
|
));
|
|
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeviceInfo>(
|
|
"DeviceInfo",
|
|
fields,
|
|
oneofs,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::Message for DeviceInfo {
|
|
const NAME: &'static str = "DeviceInfo";
|
|
|
|
fn is_initialized(&self) -> bool {
|
|
true
|
|
}
|
|
|
|
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
|
|
while let Some(tag) = is.read_raw_tag_or_eof()? {
|
|
match tag {
|
|
10 => {
|
|
self.name = is.read_string()?;
|
|
},
|
|
21 => {
|
|
self.virtual_ip = is.read_fixed32()?;
|
|
},
|
|
24 => {
|
|
self.device_status = is.read_uint32()?;
|
|
},
|
|
tag => {
|
|
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
|
|
},
|
|
};
|
|
}
|
|
::std::result::Result::Ok(())
|
|
}
|
|
|
|
// Compute sizes of nested messages
|
|
#[allow(unused_variables)]
|
|
fn compute_size(&self) -> u64 {
|
|
let mut my_size = 0;
|
|
if !self.name.is_empty() {
|
|
my_size += ::protobuf::rt::string_size(1, &self.name);
|
|
}
|
|
if self.virtual_ip != 0 {
|
|
my_size += 1 + 4;
|
|
}
|
|
if self.device_status != 0 {
|
|
my_size += ::protobuf::rt::uint32_size(3, self.device_status);
|
|
}
|
|
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
|
|
self.special_fields.cached_size().set(my_size as u32);
|
|
my_size
|
|
}
|
|
|
|
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
|
|
if !self.name.is_empty() {
|
|
os.write_string(1, &self.name)?;
|
|
}
|
|
if self.virtual_ip != 0 {
|
|
os.write_fixed32(2, self.virtual_ip)?;
|
|
}
|
|
if self.device_status != 0 {
|
|
os.write_uint32(3, self.device_status)?;
|
|
}
|
|
os.write_unknown_fields(self.special_fields.unknown_fields())?;
|
|
::std::result::Result::Ok(())
|
|
}
|
|
|
|
fn special_fields(&self) -> &::protobuf::SpecialFields {
|
|
&self.special_fields
|
|
}
|
|
|
|
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
|
|
&mut self.special_fields
|
|
}
|
|
|
|
fn new() -> DeviceInfo {
|
|
DeviceInfo::new()
|
|
}
|
|
|
|
fn clear(&mut self) {
|
|
self.name.clear();
|
|
self.virtual_ip = 0;
|
|
self.device_status = 0;
|
|
self.special_fields.clear();
|
|
}
|
|
|
|
fn default_instance() -> &'static DeviceInfo {
|
|
static instance: DeviceInfo = DeviceInfo {
|
|
name: ::std::string::String::new(),
|
|
virtual_ip: 0,
|
|
device_status: 0,
|
|
special_fields: ::protobuf::SpecialFields::new(),
|
|
};
|
|
&instance
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::MessageFull for DeviceInfo {
|
|
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
|
|
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
|
|
descriptor.get(|| file_descriptor().message_by_package_relative_name("DeviceInfo").unwrap()).clone()
|
|
}
|
|
}
|
|
|
|
impl ::std::fmt::Display for DeviceInfo {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
|
|
::protobuf::text_format::fmt(self, f)
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::reflect::ProtobufValue for DeviceInfo {
|
|
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
|
|
}
|
|
|
|
#[derive(PartialEq,Clone,Default,Debug)]
|
|
// @@protoc_insertion_point(message:DeviceList)
|
|
pub struct DeviceList {
|
|
// message fields
|
|
// @@protoc_insertion_point(field:DeviceList.epoch)
|
|
pub epoch: u32,
|
|
// @@protoc_insertion_point(field:DeviceList.device_info_list)
|
|
pub device_info_list: ::std::vec::Vec<DeviceInfo>,
|
|
// special fields
|
|
// @@protoc_insertion_point(special_field:DeviceList.special_fields)
|
|
pub special_fields: ::protobuf::SpecialFields,
|
|
}
|
|
|
|
impl<'a> ::std::default::Default for &'a DeviceList {
|
|
fn default() -> &'a DeviceList {
|
|
<DeviceList as ::protobuf::Message>::default_instance()
|
|
}
|
|
}
|
|
|
|
impl DeviceList {
|
|
pub fn new() -> DeviceList {
|
|
::std::default::Default::default()
|
|
}
|
|
|
|
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
|
|
let mut fields = ::std::vec::Vec::with_capacity(2);
|
|
let mut oneofs = ::std::vec::Vec::with_capacity(0);
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"epoch",
|
|
|m: &DeviceList| { &m.epoch },
|
|
|m: &mut DeviceList| { &mut m.epoch },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
|
|
"device_info_list",
|
|
|m: &DeviceList| { &m.device_info_list },
|
|
|m: &mut DeviceList| { &mut m.device_info_list },
|
|
));
|
|
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeviceList>(
|
|
"DeviceList",
|
|
fields,
|
|
oneofs,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::Message for DeviceList {
|
|
const NAME: &'static str = "DeviceList";
|
|
|
|
fn is_initialized(&self) -> bool {
|
|
true
|
|
}
|
|
|
|
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
|
|
while let Some(tag) = is.read_raw_tag_or_eof()? {
|
|
match tag {
|
|
8 => {
|
|
self.epoch = is.read_uint32()?;
|
|
},
|
|
18 => {
|
|
self.device_info_list.push(is.read_message()?);
|
|
},
|
|
tag => {
|
|
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
|
|
},
|
|
};
|
|
}
|
|
::std::result::Result::Ok(())
|
|
}
|
|
|
|
// Compute sizes of nested messages
|
|
#[allow(unused_variables)]
|
|
fn compute_size(&self) -> u64 {
|
|
let mut my_size = 0;
|
|
if self.epoch != 0 {
|
|
my_size += ::protobuf::rt::uint32_size(1, self.epoch);
|
|
}
|
|
for value in &self.device_info_list {
|
|
let len = value.compute_size();
|
|
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
|
|
};
|
|
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
|
|
self.special_fields.cached_size().set(my_size as u32);
|
|
my_size
|
|
}
|
|
|
|
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
|
|
if self.epoch != 0 {
|
|
os.write_uint32(1, self.epoch)?;
|
|
}
|
|
for v in &self.device_info_list {
|
|
::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
|
|
};
|
|
os.write_unknown_fields(self.special_fields.unknown_fields())?;
|
|
::std::result::Result::Ok(())
|
|
}
|
|
|
|
fn special_fields(&self) -> &::protobuf::SpecialFields {
|
|
&self.special_fields
|
|
}
|
|
|
|
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
|
|
&mut self.special_fields
|
|
}
|
|
|
|
fn new() -> DeviceList {
|
|
DeviceList::new()
|
|
}
|
|
|
|
fn clear(&mut self) {
|
|
self.epoch = 0;
|
|
self.device_info_list.clear();
|
|
self.special_fields.clear();
|
|
}
|
|
|
|
fn default_instance() -> &'static DeviceList {
|
|
static instance: DeviceList = DeviceList {
|
|
epoch: 0,
|
|
device_info_list: ::std::vec::Vec::new(),
|
|
special_fields: ::protobuf::SpecialFields::new(),
|
|
};
|
|
&instance
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::MessageFull for DeviceList {
|
|
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
|
|
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
|
|
descriptor.get(|| file_descriptor().message_by_package_relative_name("DeviceList").unwrap()).clone()
|
|
}
|
|
}
|
|
|
|
impl ::std::fmt::Display for DeviceList {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
|
|
::protobuf::text_format::fmt(self, f)
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::reflect::ProtobufValue for DeviceList {
|
|
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
|
|
}
|
|
|
|
#[derive(PartialEq,Clone,Default,Debug)]
|
|
// @@protoc_insertion_point(message:Punch)
|
|
pub struct Punch {
|
|
// message fields
|
|
// @@protoc_insertion_point(field:Punch.virtual_ip)
|
|
pub virtual_ip: u32,
|
|
// @@protoc_insertion_point(field:Punch.public_ip_list)
|
|
pub public_ip_list: ::std::vec::Vec<u32>,
|
|
// @@protoc_insertion_point(field:Punch.public_port)
|
|
pub public_port: u32,
|
|
// @@protoc_insertion_point(field:Punch.public_port_range)
|
|
pub public_port_range: u32,
|
|
// @@protoc_insertion_point(field:Punch.nat_type)
|
|
pub nat_type: ::protobuf::EnumOrUnknown<NatType>,
|
|
// @@protoc_insertion_point(field:Punch.reply)
|
|
pub reply: bool,
|
|
// @@protoc_insertion_point(field:Punch.step)
|
|
pub step: ::protobuf::EnumOrUnknown<Step>,
|
|
// special fields
|
|
// @@protoc_insertion_point(special_field:Punch.special_fields)
|
|
pub special_fields: ::protobuf::SpecialFields,
|
|
}
|
|
|
|
impl<'a> ::std::default::Default for &'a Punch {
|
|
fn default() -> &'a Punch {
|
|
<Punch as ::protobuf::Message>::default_instance()
|
|
}
|
|
}
|
|
|
|
impl Punch {
|
|
pub fn new() -> Punch {
|
|
::std::default::Default::default()
|
|
}
|
|
|
|
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
|
|
let mut fields = ::std::vec::Vec::with_capacity(7);
|
|
let mut oneofs = ::std::vec::Vec::with_capacity(0);
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"virtual_ip",
|
|
|m: &Punch| { &m.virtual_ip },
|
|
|m: &mut Punch| { &mut m.virtual_ip },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
|
|
"public_ip_list",
|
|
|m: &Punch| { &m.public_ip_list },
|
|
|m: &mut Punch| { &mut m.public_ip_list },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"public_port",
|
|
|m: &Punch| { &m.public_port },
|
|
|m: &mut Punch| { &mut m.public_port },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"public_port_range",
|
|
|m: &Punch| { &m.public_port_range },
|
|
|m: &mut Punch| { &mut m.public_port_range },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"nat_type",
|
|
|m: &Punch| { &m.nat_type },
|
|
|m: &mut Punch| { &mut m.nat_type },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"reply",
|
|
|m: &Punch| { &m.reply },
|
|
|m: &mut Punch| { &mut m.reply },
|
|
));
|
|
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
|
|
"step",
|
|
|m: &Punch| { &m.step },
|
|
|m: &mut Punch| { &mut m.step },
|
|
));
|
|
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Punch>(
|
|
"Punch",
|
|
fields,
|
|
oneofs,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::Message for Punch {
|
|
const NAME: &'static str = "Punch";
|
|
|
|
fn is_initialized(&self) -> bool {
|
|
true
|
|
}
|
|
|
|
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
|
|
while let Some(tag) = is.read_raw_tag_or_eof()? {
|
|
match tag {
|
|
13 => {
|
|
self.virtual_ip = is.read_fixed32()?;
|
|
},
|
|
18 => {
|
|
is.read_repeated_packed_fixed32_into(&mut self.public_ip_list)?;
|
|
},
|
|
21 => {
|
|
self.public_ip_list.push(is.read_fixed32()?);
|
|
},
|
|
24 => {
|
|
self.public_port = is.read_uint32()?;
|
|
},
|
|
32 => {
|
|
self.public_port_range = is.read_uint32()?;
|
|
},
|
|
40 => {
|
|
self.nat_type = is.read_enum_or_unknown()?;
|
|
},
|
|
48 => {
|
|
self.reply = is.read_bool()?;
|
|
},
|
|
56 => {
|
|
self.step = is.read_enum_or_unknown()?;
|
|
},
|
|
tag => {
|
|
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
|
|
},
|
|
};
|
|
}
|
|
::std::result::Result::Ok(())
|
|
}
|
|
|
|
// Compute sizes of nested messages
|
|
#[allow(unused_variables)]
|
|
fn compute_size(&self) -> u64 {
|
|
let mut my_size = 0;
|
|
if self.virtual_ip != 0 {
|
|
my_size += 1 + 4;
|
|
}
|
|
my_size += 5 * self.public_ip_list.len() as u64;
|
|
if self.public_port != 0 {
|
|
my_size += ::protobuf::rt::uint32_size(3, self.public_port);
|
|
}
|
|
if self.public_port_range != 0 {
|
|
my_size += ::protobuf::rt::uint32_size(4, self.public_port_range);
|
|
}
|
|
if self.nat_type != ::protobuf::EnumOrUnknown::new(NatType::Symmetric) {
|
|
my_size += ::protobuf::rt::int32_size(5, self.nat_type.value());
|
|
}
|
|
if self.reply != false {
|
|
my_size += 1 + 1;
|
|
}
|
|
if self.step != ::protobuf::EnumOrUnknown::new(Step::Step1) {
|
|
my_size += ::protobuf::rt::int32_size(7, self.step.value());
|
|
}
|
|
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
|
|
self.special_fields.cached_size().set(my_size as u32);
|
|
my_size
|
|
}
|
|
|
|
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
|
|
if self.virtual_ip != 0 {
|
|
os.write_fixed32(1, self.virtual_ip)?;
|
|
}
|
|
for v in &self.public_ip_list {
|
|
os.write_fixed32(2, *v)?;
|
|
};
|
|
if self.public_port != 0 {
|
|
os.write_uint32(3, self.public_port)?;
|
|
}
|
|
if self.public_port_range != 0 {
|
|
os.write_uint32(4, self.public_port_range)?;
|
|
}
|
|
if self.nat_type != ::protobuf::EnumOrUnknown::new(NatType::Symmetric) {
|
|
os.write_enum(5, ::protobuf::EnumOrUnknown::value(&self.nat_type))?;
|
|
}
|
|
if self.reply != false {
|
|
os.write_bool(6, self.reply)?;
|
|
}
|
|
if self.step != ::protobuf::EnumOrUnknown::new(Step::Step1) {
|
|
os.write_enum(7, ::protobuf::EnumOrUnknown::value(&self.step))?;
|
|
}
|
|
os.write_unknown_fields(self.special_fields.unknown_fields())?;
|
|
::std::result::Result::Ok(())
|
|
}
|
|
|
|
fn special_fields(&self) -> &::protobuf::SpecialFields {
|
|
&self.special_fields
|
|
}
|
|
|
|
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
|
|
&mut self.special_fields
|
|
}
|
|
|
|
fn new() -> Punch {
|
|
Punch::new()
|
|
}
|
|
|
|
fn clear(&mut self) {
|
|
self.virtual_ip = 0;
|
|
self.public_ip_list.clear();
|
|
self.public_port = 0;
|
|
self.public_port_range = 0;
|
|
self.nat_type = ::protobuf::EnumOrUnknown::new(NatType::Symmetric);
|
|
self.reply = false;
|
|
self.step = ::protobuf::EnumOrUnknown::new(Step::Step1);
|
|
self.special_fields.clear();
|
|
}
|
|
|
|
fn default_instance() -> &'static Punch {
|
|
static instance: Punch = Punch {
|
|
virtual_ip: 0,
|
|
public_ip_list: ::std::vec::Vec::new(),
|
|
public_port: 0,
|
|
public_port_range: 0,
|
|
nat_type: ::protobuf::EnumOrUnknown::from_i32(0),
|
|
reply: false,
|
|
step: ::protobuf::EnumOrUnknown::from_i32(0),
|
|
special_fields: ::protobuf::SpecialFields::new(),
|
|
};
|
|
&instance
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::MessageFull for Punch {
|
|
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
|
|
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
|
|
descriptor.get(|| file_descriptor().message_by_package_relative_name("Punch").unwrap()).clone()
|
|
}
|
|
}
|
|
|
|
impl ::std::fmt::Display for Punch {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
|
|
::protobuf::text_format::fmt(self, f)
|
|
}
|
|
}
|
|
|
|
impl ::protobuf::reflect::ProtobufValue for Punch {
|
|
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
|
|
}
|
|
|
|
#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
|
|
// @@protoc_insertion_point(enum:NatType)
|
|
pub enum NatType {
|
|
// @@protoc_insertion_point(enum_value:NatType.Symmetric)
|
|
Symmetric = 0,
|
|
// @@protoc_insertion_point(enum_value:NatType.Cone)
|
|
Cone = 1,
|
|
}
|
|
|
|
impl ::protobuf::Enum for NatType {
|
|
const NAME: &'static str = "NatType";
|
|
|
|
fn value(&self) -> i32 {
|
|
*self as i32
|
|
}
|
|
|
|
fn from_i32(value: i32) -> ::std::option::Option<NatType> {
|
|
match value {
|
|
0 => ::std::option::Option::Some(NatType::Symmetric),
|
|
1 => ::std::option::Option::Some(NatType::Cone),
|
|
_ => ::std::option::Option::None
|
|
}
|
|
}
|
|
|
|
const VALUES: &'static [NatType] = &[
|
|
NatType::Symmetric,
|
|
NatType::Cone,
|
|
];
|
|
}
|
|
|
|
impl ::protobuf::EnumFull for NatType {
|
|
fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
|
|
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
|
|
descriptor.get(|| file_descriptor().enum_by_package_relative_name("NatType").unwrap()).clone()
|
|
}
|
|
|
|
fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
|
|
let index = *self as usize;
|
|
Self::enum_descriptor().value_by_index(index)
|
|
}
|
|
}
|
|
|
|
impl ::std::default::Default for NatType {
|
|
fn default() -> Self {
|
|
NatType::Symmetric
|
|
}
|
|
}
|
|
|
|
impl NatType {
|
|
fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
|
|
::protobuf::reflect::GeneratedEnumDescriptorData::new::<NatType>("NatType")
|
|
}
|
|
}
|
|
|
|
#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
|
|
// @@protoc_insertion_point(enum:Step)
|
|
pub enum Step {
|
|
// @@protoc_insertion_point(enum_value:Step.Step1)
|
|
Step1 = 0,
|
|
// @@protoc_insertion_point(enum_value:Step.Step2)
|
|
Step2 = 1,
|
|
// @@protoc_insertion_point(enum_value:Step.Step3)
|
|
Step3 = 2,
|
|
// @@protoc_insertion_point(enum_value:Step.Step4)
|
|
Step4 = 3,
|
|
}
|
|
|
|
impl ::protobuf::Enum for Step {
|
|
const NAME: &'static str = "Step";
|
|
|
|
fn value(&self) -> i32 {
|
|
*self as i32
|
|
}
|
|
|
|
fn from_i32(value: i32) -> ::std::option::Option<Step> {
|
|
match value {
|
|
0 => ::std::option::Option::Some(Step::Step1),
|
|
1 => ::std::option::Option::Some(Step::Step2),
|
|
2 => ::std::option::Option::Some(Step::Step3),
|
|
3 => ::std::option::Option::Some(Step::Step4),
|
|
_ => ::std::option::Option::None
|
|
}
|
|
}
|
|
|
|
const VALUES: &'static [Step] = &[
|
|
Step::Step1,
|
|
Step::Step2,
|
|
Step::Step3,
|
|
Step::Step4,
|
|
];
|
|
}
|
|
|
|
impl ::protobuf::EnumFull for Step {
|
|
fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
|
|
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
|
|
descriptor.get(|| file_descriptor().enum_by_package_relative_name("Step").unwrap()).clone()
|
|
}
|
|
|
|
fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
|
|
let index = *self as usize;
|
|
Self::enum_descriptor().value_by_index(index)
|
|
}
|
|
}
|
|
|
|
impl ::std::default::Default for Step {
|
|
fn default() -> Self {
|
|
Step::Step1
|
|
}
|
|
}
|
|
|
|
impl Step {
|
|
fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
|
|
::protobuf::reflect::GeneratedEnumDescriptorData::new::<Step>("Step")
|
|
}
|
|
}
|
|
|
|
static file_descriptor_proto_data: &'static [u8] = b"\
|
|
\n\rmessage.proto\"y\n\x13RegistrationRequest\x12\x14\n\x05token\x18\x01\
|
|
\x20\x01(\tR\x05token\x12\x1f\n\x0bmac_address\x18\x02\x20\x01(\tR\nmacA\
|
|
ddress\x12\x12\n\x04name\x18\x03\x20\x01(\tR\x04name\x12\x17\n\x07is_fas\
|
|
t\x18\x04\x20\x01(\x08R\x06isFast\"\x92\x02\n\x14RegistrationResponse\
|
|
\x12\x1d\n\nvirtual_ip\x18\x01\x20\x01(\x07R\tvirtualIp\x12'\n\x0fvirtua\
|
|
l_gateway\x18\x02\x20\x01(\x07R\x0evirtualGateway\x12'\n\x0fvirtual_netm\
|
|
ask\x18\x03\x20\x01(\x07R\x0evirtualNetmask\x12\x14\n\x05epoch\x18\x04\
|
|
\x20\x01(\rR\x05epoch\x125\n\x10device_info_list\x18\x05\x20\x03(\x0b2\
|
|
\x0b.DeviceInfoR\x0edeviceInfoList\x12\x1b\n\tpublic_ip\x18\x06\x20\x01(\
|
|
\x07R\x08publicIp\x12\x1f\n\x0bpublic_port\x18\x07\x20\x01(\rR\npublicPo\
|
|
rt\"d\n\nDeviceInfo\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\
|
|
\x1d\n\nvirtual_ip\x18\x02\x20\x01(\x07R\tvirtualIp\x12#\n\rdevice_statu\
|
|
s\x18\x03\x20\x01(\rR\x0cdeviceStatus\"Y\n\nDeviceList\x12\x14\n\x05epoc\
|
|
h\x18\x01\x20\x01(\rR\x05epoch\x125\n\x10device_info_list\x18\x02\x20\
|
|
\x03(\x0b2\x0b.DeviceInfoR\x0edeviceInfoList\"\xef\x01\n\x05Punch\x12\
|
|
\x1d\n\nvirtual_ip\x18\x01\x20\x01(\x07R\tvirtualIp\x12$\n\x0epublic_ip_\
|
|
list\x18\x02\x20\x03(\x07R\x0cpublicIpList\x12\x1f\n\x0bpublic_port\x18\
|
|
\x03\x20\x01(\rR\npublicPort\x12*\n\x11public_port_range\x18\x04\x20\x01\
|
|
(\rR\x0fpublicPortRange\x12#\n\x08nat_type\x18\x05\x20\x01(\x0e2\x08.Nat\
|
|
TypeR\x07natType\x12\x14\n\x05reply\x18\x06\x20\x01(\x08R\x05reply\x12\
|
|
\x19\n\x04step\x18\x07\x20\x01(\x0e2\x05.StepR\x04step*\"\n\x07NatType\
|
|
\x12\r\n\tSymmetric\x10\0\x12\x08\n\x04Cone\x10\x01*2\n\x04Step\x12\t\n\
|
|
\x05Step1\x10\0\x12\t\n\x05Step2\x10\x01\x12\t\n\x05Step3\x10\x02\x12\t\
|
|
\n\x05Step4\x10\x03b\x06proto3\
|
|
";
|
|
|
|
/// `FileDescriptorProto` object which was a source for this generated file
|
|
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
|
|
static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
|
|
file_descriptor_proto_lazy.get(|| {
|
|
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
|
|
})
|
|
}
|
|
|
|
/// `FileDescriptor` object which allows dynamic access to files
|
|
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
|
|
static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
|
|
static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
|
|
file_descriptor.get(|| {
|
|
let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
|
|
let mut deps = ::std::vec::Vec::with_capacity(0);
|
|
let mut messages = ::std::vec::Vec::with_capacity(5);
|
|
messages.push(RegistrationRequest::generated_message_descriptor_data());
|
|
messages.push(RegistrationResponse::generated_message_descriptor_data());
|
|
messages.push(DeviceInfo::generated_message_descriptor_data());
|
|
messages.push(DeviceList::generated_message_descriptor_data());
|
|
messages.push(Punch::generated_message_descriptor_data());
|
|
let mut enums = ::std::vec::Vec::with_capacity(2);
|
|
enums.push(NatType::generated_enum_descriptor_data());
|
|
enums.push(Step::generated_enum_descriptor_data());
|
|
::protobuf::reflect::GeneratedFileDescriptor::new_generated(
|
|
file_descriptor_proto(),
|
|
deps,
|
|
messages,
|
|
enums,
|
|
)
|
|
});
|
|
::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
|
|
})
|
|
}
|