From d5bf6f77fc124b0915e0cfbf8a693dc8238631c9 Mon Sep 17 00:00:00 2001 From: Russell Mull Date: Mon, 9 Sep 2019 09:15:04 -0700 Subject: [PATCH] Change rust_gen_arrayvec to (rust_max_length) --- pb-rs/src/parser.rs | 26 +- pb-rs/src/types.rs | 20 +- perftest/src/perftest_data.rs | 2267 ++--------------- .../no-std-example/src/no_std.proto | 4 +- .../rust_protobuf/v3/test_basic_pb.proto | 28 +- 5 files changed, 275 insertions(+), 2070 deletions(-) diff --git a/pb-rs/src/parser.rs b/pb-rs/src/parser.rs index c5825541..0fdbaddc 100644 --- a/pb-rs/src/parser.rs +++ b/pb-rs/src/parser.rs @@ -148,12 +148,18 @@ named!( ) ); +named!( + option_key<&str>, + alt_complete!(delimited!(tag!("("), word_ref, tag!(")")) + | word_ref) +); + named!( key_val<(&str, &str)>, do_parse!( tag!("[") >> many0!(br) - >> key: word_ref + >> key: option_key >> many0!(br) >> tag!("=") >> many0!(br) @@ -265,12 +271,12 @@ named!( .find(|&&(k, _)| k == "deprecated") .map_or(false, |&(_, v)| str::FromStr::from_str(v) .expect("Cannot parse Deprecated value")), - gen_arrayvec: key_vals + max_length: key_vals .iter() - .find(|&&(k, _)| k == "rust_gen_arrayvec") + .find(|&&(k, _)| k == "rust_max_length") .map(|&(_, v)| v .parse::() - .expect("Cannot parse rust_gen_arrayvec value")), + .expect("Cannot parse rust_max_length value")), }) ) ); @@ -673,4 +679,16 @@ mod test { } } + #[test] + fn test_option_key_plain() { + let s = option_key("test".as_bytes()).unwrap().1; + assert_eq!("test", s); + } + + #[test] + fn test_option_key_parens() { + let s = option_key("(test)".as_bytes()).unwrap().1; + assert_eq!("test", s); + } + } diff --git a/pb-rs/src/types.rs b/pb-rs/src/types.rs index ffc1fb17..ac5195bb 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -264,7 +264,7 @@ impl FieldType { fn has_lifetime( &self, desc: &FileDescriptor, - gen_arrayvec: bool, + max_length: bool, packed: bool, ignore: &mut Vec, ) -> bool { @@ -278,7 +278,7 @@ impl FieldType { | FieldType::Sfixed32 | FieldType::String_ | FieldType::Bytes_ - | FieldType::Float => !gen_arrayvec && packed, // Cow<[M]> + | FieldType::Float => !max_length && packed, // Cow<[M]> FieldType::Map(ref key, ref value) => { key.has_lifetime(desc, false, false, ignore) || value.has_lifetime(desc, false, false, ignore) @@ -434,12 +434,12 @@ pub struct Field { pub packed: Option, pub boxed: bool, pub deprecated: bool, - pub gen_arrayvec: Option, + pub max_length: Option, } impl Field { - fn gen_arrayvec(&self) -> bool { - self.gen_arrayvec.is_some() + fn max_length(&self) -> bool { + self.max_length.is_some() } fn packed(&self) -> bool { @@ -502,11 +502,11 @@ impl Field { { writeln!(w, "Option<{}>,", rust_type)? } - Frequency::Repeated if self.gen_arrayvec.is_some() => writeln!( + Frequency::Repeated if self.max_length.is_some() => writeln!( w, "arrayvec::ArrayVec<[{}; {}]>,", rust_type, - self.gen_arrayvec.unwrap() + self.max_length.unwrap() )?, Frequency::Repeated if self.packed() && self.typ.is_fixed_size() && !config.dont_use_cow => @@ -553,7 +553,7 @@ impl Field { Frequency::Required | Frequency::Optional => { writeln!(w, "msg.{} = {},", name, val_cow)? } - Frequency::Repeated if self.packed() && self.gen_arrayvec.is_some() => { + Frequency::Repeated if self.packed() && self.max_length.is_some() => { writeln!( w, "msg.{} = r.read_packed_arrayvec(bytes, |r, bytes| Ok({}))?,", @@ -822,7 +822,7 @@ impl Message { ignore.push(self.index.clone()); let res = self.all_fields().any(|f| { f.typ - .has_lifetime(desc, f.gen_arrayvec(), f.packed(), ignore) + .has_lifetime(desc, f.max_length(), f.packed(), ignore) }); ignore.pop(); res @@ -1458,7 +1458,7 @@ impl OneOf { self.fields.iter().any(|f| { !f.deprecated && f.typ - .has_lifetime(desc, f.gen_arrayvec(), f.packed(), &mut Vec::new()) + .has_lifetime(desc, f.max_length(), f.packed(), &mut Vec::new()) }) } diff --git a/perftest/src/perftest_data.rs b/perftest/src/perftest_data.rs index cebe0abf..1ea21071 100644 --- a/perftest/src/perftest_data.rs +++ b/perftest/src/perftest_data.rs @@ -1,2130 +1,317 @@ -// This file is generated by rust-protobuf 2.8.0. Do not edit -// @generated +// Automatically generated rust module for 'perftest_data.proto' file -// https://github.com/Manishearth/rust-clippy/issues/702 -#![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(non_camel_case_types)] #![allow(unused_imports)] -#![allow(unused_results)] -//! Generated file from `perftest_data.proto` +#![allow(unknown_lints)] +#![allow(clippy)] +#![cfg_attr(rustfmt, rustfmt_skip)] -use protobuf::Message as Message_imported_for_functions; -use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; -/// Generated files are compatible only with the same version -/// of protobuf runtime. -const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_8_0; +use std::borrow::Cow; +use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; +use quick_protobuf::sizeofs::*; +use super::*; -#[derive(PartialEq,Clone,Default)] +#[derive(Debug, Default, PartialEq, Clone)] pub struct Test1 { - // message fields - value: ::std::option::Option, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a Test1 { - fn default() -> &'a Test1 { - ::default_instance() - } -} - -impl Test1 { - pub fn new() -> Test1 { - ::std::default::Default::default() - } - - // optional int32 value = 1; - - - pub fn get_value(&self) -> i32 { - self.value.unwrap_or(0) - } - pub fn clear_value(&mut self) { - self.value = ::std::option::Option::None; - } - - pub fn has_value(&self) -> bool { - self.value.is_some() - } - - // Param is passed by value, moved - pub fn set_value(&mut self, v: i32) { - self.value = ::std::option::Option::Some(v); - } + pub value: Option, } -impl ::protobuf::Message for Test1 { - 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 = ::std::option::Option::Some(tmp); - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(v) = self.value { - my_size += ::protobuf::rt::value_size(1, v, ::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 let Some(v) = self.value { - os.write_int32(1, v)?; - } - 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) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> Test1 { - Test1::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_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "value", - |m: &Test1| { &m.value }, - |m: &mut Test1| { &mut m.value }, - )); - ::protobuf::reflect::MessageDescriptor::new::( - "Test1", - fields, - file_descriptor_proto() - ) - }) - } - } - - fn default_instance() -> &'static Test1 { - static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { - lock: ::protobuf::lazy::ONCE_INIT, - ptr: 0 as *const Test1, - }; - unsafe { - instance.get(Test1::new) +impl<'a> MessageRead<'a> for Test1 { + fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result { + let mut msg = Self::default(); + while !r.is_eof() { + match r.next_tag(bytes) { + Ok(8) => msg.value = Some(r.read_int32(bytes)?), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } } + Ok(msg) } } -impl ::protobuf::Clear for Test1 { - fn clear(&mut self) { - self.value = ::std::option::Option::None; - self.unknown_fields.clear(); +impl MessageWrite for Test1 { + fn get_size(&self) -> usize { + 0 + + self.value.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64)) } -} - -impl ::std::fmt::Debug for Test1 { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} -impl ::protobuf::reflect::ProtobufValue for Test1 { - fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { - ::protobuf::reflect::ProtobufValueRef::Message(self) + fn write_message(&self, w: &mut Writer) -> Result<()> { + if let Some(ref s) = self.value { w.write_with_tag(8, |w| w.write_int32(*s))?; } + Ok(()) } } -#[derive(PartialEq,Clone,Default)] +#[derive(Debug, Default, PartialEq, Clone)] pub struct TestRepeatedBool { - // message fields - values: ::std::vec::Vec, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a TestRepeatedBool { - fn default() -> &'a TestRepeatedBool { - ::default_instance() - } -} - -impl TestRepeatedBool { - pub fn new() -> TestRepeatedBool { - ::std::default::Default::default() - } - - // repeated bool values = 1; - - - pub fn get_values(&self) -> &[bool] { - &self.values - } - pub fn clear_values(&mut self) { - self.values.clear(); - } - - // Param is passed by value, moved - pub fn set_values(&mut self, v: ::std::vec::Vec) { - self.values = v; - } - - // Mutable pointer to the field. - pub fn mut_values(&mut self) -> &mut ::std::vec::Vec { - &mut self.values - } - - // Take field - pub fn take_values(&mut self) -> ::std::vec::Vec { - ::std::mem::replace(&mut self.values, ::std::vec::Vec::new()) - } + pub values: Vec, } -impl ::protobuf::Message for TestRepeatedBool { - 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_repeated_bool_into(wire_type, is, &mut self.values)?; - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - my_size += 2 * self.values.len() as u32; - 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.values { - os.write_bool(1, *v)?; - }; - 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) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> TestRepeatedBool { - TestRepeatedBool::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_vec_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "values", - |m: &TestRepeatedBool| { &m.values }, - |m: &mut TestRepeatedBool| { &mut m.values }, - )); - ::protobuf::reflect::MessageDescriptor::new::( - "TestRepeatedBool", - fields, - file_descriptor_proto() - ) - }) - } - } - - fn default_instance() -> &'static TestRepeatedBool { - static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { - lock: ::protobuf::lazy::ONCE_INIT, - ptr: 0 as *const TestRepeatedBool, - }; - unsafe { - instance.get(TestRepeatedBool::new) +impl<'a> MessageRead<'a> for TestRepeatedBool { + fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result { + let mut msg = Self::default(); + while !r.is_eof() { + match r.next_tag(bytes) { + Ok(8) => msg.values.push(r.read_bool(bytes)?), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } } + Ok(msg) } } -impl ::protobuf::Clear for TestRepeatedBool { - fn clear(&mut self) { - self.values.clear(); - self.unknown_fields.clear(); +impl MessageWrite for TestRepeatedBool { + fn get_size(&self) -> usize { + 0 + + self.values.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() } -} - -impl ::std::fmt::Debug for TestRepeatedBool { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} -impl ::protobuf::reflect::ProtobufValue for TestRepeatedBool { - fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { - ::protobuf::reflect::ProtobufValueRef::Message(self) + fn write_message(&self, w: &mut Writer) -> Result<()> { + for s in &self.values { w.write_with_tag(8, |w| w.write_bool(*s))?; } + Ok(()) } } -#[derive(PartialEq,Clone,Default)] +#[derive(Debug, Default, PartialEq, Clone)] pub struct TestRepeatedPackedInt32 { - // message fields - values: ::std::vec::Vec, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, + pub values: Vec, } -impl<'a> ::std::default::Default for &'a TestRepeatedPackedInt32 { - fn default() -> &'a TestRepeatedPackedInt32 { - ::default_instance() +impl<'a> MessageRead<'a> for TestRepeatedPackedInt32 { + fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result { + let mut msg = Self::default(); + while !r.is_eof() { + match r.next_tag(bytes) { + Ok(10) => msg.values = r.read_packed(bytes, |r, bytes| Ok(r.read_int32(bytes)?))?, + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) } } -impl TestRepeatedPackedInt32 { - pub fn new() -> TestRepeatedPackedInt32 { - ::std::default::Default::default() - } - - // repeated int32 values = 1; - - - pub fn get_values(&self) -> &[i32] { - &self.values - } - pub fn clear_values(&mut self) { - self.values.clear(); - } - - // Param is passed by value, moved - pub fn set_values(&mut self, v: ::std::vec::Vec) { - self.values = v; - } - - // Mutable pointer to the field. - pub fn mut_values(&mut self) -> &mut ::std::vec::Vec { - &mut self.values +impl MessageWrite for TestRepeatedPackedInt32 { + fn get_size(&self) -> usize { + 0 + + if self.values.is_empty() { 0 } else { 1 + sizeof_len(self.values.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } } - // Take field - pub fn take_values(&mut self) -> ::std::vec::Vec { - ::std::mem::replace(&mut self.values, ::std::vec::Vec::new()) + fn write_message(&self, w: &mut Writer) -> Result<()> { + w.write_packed_with_tag(10, &self.values, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?; + Ok(()) } } -impl ::protobuf::Message for TestRepeatedPackedInt32 { - 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_repeated_int32_into(wire_type, is, &mut self.values)?; - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if !self.values.is_empty() { - my_size += ::protobuf::rt::vec_packed_varint_size(1, &self.values); - } - 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.values.is_empty() { - os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; - // TODO: Data size is computed again, it should be cached - os.write_raw_varint32(::protobuf::rt::vec_packed_varint_data_size(&self.values))?; - for v in &self.values { - os.write_int32_no_tag(*v)?; - }; +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestRepeatedMessages { + pub messages1: Vec, + pub messages2: Vec, + pub messages3: Vec, +} + +impl<'a> MessageRead<'a> for TestRepeatedMessages { + fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result { + let mut msg = Self::default(); + while !r.is_eof() { + match r.next_tag(bytes) { + Ok(10) => msg.messages1.push(r.read_message::(bytes)?), + Ok(18) => msg.messages2.push(r.read_message::(bytes)?), + Ok(26) => msg.messages3.push(r.read_message::(bytes)?), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } } - 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) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> TestRepeatedPackedInt32 { - TestRepeatedPackedInt32::new() + Ok(msg) } +} - 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_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "values", - |m: &TestRepeatedPackedInt32| { &m.values }, - |m: &mut TestRepeatedPackedInt32| { &mut m.values }, - )); - ::protobuf::reflect::MessageDescriptor::new::( - "TestRepeatedPackedInt32", - fields, - file_descriptor_proto() - ) - }) - } +impl MessageWrite for TestRepeatedMessages { + fn get_size(&self) -> usize { + 0 + + self.messages1.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() + + self.messages2.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() + + self.messages3.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() } - fn default_instance() -> &'static TestRepeatedPackedInt32 { - static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { - lock: ::protobuf::lazy::ONCE_INIT, - ptr: 0 as *const TestRepeatedPackedInt32, - }; - unsafe { - instance.get(TestRepeatedPackedInt32::new) - } + fn write_message(&self, w: &mut Writer) -> Result<()> { + for s in &self.messages1 { w.write_with_tag(10, |w| w.write_message(s))?; } + for s in &self.messages2 { w.write_with_tag(18, |w| w.write_message(s))?; } + for s in &self.messages3 { w.write_with_tag(26, |w| w.write_message(s))?; } + Ok(()) } } -impl ::protobuf::Clear for TestRepeatedPackedInt32 { - fn clear(&mut self) { - self.values.clear(); - self.unknown_fields.clear(); +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestOptionalMessages { + pub message1: Option>, + pub message2: Option>, + pub message3: Option>, +} + +impl<'a> MessageRead<'a> for TestOptionalMessages { + fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result { + let mut msg = Self::default(); + while !r.is_eof() { + match r.next_tag(bytes) { + Ok(10) => msg.message1 = Some(Box::new(r.read_message::(bytes)?)), + Ok(18) => msg.message2 = Some(Box::new(r.read_message::(bytes)?)), + Ok(26) => msg.message3 = Some(Box::new(r.read_message::(bytes)?)), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) } } -impl ::std::fmt::Debug for TestRepeatedPackedInt32 { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) +impl MessageWrite for TestOptionalMessages { + fn get_size(&self) -> usize { + 0 + + self.message1.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) + + self.message2.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) + + self.message3.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) } -} -impl ::protobuf::reflect::ProtobufValue for TestRepeatedPackedInt32 { - fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { - ::protobuf::reflect::ProtobufValueRef::Message(self) + fn write_message(&self, w: &mut Writer) -> Result<()> { + if let Some(ref s) = self.message1 { w.write_with_tag(10, |w| w.write_message(&**s))?; } + if let Some(ref s) = self.message2 { w.write_with_tag(18, |w| w.write_message(&**s))?; } + if let Some(ref s) = self.message3 { w.write_with_tag(26, |w| w.write_message(&**s))?; } + Ok(()) } } -#[derive(PartialEq,Clone,Default)] -pub struct TestRepeatedMessages { - // message fields - messages1: ::protobuf::RepeatedField, - messages2: ::protobuf::RepeatedField, - messages3: ::protobuf::RepeatedField, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestStrings<'a> { + pub s1: Option>, + pub s2: Option>, + pub s3: Option>, } -impl<'a> ::std::default::Default for &'a TestRepeatedMessages { - fn default() -> &'a TestRepeatedMessages { - ::default_instance() +impl<'a> MessageRead<'a> for TestStrings<'a> { + fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result { + let mut msg = Self::default(); + while !r.is_eof() { + match r.next_tag(bytes) { + Ok(10) => msg.s1 = Some(r.read_string(bytes).map(Cow::Borrowed)?), + Ok(18) => msg.s2 = Some(r.read_string(bytes).map(Cow::Borrowed)?), + Ok(26) => msg.s3 = Some(r.read_string(bytes).map(Cow::Borrowed)?), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) } } -impl TestRepeatedMessages { - pub fn new() -> TestRepeatedMessages { - ::std::default::Default::default() - } - - // repeated .perftest_data.TestRepeatedMessages messages1 = 1; - - - pub fn get_messages1(&self) -> &[TestRepeatedMessages] { - &self.messages1 - } - pub fn clear_messages1(&mut self) { - self.messages1.clear(); - } - - // Param is passed by value, moved - pub fn set_messages1(&mut self, v: ::protobuf::RepeatedField) { - self.messages1 = v; - } - - // Mutable pointer to the field. - pub fn mut_messages1(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.messages1 - } - - // Take field - pub fn take_messages1(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.messages1, ::protobuf::RepeatedField::new()) +impl<'a> MessageWrite for TestStrings<'a> { + fn get_size(&self) -> usize { + 0 + + self.s1.as_ref().map_or(0, |m| 1 + sizeof_len((m).len())) + + self.s2.as_ref().map_or(0, |m| 1 + sizeof_len((m).len())) + + self.s3.as_ref().map_or(0, |m| 1 + sizeof_len((m).len())) } - // repeated .perftest_data.TestRepeatedMessages messages2 = 2; - - - pub fn get_messages2(&self) -> &[TestRepeatedMessages] { - &self.messages2 - } - pub fn clear_messages2(&mut self) { - self.messages2.clear(); - } - - // Param is passed by value, moved - pub fn set_messages2(&mut self, v: ::protobuf::RepeatedField) { - self.messages2 = v; - } - - // Mutable pointer to the field. - pub fn mut_messages2(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.messages2 - } - - // Take field - pub fn take_messages2(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.messages2, ::protobuf::RepeatedField::new()) - } - - // repeated .perftest_data.TestRepeatedMessages messages3 = 3; - - - pub fn get_messages3(&self) -> &[TestRepeatedMessages] { - &self.messages3 - } - pub fn clear_messages3(&mut self) { - self.messages3.clear(); - } - - // Param is passed by value, moved - pub fn set_messages3(&mut self, v: ::protobuf::RepeatedField) { - self.messages3 = v; - } - - // Mutable pointer to the field. - pub fn mut_messages3(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.messages3 + fn write_message(&self, w: &mut Writer) -> Result<()> { + if let Some(ref s) = self.s1 { w.write_with_tag(10, |w| w.write_string(&**s))?; } + if let Some(ref s) = self.s2 { w.write_with_tag(18, |w| w.write_string(&**s))?; } + if let Some(ref s) = self.s3 { w.write_with_tag(26, |w| w.write_string(&**s))?; } + Ok(()) } +} - // Take field - pub fn take_messages3(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.messages3, ::protobuf::RepeatedField::new()) - } +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestBytes<'a> { + pub b1: Option>, } -impl ::protobuf::Message for TestRepeatedMessages { - fn is_initialized(&self) -> bool { - for v in &self.messages1 { - if !v.is_initialized() { - return false; +impl<'a> MessageRead<'a> for TestBytes<'a> { + fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result { + let mut msg = Self::default(); + while !r.is_eof() { + match r.next_tag(bytes) { + Ok(10) => msg.b1 = Some(r.read_bytes(bytes).map(Cow::Borrowed)?), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), } - }; - for v in &self.messages2 { - if !v.is_initialized() { - return false; - } - }; - for v in &self.messages3 { - 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.messages1)?; - }, - 2 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.messages2)?; - }, - 3 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.messages3)?; - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - for value in &self.messages1 { - let len = value.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - for value in &self.messages2 { - let len = value.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - for value in &self.messages3 { - 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.messages1 { - os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - for v in &self.messages2 { - os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - for v in &self.messages3 { - os.write_tag(3, ::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) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> TestRepeatedMessages { - TestRepeatedMessages::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>( - "messages1", - |m: &TestRepeatedMessages| { &m.messages1 }, - |m: &mut TestRepeatedMessages| { &mut m.messages1 }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "messages2", - |m: &TestRepeatedMessages| { &m.messages2 }, - |m: &mut TestRepeatedMessages| { &mut m.messages2 }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "messages3", - |m: &TestRepeatedMessages| { &m.messages3 }, - |m: &mut TestRepeatedMessages| { &mut m.messages3 }, - )); - ::protobuf::reflect::MessageDescriptor::new::( - "TestRepeatedMessages", - fields, - file_descriptor_proto() - ) - }) - } - } - - fn default_instance() -> &'static TestRepeatedMessages { - static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { - lock: ::protobuf::lazy::ONCE_INIT, - ptr: 0 as *const TestRepeatedMessages, - }; - unsafe { - instance.get(TestRepeatedMessages::new) } + Ok(msg) } } -impl ::protobuf::Clear for TestRepeatedMessages { - fn clear(&mut self) { - self.messages1.clear(); - self.messages2.clear(); - self.messages3.clear(); - self.unknown_fields.clear(); +impl<'a> MessageWrite for TestBytes<'a> { + fn get_size(&self) -> usize { + 0 + + self.b1.as_ref().map_or(0, |m| 1 + sizeof_len((m).len())) } -} - -impl ::std::fmt::Debug for TestRepeatedMessages { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} -impl ::protobuf::reflect::ProtobufValue for TestRepeatedMessages { - fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { - ::protobuf::reflect::ProtobufValueRef::Message(self) + fn write_message(&self, w: &mut Writer) -> Result<()> { + if let Some(ref s) = self.b1 { w.write_with_tag(10, |w| w.write_bytes(&**s))?; } + Ok(()) } } -#[derive(PartialEq,Clone,Default)] -pub struct TestOptionalMessages { - // message fields - message1: ::protobuf::SingularPtrField, - message2: ::protobuf::SingularPtrField, - message3: ::protobuf::SingularPtrField, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a TestOptionalMessages { - fn default() -> &'a TestOptionalMessages { - ::default_instance() - } +#[derive(Debug, Default, PartialEq, Clone)] +pub struct PerftestData<'a> { + pub test1: Vec, + pub test_repeated_bool: Vec, + pub test_repeated_messages: Vec, + pub test_optional_messages: Vec, + pub test_strings: Vec>, + pub test_repeated_packed_int32: Vec, + pub test_small_bytearrays: Vec>, + pub test_large_bytearrays: Vec>, } -impl TestOptionalMessages { - pub fn new() -> TestOptionalMessages { - ::std::default::Default::default() - } - - // optional .perftest_data.TestOptionalMessages message1 = 1; - - - pub fn get_message1(&self) -> &TestOptionalMessages { - self.message1.as_ref().unwrap_or_else(|| TestOptionalMessages::default_instance()) - } - pub fn clear_message1(&mut self) { - self.message1.clear(); - } - - pub fn has_message1(&self) -> bool { - self.message1.is_some() - } - - // Param is passed by value, moved - pub fn set_message1(&mut self, v: TestOptionalMessages) { - self.message1 = ::protobuf::SingularPtrField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_message1(&mut self) -> &mut TestOptionalMessages { - if self.message1.is_none() { - self.message1.set_default(); - } - self.message1.as_mut().unwrap() - } - - // Take field - pub fn take_message1(&mut self) -> TestOptionalMessages { - self.message1.take().unwrap_or_else(|| TestOptionalMessages::new()) - } - - // optional .perftest_data.TestOptionalMessages message2 = 2; - - - pub fn get_message2(&self) -> &TestOptionalMessages { - self.message2.as_ref().unwrap_or_else(|| TestOptionalMessages::default_instance()) - } - pub fn clear_message2(&mut self) { - self.message2.clear(); - } - - pub fn has_message2(&self) -> bool { - self.message2.is_some() - } - - // Param is passed by value, moved - pub fn set_message2(&mut self, v: TestOptionalMessages) { - self.message2 = ::protobuf::SingularPtrField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_message2(&mut self) -> &mut TestOptionalMessages { - if self.message2.is_none() { - self.message2.set_default(); +impl<'a> MessageRead<'a> for PerftestData<'a> { + fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result { + let mut msg = Self::default(); + while !r.is_eof() { + match r.next_tag(bytes) { + Ok(10) => msg.test1.push(r.read_message::(bytes)?), + Ok(18) => msg.test_repeated_bool.push(r.read_message::(bytes)?), + Ok(26) => msg.test_repeated_messages.push(r.read_message::(bytes)?), + Ok(34) => msg.test_optional_messages.push(r.read_message::(bytes)?), + Ok(42) => msg.test_strings.push(r.read_message::(bytes)?), + Ok(50) => msg.test_repeated_packed_int32.push(r.read_message::(bytes)?), + Ok(58) => msg.test_small_bytearrays.push(r.read_message::(bytes)?), + Ok(66) => msg.test_large_bytearrays.push(r.read_message::(bytes)?), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } } - self.message2.as_mut().unwrap() - } - - // Take field - pub fn take_message2(&mut self) -> TestOptionalMessages { - self.message2.take().unwrap_or_else(|| TestOptionalMessages::new()) - } - - // optional .perftest_data.TestOptionalMessages message3 = 3; - - - pub fn get_message3(&self) -> &TestOptionalMessages { - self.message3.as_ref().unwrap_or_else(|| TestOptionalMessages::default_instance()) - } - pub fn clear_message3(&mut self) { - self.message3.clear(); - } - - pub fn has_message3(&self) -> bool { - self.message3.is_some() - } - - // Param is passed by value, moved - pub fn set_message3(&mut self, v: TestOptionalMessages) { - self.message3 = ::protobuf::SingularPtrField::some(v); + Ok(msg) } +} - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_message3(&mut self) -> &mut TestOptionalMessages { - if self.message3.is_none() { - self.message3.set_default(); - } - self.message3.as_mut().unwrap() +impl<'a> MessageWrite for PerftestData<'a> { + fn get_size(&self) -> usize { + 0 + + self.test1.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() + + self.test_repeated_bool.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() + + self.test_repeated_messages.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() + + self.test_optional_messages.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() + + self.test_strings.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() + + self.test_repeated_packed_int32.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() + + self.test_small_bytearrays.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() + + self.test_large_bytearrays.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() } - // Take field - pub fn take_message3(&mut self) -> TestOptionalMessages { - self.message3.take().unwrap_or_else(|| TestOptionalMessages::new()) + fn write_message(&self, w: &mut Writer) -> Result<()> { + for s in &self.test1 { w.write_with_tag(10, |w| w.write_message(s))?; } + for s in &self.test_repeated_bool { w.write_with_tag(18, |w| w.write_message(s))?; } + for s in &self.test_repeated_messages { w.write_with_tag(26, |w| w.write_message(s))?; } + for s in &self.test_optional_messages { w.write_with_tag(34, |w| w.write_message(s))?; } + for s in &self.test_strings { w.write_with_tag(42, |w| w.write_message(s))?; } + for s in &self.test_repeated_packed_int32 { w.write_with_tag(50, |w| w.write_message(s))?; } + for s in &self.test_small_bytearrays { w.write_with_tag(58, |w| w.write_message(s))?; } + for s in &self.test_large_bytearrays { w.write_with_tag(66, |w| w.write_message(s))?; } + Ok(()) } } -impl ::protobuf::Message for TestOptionalMessages { - fn is_initialized(&self) -> bool { - for v in &self.message1 { - if !v.is_initialized() { - return false; - } - }; - for v in &self.message2 { - if !v.is_initialized() { - return false; - } - }; - for v in &self.message3 { - 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.message1)?; - }, - 2 => { - ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.message2)?; - }, - 3 => { - ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.message3)?; - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(ref v) = self.message1.as_ref() { - let len = v.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - } - if let Some(ref v) = self.message2.as_ref() { - let len = v.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - } - if let Some(ref v) = self.message3.as_ref() { - let len = v.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.message1.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.message2.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.message3.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)?; - } - 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) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> TestOptionalMessages { - TestOptionalMessages::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>( - "message1", - |m: &TestOptionalMessages| { &m.message1 }, - |m: &mut TestOptionalMessages| { &mut m.message1 }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "message2", - |m: &TestOptionalMessages| { &m.message2 }, - |m: &mut TestOptionalMessages| { &mut m.message2 }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "message3", - |m: &TestOptionalMessages| { &m.message3 }, - |m: &mut TestOptionalMessages| { &mut m.message3 }, - )); - ::protobuf::reflect::MessageDescriptor::new::( - "TestOptionalMessages", - fields, - file_descriptor_proto() - ) - }) - } - } - - fn default_instance() -> &'static TestOptionalMessages { - static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { - lock: ::protobuf::lazy::ONCE_INIT, - ptr: 0 as *const TestOptionalMessages, - }; - unsafe { - instance.get(TestOptionalMessages::new) - } - } -} - -impl ::protobuf::Clear for TestOptionalMessages { - fn clear(&mut self) { - self.message1.clear(); - self.message2.clear(); - self.message3.clear(); - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for TestOptionalMessages { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for TestOptionalMessages { - fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { - ::protobuf::reflect::ProtobufValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct TestStrings { - // message fields - s1: ::protobuf::SingularField<::std::string::String>, - s2: ::protobuf::SingularField<::std::string::String>, - s3: ::protobuf::SingularField<::std::string::String>, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a TestStrings { - fn default() -> &'a TestStrings { - ::default_instance() - } -} - -impl TestStrings { - pub fn new() -> TestStrings { - ::std::default::Default::default() - } - - // optional string s1 = 1; - - - pub fn get_s1(&self) -> &str { - match self.s1.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_s1(&mut self) { - self.s1.clear(); - } - - pub fn has_s1(&self) -> bool { - self.s1.is_some() - } - - // Param is passed by value, moved - pub fn set_s1(&mut self, v: ::std::string::String) { - self.s1 = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_s1(&mut self) -> &mut ::std::string::String { - if self.s1.is_none() { - self.s1.set_default(); - } - self.s1.as_mut().unwrap() - } - - // Take field - pub fn take_s1(&mut self) -> ::std::string::String { - self.s1.take().unwrap_or_else(|| ::std::string::String::new()) - } - // optional string s2 = 2; - - - pub fn get_s2(&self) -> &str { - match self.s2.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_s2(&mut self) { - self.s2.clear(); - } - - pub fn has_s2(&self) -> bool { - self.s2.is_some() - } - - // Param is passed by value, moved - pub fn set_s2(&mut self, v: ::std::string::String) { - self.s2 = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_s2(&mut self) -> &mut ::std::string::String { - if self.s2.is_none() { - self.s2.set_default(); - } - self.s2.as_mut().unwrap() - } - - // Take field - pub fn take_s2(&mut self) -> ::std::string::String { - self.s2.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional string s3 = 3; - - - pub fn get_s3(&self) -> &str { - match self.s3.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_s3(&mut self) { - self.s3.clear(); - } - - pub fn has_s3(&self) -> bool { - self.s3.is_some() - } - - // Param is passed by value, moved - pub fn set_s3(&mut self, v: ::std::string::String) { - self.s3 = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_s3(&mut self) -> &mut ::std::string::String { - if self.s3.is_none() { - self.s3.set_default(); - } - self.s3.as_mut().unwrap() - } - - // Take field - pub fn take_s3(&mut self) -> ::std::string::String { - self.s3.take().unwrap_or_else(|| ::std::string::String::new()) - } -} - -impl ::protobuf::Message for TestStrings { - 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_string_into(wire_type, is, &mut self.s1)?; - }, - 2 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.s2)?; - }, - 3 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.s3)?; - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(ref v) = self.s1.as_ref() { - my_size += ::protobuf::rt::string_size(1, &v); - } - if let Some(ref v) = self.s2.as_ref() { - my_size += ::protobuf::rt::string_size(2, &v); - } - if let Some(ref v) = self.s3.as_ref() { - my_size += ::protobuf::rt::string_size(3, &v); - } - 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.s1.as_ref() { - os.write_string(1, &v)?; - } - if let Some(ref v) = self.s2.as_ref() { - os.write_string(2, &v)?; - } - if let Some(ref v) = self.s3.as_ref() { - os.write_string(3, &v)?; - } - 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) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> TestStrings { - TestStrings::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_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "s1", - |m: &TestStrings| { &m.s1 }, - |m: &mut TestStrings| { &mut m.s1 }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "s2", - |m: &TestStrings| { &m.s2 }, - |m: &mut TestStrings| { &mut m.s2 }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "s3", - |m: &TestStrings| { &m.s3 }, - |m: &mut TestStrings| { &mut m.s3 }, - )); - ::protobuf::reflect::MessageDescriptor::new::( - "TestStrings", - fields, - file_descriptor_proto() - ) - }) - } - } - - fn default_instance() -> &'static TestStrings { - static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { - lock: ::protobuf::lazy::ONCE_INIT, - ptr: 0 as *const TestStrings, - }; - unsafe { - instance.get(TestStrings::new) - } - } -} - -impl ::protobuf::Clear for TestStrings { - fn clear(&mut self) { - self.s1.clear(); - self.s2.clear(); - self.s3.clear(); - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for TestStrings { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for TestStrings { - fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { - ::protobuf::reflect::ProtobufValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct TestBytes { - // message fields - b1: ::protobuf::SingularField<::std::vec::Vec>, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a TestBytes { - fn default() -> &'a TestBytes { - ::default_instance() - } -} - -impl TestBytes { - pub fn new() -> TestBytes { - ::std::default::Default::default() - } - - // optional bytes b1 = 1; - - - pub fn get_b1(&self) -> &[u8] { - match self.b1.as_ref() { - Some(v) => &v, - None => &[], - } - } - pub fn clear_b1(&mut self) { - self.b1.clear(); - } - - pub fn has_b1(&self) -> bool { - self.b1.is_some() - } - - // Param is passed by value, moved - pub fn set_b1(&mut self, v: ::std::vec::Vec) { - self.b1 = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_b1(&mut self) -> &mut ::std::vec::Vec { - if self.b1.is_none() { - self.b1.set_default(); - } - self.b1.as_mut().unwrap() - } - - // Take field - pub fn take_b1(&mut self) -> ::std::vec::Vec { - self.b1.take().unwrap_or_else(|| ::std::vec::Vec::new()) - } -} - -impl ::protobuf::Message for TestBytes { - 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_bytes_into(wire_type, is, &mut self.b1)?; - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(ref v) = self.b1.as_ref() { - my_size += ::protobuf::rt::bytes_size(1, &v); - } - 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.b1.as_ref() { - os.write_bytes(1, &v)?; - } - 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) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> TestBytes { - TestBytes::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_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( - "b1", - |m: &TestBytes| { &m.b1 }, - |m: &mut TestBytes| { &mut m.b1 }, - )); - ::protobuf::reflect::MessageDescriptor::new::( - "TestBytes", - fields, - file_descriptor_proto() - ) - }) - } - } - - fn default_instance() -> &'static TestBytes { - static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { - lock: ::protobuf::lazy::ONCE_INIT, - ptr: 0 as *const TestBytes, - }; - unsafe { - instance.get(TestBytes::new) - } - } -} - -impl ::protobuf::Clear for TestBytes { - fn clear(&mut self) { - self.b1.clear(); - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for TestBytes { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for TestBytes { - fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { - ::protobuf::reflect::ProtobufValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct PerftestData { - // message fields - test1: ::protobuf::RepeatedField, - test_repeated_bool: ::protobuf::RepeatedField, - test_repeated_messages: ::protobuf::RepeatedField, - test_optional_messages: ::protobuf::RepeatedField, - test_strings: ::protobuf::RepeatedField, - test_repeated_packed_int32: ::protobuf::RepeatedField, - test_small_bytearrays: ::protobuf::RepeatedField, - test_large_bytearrays: ::protobuf::RepeatedField, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a PerftestData { - fn default() -> &'a PerftestData { - ::default_instance() - } -} - -impl PerftestData { - pub fn new() -> PerftestData { - ::std::default::Default::default() - } - - // repeated .perftest_data.Test1 test1 = 1; - - - pub fn get_test1(&self) -> &[Test1] { - &self.test1 - } - pub fn clear_test1(&mut self) { - self.test1.clear(); - } - - // Param is passed by value, moved - pub fn set_test1(&mut self, v: ::protobuf::RepeatedField) { - self.test1 = v; - } - - // Mutable pointer to the field. - pub fn mut_test1(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.test1 - } - - // Take field - pub fn take_test1(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.test1, ::protobuf::RepeatedField::new()) - } - - // repeated .perftest_data.TestRepeatedBool test_repeated_bool = 2; - - - pub fn get_test_repeated_bool(&self) -> &[TestRepeatedBool] { - &self.test_repeated_bool - } - pub fn clear_test_repeated_bool(&mut self) { - self.test_repeated_bool.clear(); - } - - // Param is passed by value, moved - pub fn set_test_repeated_bool(&mut self, v: ::protobuf::RepeatedField) { - self.test_repeated_bool = v; - } - - // Mutable pointer to the field. - pub fn mut_test_repeated_bool(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.test_repeated_bool - } - - // Take field - pub fn take_test_repeated_bool(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.test_repeated_bool, ::protobuf::RepeatedField::new()) - } - - // repeated .perftest_data.TestRepeatedMessages test_repeated_messages = 3; - - - pub fn get_test_repeated_messages(&self) -> &[TestRepeatedMessages] { - &self.test_repeated_messages - } - pub fn clear_test_repeated_messages(&mut self) { - self.test_repeated_messages.clear(); - } - - // Param is passed by value, moved - pub fn set_test_repeated_messages(&mut self, v: ::protobuf::RepeatedField) { - self.test_repeated_messages = v; - } - - // Mutable pointer to the field. - pub fn mut_test_repeated_messages(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.test_repeated_messages - } - - // Take field - pub fn take_test_repeated_messages(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.test_repeated_messages, ::protobuf::RepeatedField::new()) - } - - // repeated .perftest_data.TestOptionalMessages test_optional_messages = 4; - - - pub fn get_test_optional_messages(&self) -> &[TestOptionalMessages] { - &self.test_optional_messages - } - pub fn clear_test_optional_messages(&mut self) { - self.test_optional_messages.clear(); - } - - // Param is passed by value, moved - pub fn set_test_optional_messages(&mut self, v: ::protobuf::RepeatedField) { - self.test_optional_messages = v; - } - - // Mutable pointer to the field. - pub fn mut_test_optional_messages(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.test_optional_messages - } - - // Take field - pub fn take_test_optional_messages(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.test_optional_messages, ::protobuf::RepeatedField::new()) - } - - // repeated .perftest_data.TestStrings test_strings = 5; - - - pub fn get_test_strings(&self) -> &[TestStrings] { - &self.test_strings - } - pub fn clear_test_strings(&mut self) { - self.test_strings.clear(); - } - - // Param is passed by value, moved - pub fn set_test_strings(&mut self, v: ::protobuf::RepeatedField) { - self.test_strings = v; - } - - // Mutable pointer to the field. - pub fn mut_test_strings(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.test_strings - } - - // Take field - pub fn take_test_strings(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.test_strings, ::protobuf::RepeatedField::new()) - } - - // repeated .perftest_data.TestRepeatedPackedInt32 test_repeated_packed_int32 = 6; - - - pub fn get_test_repeated_packed_int32(&self) -> &[TestRepeatedPackedInt32] { - &self.test_repeated_packed_int32 - } - pub fn clear_test_repeated_packed_int32(&mut self) { - self.test_repeated_packed_int32.clear(); - } - - // Param is passed by value, moved - pub fn set_test_repeated_packed_int32(&mut self, v: ::protobuf::RepeatedField) { - self.test_repeated_packed_int32 = v; - } - - // Mutable pointer to the field. - pub fn mut_test_repeated_packed_int32(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.test_repeated_packed_int32 - } - - // Take field - pub fn take_test_repeated_packed_int32(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.test_repeated_packed_int32, ::protobuf::RepeatedField::new()) - } - - // repeated .perftest_data.TestBytes test_small_bytearrays = 7; - - - pub fn get_test_small_bytearrays(&self) -> &[TestBytes] { - &self.test_small_bytearrays - } - pub fn clear_test_small_bytearrays(&mut self) { - self.test_small_bytearrays.clear(); - } - - // Param is passed by value, moved - pub fn set_test_small_bytearrays(&mut self, v: ::protobuf::RepeatedField) { - self.test_small_bytearrays = v; - } - - // Mutable pointer to the field. - pub fn mut_test_small_bytearrays(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.test_small_bytearrays - } - - // Take field - pub fn take_test_small_bytearrays(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.test_small_bytearrays, ::protobuf::RepeatedField::new()) - } - - // repeated .perftest_data.TestBytes test_large_bytearrays = 8; - - - pub fn get_test_large_bytearrays(&self) -> &[TestBytes] { - &self.test_large_bytearrays - } - pub fn clear_test_large_bytearrays(&mut self) { - self.test_large_bytearrays.clear(); - } - - // Param is passed by value, moved - pub fn set_test_large_bytearrays(&mut self, v: ::protobuf::RepeatedField) { - self.test_large_bytearrays = v; - } - - // Mutable pointer to the field. - pub fn mut_test_large_bytearrays(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.test_large_bytearrays - } - - // Take field - pub fn take_test_large_bytearrays(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.test_large_bytearrays, ::protobuf::RepeatedField::new()) - } -} - -impl ::protobuf::Message for PerftestData { - fn is_initialized(&self) -> bool { - for v in &self.test1 { - if !v.is_initialized() { - return false; - } - }; - for v in &self.test_repeated_bool { - if !v.is_initialized() { - return false; - } - }; - for v in &self.test_repeated_messages { - if !v.is_initialized() { - return false; - } - }; - for v in &self.test_optional_messages { - if !v.is_initialized() { - return false; - } - }; - for v in &self.test_strings { - if !v.is_initialized() { - return false; - } - }; - for v in &self.test_repeated_packed_int32 { - if !v.is_initialized() { - return false; - } - }; - for v in &self.test_small_bytearrays { - if !v.is_initialized() { - return false; - } - }; - for v in &self.test_large_bytearrays { - 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.test1)?; - }, - 2 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.test_repeated_bool)?; - }, - 3 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.test_repeated_messages)?; - }, - 4 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.test_optional_messages)?; - }, - 5 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.test_strings)?; - }, - 6 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.test_repeated_packed_int32)?; - }, - 7 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.test_small_bytearrays)?; - }, - 8 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.test_large_bytearrays)?; - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - for value in &self.test1 { - let len = value.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - for value in &self.test_repeated_bool { - let len = value.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - for value in &self.test_repeated_messages { - let len = value.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - for value in &self.test_optional_messages { - let len = value.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - for value in &self.test_strings { - let len = value.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - for value in &self.test_repeated_packed_int32 { - let len = value.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - for value in &self.test_small_bytearrays { - let len = value.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - for value in &self.test_large_bytearrays { - 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.test1 { - os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - for v in &self.test_repeated_bool { - os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - for v in &self.test_repeated_messages { - os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - for v in &self.test_optional_messages { - os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - for v in &self.test_strings { - os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - for v in &self.test_repeated_packed_int32 { - os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - for v in &self.test_small_bytearrays { - 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.test_large_bytearrays { - 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) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> PerftestData { - PerftestData::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>( - "test1", - |m: &PerftestData| { &m.test1 }, - |m: &mut PerftestData| { &mut m.test1 }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "test_repeated_bool", - |m: &PerftestData| { &m.test_repeated_bool }, - |m: &mut PerftestData| { &mut m.test_repeated_bool }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "test_repeated_messages", - |m: &PerftestData| { &m.test_repeated_messages }, - |m: &mut PerftestData| { &mut m.test_repeated_messages }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "test_optional_messages", - |m: &PerftestData| { &m.test_optional_messages }, - |m: &mut PerftestData| { &mut m.test_optional_messages }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "test_strings", - |m: &PerftestData| { &m.test_strings }, - |m: &mut PerftestData| { &mut m.test_strings }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "test_repeated_packed_int32", - |m: &PerftestData| { &m.test_repeated_packed_int32 }, - |m: &mut PerftestData| { &mut m.test_repeated_packed_int32 }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "test_small_bytearrays", - |m: &PerftestData| { &m.test_small_bytearrays }, - |m: &mut PerftestData| { &mut m.test_small_bytearrays }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "test_large_bytearrays", - |m: &PerftestData| { &m.test_large_bytearrays }, - |m: &mut PerftestData| { &mut m.test_large_bytearrays }, - )); - ::protobuf::reflect::MessageDescriptor::new::( - "PerftestData", - fields, - file_descriptor_proto() - ) - }) - } - } - - fn default_instance() -> &'static PerftestData { - static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { - lock: ::protobuf::lazy::ONCE_INIT, - ptr: 0 as *const PerftestData, - }; - unsafe { - instance.get(PerftestData::new) - } - } -} - -impl ::protobuf::Clear for PerftestData { - fn clear(&mut self) { - self.test1.clear(); - self.test_repeated_bool.clear(); - self.test_repeated_messages.clear(); - self.test_optional_messages.clear(); - self.test_strings.clear(); - self.test_repeated_packed_int32.clear(); - self.test_small_bytearrays.clear(); - self.test_large_bytearrays.clear(); - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for PerftestData { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for PerftestData { - fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { - ::protobuf::reflect::ProtobufValueRef::Message(self) - } -} - -static file_descriptor_proto_data: &'static [u8] = b"\ - \n\x13perftest_data.proto\x12\rperftest_data\"\x1a\n\x05Test1\x12\x0f\n\ - \x05value\x18\x01\x20\x01(\x05B\0:\0\"&\n\x10TestRepeatedBool\x12\x10\n\ - \x06values\x18\x01\x20\x03(\x08B\0:\0\"/\n\x17TestRepeatedPackedInt32\ - \x12\x12\n\x06values\x18\x01\x20\x03(\x05B\x02\x10\x01:\0\"\xc6\x01\n\ - \x14TestRepeatedMessages\x128\n\tmessages1\x18\x01\x20\x03(\x0b2#.perfte\ - st_data.TestRepeatedMessagesB\0\x128\n\tmessages2\x18\x02\x20\x03(\x0b2#\ - .perftest_data.TestRepeatedMessagesB\0\x128\n\tmessages3\x18\x03\x20\x03\ - (\x0b2#.perftest_data.TestRepeatedMessagesB\0:\0\"\xc3\x01\n\x14TestOpti\ - onalMessages\x127\n\x08message1\x18\x01\x20\x01(\x0b2#.perftest_data.Tes\ - tOptionalMessagesB\0\x127\n\x08message2\x18\x02\x20\x01(\x0b2#.perftest_\ - data.TestOptionalMessagesB\0\x127\n\x08message3\x18\x03\x20\x01(\x0b2#.p\ - erftest_data.TestOptionalMessagesB\0:\0\"9\n\x0bTestStrings\x12\x0c\n\ - \x02s1\x18\x01\x20\x01(\tB\0\x12\x0c\n\x02s2\x18\x02\x20\x01(\tB\0\x12\ - \x0c\n\x02s3\x18\x03\x20\x01(\tB\0:\0\"\x1b\n\tTestBytes\x12\x0c\n\x02b1\ - \x18\x01\x20\x01(\x0cB\0:\0\"\xfc\x03\n\x0cPerftestData\x12%\n\x05test1\ - \x18\x01\x20\x03(\x0b2\x14.perftest_data.Test1B\0\x12=\n\x12test_repeate\ - d_bool\x18\x02\x20\x03(\x0b2\x1f.perftest_data.TestRepeatedBoolB\0\x12E\ - \n\x16test_repeated_messages\x18\x03\x20\x03(\x0b2#.perftest_data.TestRe\ - peatedMessagesB\0\x12E\n\x16test_optional_messages\x18\x04\x20\x03(\x0b2\ - #.perftest_data.TestOptionalMessagesB\0\x122\n\x0ctest_strings\x18\x05\ - \x20\x03(\x0b2\x1a.perftest_data.TestStringsB\0\x12L\n\x1atest_repeated_\ - packed_int32\x18\x06\x20\x03(\x0b2&.perftest_data.TestRepeatedPackedInt3\ - 2B\0\x129\n\x15test_small_bytearrays\x18\x07\x20\x03(\x0b2\x18.perftest_\ - data.TestBytesB\0\x129\n\x15test_large_bytearrays\x18\x08\x20\x03(\x0b2\ - \x18.perftest_data.TestBytesB\0:\0B\0b\x06proto2\ -"; - -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() - }) - } -} diff --git a/quick-protobuf/no-std-example/src/no_std.proto b/quick-protobuf/no-std-example/src/no_std.proto index 2ff021b8..03c340af 100644 --- a/quick-protobuf/no-std-example/src/no_std.proto +++ b/quick-protobuf/no-std-example/src/no_std.proto @@ -14,7 +14,7 @@ message EmbeddedMessage { message NoStdMessage { fixed32 num = 1; - repeated fixed32 nums = 2 [rust_gen_arrayvec = 16]; + repeated fixed32 nums = 2 [(rust_max_length)=16]; EmbeddedMessage message = 3; - repeated EmbeddedMessage messages = 4 [rust_gen_arrayvec = 16]; + repeated EmbeddedMessage messages = 4 [(rust_max_length)=16]; } diff --git a/quick-protobuf/tests/rust_protobuf/v3/test_basic_pb.proto b/quick-protobuf/tests/rust_protobuf/v3/test_basic_pb.proto index 97c59914..4aaaa7e9 100644 --- a/quick-protobuf/tests/rust_protobuf/v3/test_basic_pb.proto +++ b/quick-protobuf/tests/rust_protobuf/v3/test_basic_pb.proto @@ -100,20 +100,20 @@ message TestTypesRepeated { } message TestTypesRepeatedArrayVec { - repeated double double_field = 1 [rust_gen_arrayvec=10]; - repeated float float_field = 2 [rust_gen_arrayvec=10]; - repeated int32 int32_field = 3 [rust_gen_arrayvec=10]; - repeated int64 int64_field = 4 [rust_gen_arrayvec=10]; - repeated uint32 uint32_field = 5 [rust_gen_arrayvec=10]; - repeated uint64 uint64_field = 6 [rust_gen_arrayvec=10]; - repeated sint32 sint32_field = 7 [rust_gen_arrayvec=10]; - repeated sint64 sint64_field = 8 [rust_gen_arrayvec=10]; - repeated fixed32 fixed32_field = 9 [rust_gen_arrayvec=10]; - repeated fixed64 fixed64_field = 10 [rust_gen_arrayvec=10]; - repeated sfixed32 sfixed32_field = 11 [rust_gen_arrayvec=10]; - repeated sfixed64 sfixed64_field = 12 [rust_gen_arrayvec=10]; - repeated bool bool_field = 13 [rust_gen_arrayvec=10]; - repeated TestEnumDescriptor enum_field = 14 [rust_gen_arrayvec=10]; + repeated double double_field = 1 [(rust_max_length)=10]; + repeated float float_field = 2 [(rust_max_length)=10]; + repeated int32 int32_field = 3 [(rust_max_length)=10]; + repeated int64 int64_field = 4 [(rust_max_length)=10]; + repeated uint32 uint32_field = 5 [(rust_max_length)=10]; + repeated uint64 uint64_field = 6 [(rust_max_length)=10]; + repeated sint32 sint32_field = 7 [(rust_max_length)=10]; + repeated sint64 sint64_field = 8 [(rust_max_length)=10]; + repeated fixed32 fixed32_field = 9 [(rust_max_length)=10]; + repeated fixed64 fixed64_field = 10 [(rust_max_length)=10]; + repeated sfixed32 sfixed32_field = 11 [(rust_max_length)=10]; + repeated sfixed64 sfixed64_field = 12 [(rust_max_length)=10]; + repeated bool bool_field = 13 [(rust_max_length)=10]; + repeated TestEnumDescriptor enum_field = 14 [(rust_max_length)=10]; } message TestTypesRepeatedPacked {