#![allow(unknown_lints)]
#![allow(clippy::all)]
#![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(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_8_0;
#[derive(PartialEq,Clone,Default)]
pub struct Int32 {
pub value: i32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Int32 {
fn default() -> &'a Int32 {
<Int32 as ::protobuf::Message>::default_instance()
}
}
impl Int32 {
pub fn new() -> Int32 {
::std::default::Default::default()
}
pub fn get_value(&self) -> i32 {
self.value
}
pub fn clear_value(&mut self) {
self.value = 0;
}
pub fn set_value(&mut self, v: i32) {
self.value = v;
}
}
impl ::protobuf::Message for Int32 {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_int32()?;
self.value = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.value != 0 {
my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.value != 0 {
os.write_int32(1, self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Int32 {
Int32::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"value",
|m: &Int32| { &m.value },
|m: &mut Int32| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<Int32>(
"Int32",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Int32 {
static mut instance: ::protobuf::lazy::Lazy<Int32> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Int32,
};
unsafe {
instance.get(Int32::new)
}
}
}
impl ::protobuf::Clear for Int32 {
fn clear(&mut self) {
self.value = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Int32 {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Int32 {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Int64 {
pub value: i64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Int64 {
fn default() -> &'a Int64 {
<Int64 as ::protobuf::Message>::default_instance()
}
}
impl Int64 {
pub fn new() -> Int64 {
::std::default::Default::default()
}
pub fn get_value(&self) -> i64 {
self.value
}
pub fn clear_value(&mut self) {
self.value = 0;
}
pub fn set_value(&mut self, v: i64) {
self.value = v;
}
}
impl ::protobuf::Message for Int64 {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_int64()?;
self.value = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.value != 0 {
my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.value != 0 {
os.write_int64(1, self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Int64 {
Int64::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
"value",
|m: &Int64| { &m.value },
|m: &mut Int64| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<Int64>(
"Int64",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Int64 {
static mut instance: ::protobuf::lazy::Lazy<Int64> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Int64,
};
unsafe {
instance.get(Int64::new)
}
}
}
impl ::protobuf::Clear for Int64 {
fn clear(&mut self) {
self.value = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Int64 {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Int64 {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct UInt32 {
pub value: u32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a UInt32 {
fn default() -> &'a UInt32 {
<UInt32 as ::protobuf::Message>::default_instance()
}
}
impl UInt32 {
pub fn new() -> UInt32 {
::std::default::Default::default()
}
pub fn get_value(&self) -> u32 {
self.value
}
pub fn clear_value(&mut self) {
self.value = 0;
}
pub fn set_value(&mut self, v: u32) {
self.value = v;
}
}
impl ::protobuf::Message for UInt32 {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.value = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.value != 0 {
my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.value != 0 {
os.write_uint32(1, self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> UInt32 {
UInt32::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"value",
|m: &UInt32| { &m.value },
|m: &mut UInt32| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<UInt32>(
"UInt32",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static UInt32 {
static mut instance: ::protobuf::lazy::Lazy<UInt32> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const UInt32,
};
unsafe {
instance.get(UInt32::new)
}
}
}
impl ::protobuf::Clear for UInt32 {
fn clear(&mut self) {
self.value = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for UInt32 {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for UInt32 {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct UInt64 {
pub value: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a UInt64 {
fn default() -> &'a UInt64 {
<UInt64 as ::protobuf::Message>::default_instance()
}
}
impl UInt64 {
pub fn new() -> UInt64 {
::std::default::Default::default()
}
pub fn get_value(&self) -> u64 {
self.value
}
pub fn clear_value(&mut self) {
self.value = 0;
}
pub fn set_value(&mut self, v: u64) {
self.value = v;
}
}
impl ::protobuf::Message for UInt64 {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.value = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.value != 0 {
my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.value != 0 {
os.write_uint64(1, self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> UInt64 {
UInt64::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"value",
|m: &UInt64| { &m.value },
|m: &mut UInt64| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<UInt64>(
"UInt64",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static UInt64 {
static mut instance: ::protobuf::lazy::Lazy<UInt64> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const UInt64,
};
unsafe {
instance.get(UInt64::new)
}
}
}
impl ::protobuf::Clear for UInt64 {
fn clear(&mut self) {
self.value = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for UInt64 {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for UInt64 {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SInt32 {
pub value: i32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SInt32 {
fn default() -> &'a SInt32 {
<SInt32 as ::protobuf::Message>::default_instance()
}
}
impl SInt32 {
pub fn new() -> SInt32 {
::std::default::Default::default()
}
pub fn get_value(&self) -> i32 {
self.value
}
pub fn clear_value(&mut self) {
self.value = 0;
}
pub fn set_value(&mut self, v: i32) {
self.value = v;
}
}
impl ::protobuf::Message for SInt32 {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_sint32()?;
self.value = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.value != 0 {
my_size += ::protobuf::rt::value_varint_zigzag_size(1, self.value);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.value != 0 {
os.write_sint32(1, self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> SInt32 {
SInt32::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeSint32>(
"value",
|m: &SInt32| { &m.value },
|m: &mut SInt32| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<SInt32>(
"SInt32",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static SInt32 {
static mut instance: ::protobuf::lazy::Lazy<SInt32> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const SInt32,
};
unsafe {
instance.get(SInt32::new)
}
}
}
impl ::protobuf::Clear for SInt32 {
fn clear(&mut self) {
self.value = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SInt32 {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SInt32 {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SInt64 {
pub value: i64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SInt64 {
fn default() -> &'a SInt64 {
<SInt64 as ::protobuf::Message>::default_instance()
}
}
impl SInt64 {
pub fn new() -> SInt64 {
::std::default::Default::default()
}
pub fn get_value(&self) -> i64 {
self.value
}
pub fn clear_value(&mut self) {
self.value = 0;
}
pub fn set_value(&mut self, v: i64) {
self.value = v;
}
}
impl ::protobuf::Message for SInt64 {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_sint64()?;
self.value = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.value != 0 {
my_size += ::protobuf::rt::value_varint_zigzag_size(1, self.value);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.value != 0 {
os.write_sint64(1, self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> SInt64 {
SInt64::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeSint64>(
"value",
|m: &SInt64| { &m.value },
|m: &mut SInt64| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<SInt64>(
"SInt64",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static SInt64 {
static mut instance: ::protobuf::lazy::Lazy<SInt64> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const SInt64,
};
unsafe {
instance.get(SInt64::new)
}
}
}
impl ::protobuf::Clear for SInt64 {
fn clear(&mut self) {
self.value = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SInt64 {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SInt64 {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Fixed32 {
pub value: u32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Fixed32 {
fn default() -> &'a Fixed32 {
<Fixed32 as ::protobuf::Message>::default_instance()
}
}
impl Fixed32 {
pub fn new() -> Fixed32 {
::std::default::Default::default()
}
pub fn get_value(&self) -> u32 {
self.value
}
pub fn clear_value(&mut self) {
self.value = 0;
}
pub fn set_value(&mut self, v: u32) {
self.value = v;
}
}
impl ::protobuf::Message for Fixed32 {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed32()?;
self.value = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.value != 0 {
my_size += 5;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.value != 0 {
os.write_fixed32(1, self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Fixed32 {
Fixed32::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed32>(
"value",
|m: &Fixed32| { &m.value },
|m: &mut Fixed32| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<Fixed32>(
"Fixed32",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Fixed32 {
static mut instance: ::protobuf::lazy::Lazy<Fixed32> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Fixed32,
};
unsafe {
instance.get(Fixed32::new)
}
}
}
impl ::protobuf::Clear for Fixed32 {
fn clear(&mut self) {
self.value = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Fixed32 {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Fixed32 {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Fixed64 {
pub value: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Fixed64 {
fn default() -> &'a Fixed64 {
<Fixed64 as ::protobuf::Message>::default_instance()
}
}
impl Fixed64 {
pub fn new() -> Fixed64 {
::std::default::Default::default()
}
pub fn get_value(&self) -> u64 {
self.value
}
pub fn clear_value(&mut self) {
self.value = 0;
}
pub fn set_value(&mut self, v: u64) {
self.value = v;
}
}
impl ::protobuf::Message for Fixed64 {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_fixed64()?;
self.value = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.value != 0 {
my_size += 9;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.value != 0 {
os.write_fixed64(1, self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Fixed64 {
Fixed64::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFixed64>(
"value",
|m: &Fixed64| { &m.value },
|m: &mut Fixed64| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<Fixed64>(
"Fixed64",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Fixed64 {
static mut instance: ::protobuf::lazy::Lazy<Fixed64> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Fixed64,
};
unsafe {
instance.get(Fixed64::new)
}
}
}
impl ::protobuf::Clear for Fixed64 {
fn clear(&mut self) {
self.value = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Fixed64 {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Fixed64 {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Boolean {
pub value: bool,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Boolean {
fn default() -> &'a Boolean {
<Boolean as ::protobuf::Message>::default_instance()
}
}
impl Boolean {
pub fn new() -> Boolean {
::std::default::Default::default()
}
pub fn get_value(&self) -> bool {
self.value
}
pub fn clear_value(&mut self) {
self.value = false;
}
pub fn set_value(&mut self, v: bool) {
self.value = v;
}
}
impl ::protobuf::Message for Boolean {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_bool()?;
self.value = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.value != false {
my_size += 2;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if self.value != false {
os.write_bool(1, self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Boolean {
Boolean::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"value",
|m: &Boolean| { &m.value },
|m: &mut Boolean| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<Boolean>(
"Boolean",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Boolean {
static mut instance: ::protobuf::lazy::Lazy<Boolean> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Boolean,
};
unsafe {
instance.get(Boolean::new)
}
}
}
impl ::protobuf::Clear for Boolean {
fn clear(&mut self) {
self.value = false;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Boolean {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Boolean {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Strings {
pub value: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Strings {
fn default() -> &'a Strings {
<Strings as ::protobuf::Message>::default_instance()
}
}
impl Strings {
pub fn new() -> Strings {
::std::default::Default::default()
}
pub fn get_value(&self) -> &str {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::string::String) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::string::String {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.value, ::std::string::String::new())
}
}
impl ::protobuf::Message for Strings {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.value)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.value.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.value);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.value.is_empty() {
os.write_string(1, &self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Strings {
Strings::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"value",
|m: &Strings| { &m.value },
|m: &mut Strings| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<Strings>(
"Strings",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Strings {
static mut instance: ::protobuf::lazy::Lazy<Strings> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Strings,
};
unsafe {
instance.get(Strings::new)
}
}
}
impl ::protobuf::Clear for Strings {
fn clear(&mut self) {
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Strings {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Strings {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Bytes {
pub value: ::std::vec::Vec<u8>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Bytes {
fn default() -> &'a Bytes {
<Bytes as ::protobuf::Message>::default_instance()
}
}
impl Bytes {
pub fn new() -> Bytes {
::std::default::Default::default()
}
pub fn get_value(&self) -> &[u8] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.value
}
pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for Bytes {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.value.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.value);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if !self.value.is_empty() {
os.write_bytes(1, &self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Bytes {
Bytes::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"value",
|m: &Bytes| { &m.value },
|m: &mut Bytes| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<Bytes>(
"Bytes",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Bytes {
static mut instance: ::protobuf::lazy::Lazy<Bytes> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Bytes,
};
unsafe {
instance.get(Bytes::new)
}
}
}
impl ::protobuf::Clear for Bytes {
fn clear(&mut self) {
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Bytes {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Bytes {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Repeated {
pub value: ::protobuf::RepeatedField<Int32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Repeated {
fn default() -> &'a Repeated {
<Repeated as ::protobuf::Message>::default_instance()
}
}
impl Repeated {
pub fn new() -> Repeated {
::std::default::Default::default()
}
pub fn get_value(&self) -> &[Int32] {
&self.value
}
pub fn clear_value(&mut self) {
self.value.clear();
}
pub fn set_value(&mut self, v: ::protobuf::RepeatedField<Int32>) {
self.value = v;
}
pub fn mut_value(&mut self) -> &mut ::protobuf::RepeatedField<Int32> {
&mut self.value
}
pub fn take_value(&mut self) -> ::protobuf::RepeatedField<Int32> {
::std::mem::replace(&mut self.value, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for Repeated {
fn is_initialized(&self) -> bool {
for v in &self.value {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.value)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
for value in &self.value {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
for v in &self.value {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Repeated {
Repeated::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Int32>>(
"value",
|m: &Repeated| { &m.value },
|m: &mut Repeated| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new::<Repeated>(
"Repeated",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Repeated {
static mut instance: ::protobuf::lazy::Lazy<Repeated> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Repeated,
};
unsafe {
instance.get(Repeated::new)
}
}
}
impl ::protobuf::Clear for Repeated {
fn clear(&mut self) {
self.value.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Repeated {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Repeated {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Structs {
pub a: ::protobuf::SingularPtrField<Int32>,
pub b: ::protobuf::SingularPtrField<UInt32>,
pub c: ::protobuf::SingularPtrField<SInt32>,
pub d: ::protobuf::SingularPtrField<Fixed32>,
pub e: ::protobuf::SingularPtrField<Boolean>,
pub f: ::protobuf::SingularPtrField<Strings>,
pub g: ::protobuf::SingularPtrField<Bytes>,
pub h: ::protobuf::RepeatedField<Int32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Structs {
fn default() -> &'a Structs {
<Structs as ::protobuf::Message>::default_instance()
}
}
impl Structs {
pub fn new() -> Structs {
::std::default::Default::default()
}
pub fn get_a(&self) -> &Int32 {
self.a.as_ref().unwrap_or_else(|| Int32::default_instance())
}
pub fn clear_a(&mut self) {
self.a.clear();
}
pub fn has_a(&self) -> bool {
self.a.is_some()
}
pub fn set_a(&mut self, v: Int32) {
self.a = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_a(&mut self) -> &mut Int32 {
if self.a.is_none() {
self.a.set_default();
}
self.a.as_mut().unwrap()
}
pub fn take_a(&mut self) -> Int32 {
self.a.take().unwrap_or_else(|| Int32::new())
}
pub fn get_b(&self) -> &UInt32 {
self.b.as_ref().unwrap_or_else(|| UInt32::default_instance())
}
pub fn clear_b(&mut self) {
self.b.clear();
}
pub fn has_b(&self) -> bool {
self.b.is_some()
}
pub fn set_b(&mut self, v: UInt32) {
self.b = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_b(&mut self) -> &mut UInt32 {
if self.b.is_none() {
self.b.set_default();
}
self.b.as_mut().unwrap()
}
pub fn take_b(&mut self) -> UInt32 {
self.b.take().unwrap_or_else(|| UInt32::new())
}
pub fn get_c(&self) -> &SInt32 {
self.c.as_ref().unwrap_or_else(|| SInt32::default_instance())
}
pub fn clear_c(&mut self) {
self.c.clear();
}
pub fn has_c(&self) -> bool {
self.c.is_some()
}
pub fn set_c(&mut self, v: SInt32) {
self.c = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_c(&mut self) -> &mut SInt32 {
if self.c.is_none() {
self.c.set_default();
}
self.c.as_mut().unwrap()
}
pub fn take_c(&mut self) -> SInt32 {
self.c.take().unwrap_or_else(|| SInt32::new())
}
pub fn get_d(&self) -> &Fixed32 {
self.d.as_ref().unwrap_or_else(|| Fixed32::default_instance())
}
pub fn clear_d(&mut self) {
self.d.clear();
}
pub fn has_d(&self) -> bool {
self.d.is_some()
}
pub fn set_d(&mut self, v: Fixed32) {
self.d = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_d(&mut self) -> &mut Fixed32 {
if self.d.is_none() {
self.d.set_default();
}
self.d.as_mut().unwrap()
}
pub fn take_d(&mut self) -> Fixed32 {
self.d.take().unwrap_or_else(|| Fixed32::new())
}
pub fn get_e(&self) -> &Boolean {
self.e.as_ref().unwrap_or_else(|| Boolean::default_instance())
}
pub fn clear_e(&mut self) {
self.e.clear();
}
pub fn has_e(&self) -> bool {
self.e.is_some()
}
pub fn set_e(&mut self, v: Boolean) {
self.e = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_e(&mut self) -> &mut Boolean {
if self.e.is_none() {
self.e.set_default();
}
self.e.as_mut().unwrap()
}
pub fn take_e(&mut self) -> Boolean {
self.e.take().unwrap_or_else(|| Boolean::new())
}
pub fn get_f(&self) -> &Strings {
self.f.as_ref().unwrap_or_else(|| Strings::default_instance())
}
pub fn clear_f(&mut self) {
self.f.clear();
}
pub fn has_f(&self) -> bool {
self.f.is_some()
}
pub fn set_f(&mut self, v: Strings) {
self.f = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_f(&mut self) -> &mut Strings {
if self.f.is_none() {
self.f.set_default();
}
self.f.as_mut().unwrap()
}
pub fn take_f(&mut self) -> Strings {
self.f.take().unwrap_or_else(|| Strings::new())
}
pub fn get_g(&self) -> &Bytes {
self.g.as_ref().unwrap_or_else(|| Bytes::default_instance())
}
pub fn clear_g(&mut self) {
self.g.clear();
}
pub fn has_g(&self) -> bool {
self.g.is_some()
}
pub fn set_g(&mut self, v: Bytes) {
self.g = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_g(&mut self) -> &mut Bytes {
if self.g.is_none() {
self.g.set_default();
}
self.g.as_mut().unwrap()
}
pub fn take_g(&mut self) -> Bytes {
self.g.take().unwrap_or_else(|| Bytes::new())
}
pub fn get_h(&self) -> &[Int32] {
&self.h
}
pub fn clear_h(&mut self) {
self.h.clear();
}
pub fn set_h(&mut self, v: ::protobuf::RepeatedField<Int32>) {
self.h = v;
}
pub fn mut_h(&mut self) -> &mut ::protobuf::RepeatedField<Int32> {
&mut self.h
}
pub fn take_h(&mut self) -> ::protobuf::RepeatedField<Int32> {
::std::mem::replace(&mut self.h, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for Structs {
fn is_initialized(&self) -> bool {
for v in &self.a {
if !v.is_initialized() {
return false;
}
};
for v in &self.b {
if !v.is_initialized() {
return false;
}
};
for v in &self.c {
if !v.is_initialized() {
return false;
}
};
for v in &self.d {
if !v.is_initialized() {
return false;
}
};
for v in &self.e {
if !v.is_initialized() {
return false;
}
};
for v in &self.f {
if !v.is_initialized() {
return false;
}
};
for v in &self.g {
if !v.is_initialized() {
return false;
}
};
for v in &self.h {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.a)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.b)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.c)?;
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.d)?;
},
5 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.e)?;
},
6 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.f)?;
},
7 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.g)?;
},
8 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.h)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.a.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.b.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.c.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.d.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.e.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.f.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.g.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.h {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.a.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.b.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.c.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.d.as_ref() {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.e.as_ref() {
os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.f.as_ref() {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.g.as_ref() {
os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.h {
os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Structs {
Structs::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Int32>>(
"a",
|m: &Structs| { &m.a },
|m: &mut Structs| { &mut m.a },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UInt32>>(
"b",
|m: &Structs| { &m.b },
|m: &mut Structs| { &mut m.b },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SInt32>>(
"c",
|m: &Structs| { &m.c },
|m: &mut Structs| { &mut m.c },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Fixed32>>(
"d",
|m: &Structs| { &m.d },
|m: &mut Structs| { &mut m.d },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Boolean>>(
"e",
|m: &Structs| { &m.e },
|m: &mut Structs| { &mut m.e },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Strings>>(
"f",
|m: &Structs| { &m.f },
|m: &mut Structs| { &mut m.f },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Bytes>>(
"g",
|m: &Structs| { &m.g },
|m: &mut Structs| { &mut m.g },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Int32>>(
"h",
|m: &Structs| { &m.h },
|m: &mut Structs| { &mut m.h },
));
::protobuf::reflect::MessageDescriptor::new::<Structs>(
"Structs",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Structs {
static mut instance: ::protobuf::lazy::Lazy<Structs> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Structs,
};
unsafe {
instance.get(Structs::new)
}
}
}
impl ::protobuf::Clear for Structs {
fn clear(&mut self) {
self.a.clear();
self.b.clear();
self.c.clear();
self.d.clear();
self.e.clear();
self.f.clear();
self.g.clear();
self.h.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Structs {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Structs {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\ntest.proto\x12\x04test\"\x1d\n\x05Int32\x12\x14\n\x05value\x18\x01\
\x20\x01(\x05R\x05value\"\x1d\n\x05Int64\x12\x14\n\x05value\x18\x01\x20\
\x01(\x03R\x05value\"\x1e\n\x06UInt32\x12\x14\n\x05value\x18\x01\x20\x01\
(\rR\x05value\"\x1e\n\x06UInt64\x12\x14\n\x05value\x18\x01\x20\x01(\x04R\
\x05value\"\x1e\n\x06SInt32\x12\x14\n\x05value\x18\x01\x20\x01(\x11R\x05\
value\"\x1e\n\x06SInt64\x12\x14\n\x05value\x18\x01\x20\x01(\x12R\x05valu\
e\"\x1f\n\x07Fixed32\x12\x14\n\x05value\x18\x01\x20\x01(\x07R\x05value\"\
\x1f\n\x07Fixed64\x12\x14\n\x05value\x18\x01\x20\x01(\x06R\x05value\"\
\x1f\n\x07Boolean\x12\x14\n\x05value\x18\x01\x20\x01(\x08R\x05value\"\
\x1f\n\x07Strings\x12\x14\n\x05value\x18\x01\x20\x01(\tR\x05value\"\x1d\
\n\x05Bytes\x12\x14\n\x05value\x18\x01\x20\x01(\x0cR\x05value\"-\n\x08Re\
peated\x12!\n\x05value\x18\x01\x20\x03(\x0b2\x0b.test.Int32R\x05value\"\
\xe9\x01\n\x07Structs\x12\x19\n\x01a\x18\x01\x20\x01(\x0b2\x0b.test.Int3\
2R\x01a\x12\x1a\n\x01b\x18\x02\x20\x01(\x0b2\x0c.test.UInt32R\x01b\x12\
\x1a\n\x01c\x18\x03\x20\x01(\x0b2\x0c.test.SInt32R\x01c\x12\x1b\n\x01d\
\x18\x04\x20\x01(\x0b2\r.test.Fixed32R\x01d\x12\x1b\n\x01e\x18\x05\x20\
\x01(\x0b2\r.test.BooleanR\x01e\x12\x1b\n\x01f\x18\x06\x20\x01(\x0b2\r.t\
est.StringsR\x01f\x12\x19\n\x01g\x18\x07\x20\x01(\x0b2\x0b.test.BytesR\
\x01g\x12\x19\n\x01h\x18\x08\x20\x03(\x0b2\x0b.test.Int32R\x01hb\x06prot\
o3\
";
static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
};
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
unsafe {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}
}