From 30eb96417567d59d88f3233e4b838579a91f361f Mon Sep 17 00:00:00 2001 From: Russell Mull Date: Thu, 29 Aug 2019 15:24:30 -0700 Subject: [PATCH 01/30] Add rust_gen_arrayvec field option for 'repeated' fields --- pb-rs/src/parser.rs | 6 + pb-rs/src/types.rs | 39 +- perftest/Cargo.toml | 3 +- perftest/src/perftest_data.rs | 2268 ++--------------- quick-protobuf/Cargo.toml | 6 + quick-protobuf/src/reader.rs | 23 + .../tests/rust_protobuf/v3/basic.rs | 869 +++++++ .../tests/rust_protobuf/v3/test_basic.rs | 41 + .../rust_protobuf/v3/test_basic_pb.proto | 17 + 9 files changed, 1223 insertions(+), 2049 deletions(-) create mode 100644 quick-protobuf/tests/rust_protobuf/v3/basic.rs diff --git a/pb-rs/src/parser.rs b/pb-rs/src/parser.rs index dcf7de7f..c5825541 100644 --- a/pb-rs/src/parser.rs +++ b/pb-rs/src/parser.rs @@ -265,6 +265,12 @@ named!( .find(|&&(k, _)| k == "deprecated") .map_or(false, |&(_, v)| str::FromStr::from_str(v) .expect("Cannot parse Deprecated value")), + gen_arrayvec: key_vals + .iter() + .find(|&&(k, _)| k == "rust_gen_arrayvec") + .map(|&(_, v)| v + .parse::() + .expect("Cannot parse rust_gen_arrayvec value")), }) ) ); diff --git a/pb-rs/src/types.rs b/pb-rs/src/types.rs index 7685ef4a..c3f07cd0 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -264,6 +264,7 @@ impl FieldType { fn has_lifetime( &self, desc: &FileDescriptor, + gen_arrayvec: bool, packed: bool, ignore: &mut Vec, ) -> bool { @@ -277,9 +278,10 @@ impl FieldType { | FieldType::Sfixed32 | FieldType::String_ | FieldType::Bytes_ - | FieldType::Float => packed, // Cow<[M]> + | FieldType::Float => !gen_arrayvec && packed, // Cow<[M]> FieldType::Map(ref key, ref value) => { - key.has_lifetime(desc, false, ignore) || value.has_lifetime(desc, false, ignore) + key.has_lifetime(desc, false, false, ignore) + || value.has_lifetime(desc, false, false, ignore) } _ => false, } @@ -432,9 +434,14 @@ pub struct Field { pub packed: Option, pub boxed: bool, pub deprecated: bool, + pub gen_arrayvec: Option, } impl Field { + fn gen_arrayvec(&self) -> bool { + self.gen_arrayvec.is_some() + } + fn packed(&self) -> bool { self.packed.unwrap_or(false) } @@ -495,6 +502,12 @@ impl Field { { writeln!(w, "Option<{}>,", rust_type)? } + Frequency::Repeated if self.gen_arrayvec.is_some() => writeln!( + w, + "arrayvec::ArrayVec<[{}; {}]>,", + rust_type, + self.gen_arrayvec.unwrap() + )?, Frequency::Repeated if self.packed() && self.typ.is_fixed_size() && !config.dont_use_cow => { @@ -540,6 +553,13 @@ impl Field { Frequency::Required | Frequency::Optional => { writeln!(w, "msg.{} = {},", name, val_cow)? } + Frequency::Repeated if self.packed() && self.gen_arrayvec.is_some() => { + writeln!( + w, + "msg.{} = r.read_packed_arrayvec(bytes, |r, bytes| Ok({}))?,", + name, val + )?; + } Frequency::Repeated if self.packed() && self.typ.is_fixed_size() => { writeln!(w, "msg.{} = r.read_packed_fixed(bytes)?.into(),", name)?; } @@ -800,9 +820,10 @@ impl Message { return false; } ignore.push(self.index.clone()); - let res = self - .all_fields() - .any(|f| f.typ.has_lifetime(desc, f.packed(), ignore)); + let res = self.all_fields().any(|f| { + f.typ + .has_lifetime(desc, f.gen_arrayvec(), f.packed(), ignore) + }); ignore.pop(); res } @@ -1434,9 +1455,11 @@ pub struct OneOf { impl OneOf { fn has_lifetime(&self, desc: &FileDescriptor) -> bool { - self.fields - .iter() - .any(|f| !f.deprecated && f.typ.has_lifetime(desc, f.packed(), &mut Vec::new())) + self.fields.iter().any(|f| { + !f.deprecated + && f.typ + .has_lifetime(desc, f.gen_arrayvec(), f.packed(), &mut Vec::new()) + }) } fn set_package(&mut self, package: &str, module: &str) { diff --git a/perftest/Cargo.toml b/perftest/Cargo.toml index 60016a1e..cac2aff0 100644 --- a/perftest/Cargo.toml +++ b/perftest/Cargo.toml @@ -7,7 +7,7 @@ build = "build.rs" [dependencies] protobuf = "2.0.4" -quick-protobuf = { path = "../quick-protobuf" } +quick-protobuf = { path = "../quick-protobuf", default-features = false, features = ["with_arrayvec"] } time = "0.1.40" rand = "0.5.5" prost = "0.4.0" @@ -19,3 +19,4 @@ failure = "0.1.5" protobuf-codegen-pure = "2.0.4" pb-rs = { path = "../pb-rs" } prost-build = "0.4.0" +[features] diff --git a/perftest/src/perftest_data.rs b/perftest/src/perftest_data.rs index cebe0abf..8c08b1c4 100644 --- a/perftest/src/perftest_data.rs +++ b/perftest/src/perftest_data.rs @@ -1,2130 +1,318 @@ -// 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::io::Write; +use std::borrow::Cow; +use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, 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/Cargo.toml b/quick-protobuf/Cargo.toml index 0d78622c..dcfebf12 100644 --- a/quick-protobuf/Cargo.toml +++ b/quick-protobuf/Cargo.toml @@ -14,6 +14,12 @@ edition = "2018" byteorder = "1.2.4" failure = "0.1.1" failure_derive = "0.1.1" +arrayvec = {version = "0.4.11", optional = true } [dev-dependencies] lazy_static = "0.2.10" +arrayvec = "0.4.11" + +[features] +default = ["with_arrayvec"] +with_arrayvec = ["arrayvec"] diff --git a/quick-protobuf/src/reader.rs b/quick-protobuf/src/reader.rs index a89aa7b4..e6ed2827 100644 --- a/quick-protobuf/src/reader.rs +++ b/quick-protobuf/src/reader.rs @@ -11,6 +11,9 @@ use std::fs::File; use std::io::{self, Read}; use std::path::Path; +#[cfg(feature = "with_arrayvec")] +use arrayvec::{self, ArrayVec}; + use crate::errors::{Error, Result}; use crate::message::MessageRead; @@ -367,6 +370,26 @@ impl BytesReader { }) } + /// Reads packed repeated field (ArrayVec) + #[cfg(feature = "with_arrayvec")] + pub fn read_packed_arrayvec<'a, A, F>( + &mut self, + bytes: &'a [u8], + mut read: F, + ) -> Result> + where + A: arrayvec::Array, + F: FnMut(&mut BytesReader, &'a [u8]) -> Result<::Item>, + { + self.read_len_varint(bytes, |r, b| { + let mut v = arrayvec::ArrayVec::::new(); + while !r.is_eof() { + v.push(read(r, b)?); + } + Ok(v) + }) + } + /// Reads packed repeated field where M can directly be transmutted from raw bytes /// /// Note: packed field are stored as a variable length chunk of data, while regular repeated diff --git a/quick-protobuf/tests/rust_protobuf/v3/basic.rs b/quick-protobuf/tests/rust_protobuf/v3/basic.rs new file mode 100644 index 00000000..b0f2bd47 --- /dev/null +++ b/quick-protobuf/tests/rust_protobuf/v3/basic.rs @@ -0,0 +1,869 @@ +// Automatically generated rust module for 'test_basic_pb.proto' file + +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(non_camel_case_types)] +#![allow(unused_imports)] +#![allow(unknown_lints)] +#![allow(clippy)] +#![cfg_attr(rustfmt, rustfmt_skip)] + + +use std::io::Write; +use std::borrow::Cow; +use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, Result}; +use quick_protobuf::sizeofs::*; +use super::*; + +#[derive(Debug, PartialEq, Eq, Clone, Copy)] +pub enum TestEnumDescriptor { + UNKNOWN = 0, + RED = 1, + BLUE = 2, + GREEN = 3, +} + +impl Default for TestEnumDescriptor { + fn default() -> Self { + TestEnumDescriptor::UNKNOWN + } +} + +impl From for TestEnumDescriptor { + fn from(i: i32) -> Self { + match i { + 0 => TestEnumDescriptor::UNKNOWN, + 1 => TestEnumDescriptor::RED, + 2 => TestEnumDescriptor::BLUE, + 3 => TestEnumDescriptor::GREEN, + _ => Self::default(), + } + } +} + +impl<'a> From<&'a str> for TestEnumDescriptor { + fn from(s: &'a str) -> Self { + match s { + "UNKNOWN" => TestEnumDescriptor::UNKNOWN, + "RED" => TestEnumDescriptor::RED, + "BLUE" => TestEnumDescriptor::BLUE, + "GREEN" => TestEnumDescriptor::GREEN, + _ => Self::default(), + } + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct Test1 { + pub a: i32, +} + +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.a = r.read_int32(bytes)?, + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl MessageWrite for Test1 { + fn get_size(&self) -> usize { + 0 + + if self.a == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.a) as u64) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if self.a != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.a))?; } + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct Test2<'a> { + pub b: Cow<'a, str>, +} + +impl<'a> MessageRead<'a> for Test2<'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(18) => msg.b = r.read_string(bytes).map(Cow::Borrowed)?, + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl<'a> MessageWrite for Test2<'a> { + fn get_size(&self) -> usize { + 0 + + if self.b == "" { 0 } else { 1 + sizeof_len((&self.b).len()) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if self.b != "" { w.write_with_tag(18, |w| w.write_string(&**&self.b))?; } + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct Test3 { + pub c: Option, +} + +impl<'a> MessageRead<'a> for Test3 { + 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(26) => msg.c = Some(r.read_message::(bytes)?), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl MessageWrite for Test3 { + fn get_size(&self) -> usize { + 0 + + self.c.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if let Some(ref s) = self.c { w.write_with_tag(26, |w| w.write_message(s))?; } + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct Test4 { + pub d: Vec, +} + +impl<'a> MessageRead<'a> for Test4 { + 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(34) => msg.d = 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 MessageWrite for Test4 { + fn get_size(&self) -> usize { + 0 + + if self.d.is_empty() { 0 } else { 1 + sizeof_len(self.d.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + w.write_packed_with_tag(34, &self.d, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?; + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestPackedUnpacked { + pub unpacked: Vec, + pub packed: Vec, +} + +impl<'a> MessageRead<'a> for TestPackedUnpacked { + 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(32) => msg.unpacked.push(r.read_int32(bytes)?), + Ok(42) => msg.packed = 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 MessageWrite for TestPackedUnpacked { + fn get_size(&self) -> usize { + 0 + + self.unpacked.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() + + if self.packed.is_empty() { 0 } else { 1 + sizeof_len(self.packed.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + for s in &self.unpacked { w.write_with_tag(32, |w| w.write_int32(*s))?; } + w.write_packed_with_tag(42, &self.packed, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?; + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestEmpty { + pub foo: i32, +} + +impl<'a> MessageRead<'a> for TestEmpty { + 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(80) => msg.foo = r.read_int32(bytes)?, + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl MessageWrite for TestEmpty { + fn get_size(&self) -> usize { + 0 + + if self.foo == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.foo) as u64) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if self.foo != 0i32 { w.write_with_tag(80, |w| w.write_int32(*&self.foo))?; } + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct Test { + pub b: bool, +} + +impl<'a> MessageRead<'a> for Test { + 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(40) => msg.b = r.read_bool(bytes)?, + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl MessageWrite for Test { + fn get_size(&self) -> usize { + 0 + + if self.b == false { 0 } else { 1 + sizeof_varint(*(&self.b) as u64) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if self.b != false { w.write_with_tag(40, |w| w.write_bool(*&self.b))?; } + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestUnknownFields { + pub a: i32, +} + +impl<'a> MessageRead<'a> for TestUnknownFields { + 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.a = r.read_int32(bytes)?, + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl MessageWrite for TestUnknownFields { + fn get_size(&self) -> usize { + 0 + + if self.a == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.a) as u64) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if self.a != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.a))?; } + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestSelfReference { + pub r1: Option>, + pub r2: Option>, +} + +impl<'a> MessageRead<'a> for TestSelfReference { + 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.r1 = Some(Box::new(r.read_message::(bytes)?)), + Ok(18) => msg.r2 = Some(Box::new(r.read_message::(bytes)?)), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl MessageWrite for TestSelfReference { + fn get_size(&self) -> usize { + 0 + + self.r1.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) + + self.r2.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if let Some(ref s) = self.r1 { w.write_with_tag(10, |w| w.write_message(&**s))?; } + if let Some(ref s) = self.r2 { w.write_with_tag(18, |w| w.write_message(&**s))?; } + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestDefaultInstanceField<'a> { + pub s: Cow<'a, str>, +} + +impl<'a> MessageRead<'a> for TestDefaultInstanceField<'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.s = r.read_string(bytes).map(Cow::Borrowed)?, + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl<'a> MessageWrite for TestDefaultInstanceField<'a> { + fn get_size(&self) -> usize { + 0 + + if self.s == "" { 0 } else { 1 + sizeof_len((&self.s).len()) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if self.s != "" { w.write_with_tag(10, |w| w.write_string(&**&self.s))?; } + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestDefaultInstance<'a> { + pub field: Option>, +} + +impl<'a> MessageRead<'a> for TestDefaultInstance<'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.field = Some(r.read_message::(bytes)?), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl<'a> MessageWrite for TestDefaultInstance<'a> { + fn get_size(&self) -> usize { + 0 + + self.field.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if let Some(ref s) = self.field { w.write_with_tag(10, |w| w.write_message(s))?; } + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestDescriptor { + pub stuff: i32, +} + +impl<'a> MessageRead<'a> for TestDescriptor { + 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(80) => msg.stuff = r.read_int32(bytes)?, + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl MessageWrite for TestDescriptor { + fn get_size(&self) -> usize { + 0 + + if self.stuff == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.stuff) as u64) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if self.stuff != 0i32 { w.write_with_tag(80, |w| w.write_int32(*&self.stuff))?; } + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestTypesSingular<'a> { + pub double_field: f64, + pub float_field: f32, + pub int32_field: i32, + pub int64_field: i64, + pub uint32_field: u32, + pub uint64_field: u64, + pub sint32_field: i32, + pub sint64_field: i64, + pub fixed32_field: u32, + pub fixed64_field: u64, + pub sfixed32_field: i32, + pub sfixed64_field: i64, + pub bool_field: bool, + pub string_field: Cow<'a, str>, + pub bytes_field: Cow<'a, [u8]>, + pub enum_field: basic::TestEnumDescriptor, +} + +impl<'a> MessageRead<'a> for TestTypesSingular<'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(9) => msg.double_field = r.read_double(bytes)?, + Ok(21) => msg.float_field = r.read_float(bytes)?, + Ok(24) => msg.int32_field = r.read_int32(bytes)?, + Ok(32) => msg.int64_field = r.read_int64(bytes)?, + Ok(40) => msg.uint32_field = r.read_uint32(bytes)?, + Ok(48) => msg.uint64_field = r.read_uint64(bytes)?, + Ok(56) => msg.sint32_field = r.read_sint32(bytes)?, + Ok(64) => msg.sint64_field = r.read_sint64(bytes)?, + Ok(77) => msg.fixed32_field = r.read_fixed32(bytes)?, + Ok(81) => msg.fixed64_field = r.read_fixed64(bytes)?, + Ok(93) => msg.sfixed32_field = r.read_sfixed32(bytes)?, + Ok(97) => msg.sfixed64_field = r.read_sfixed64(bytes)?, + Ok(104) => msg.bool_field = r.read_bool(bytes)?, + Ok(114) => msg.string_field = r.read_string(bytes).map(Cow::Borrowed)?, + Ok(122) => msg.bytes_field = r.read_bytes(bytes).map(Cow::Borrowed)?, + Ok(128) => msg.enum_field = r.read_enum(bytes)?, + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl<'a> MessageWrite for TestTypesSingular<'a> { + fn get_size(&self) -> usize { + 0 + + if self.double_field == 0f64 { 0 } else { 1 + 8 } + + if self.float_field == 0f32 { 0 } else { 1 + 4 } + + if self.int32_field == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.int32_field) as u64) } + + if self.int64_field == 0i64 { 0 } else { 1 + sizeof_varint(*(&self.int64_field) as u64) } + + if self.uint32_field == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.uint32_field) as u64) } + + if self.uint64_field == 0u64 { 0 } else { 1 + sizeof_varint(*(&self.uint64_field) as u64) } + + if self.sint32_field == 0i32 { 0 } else { 1 + sizeof_sint32(*(&self.sint32_field)) } + + if self.sint64_field == 0i64 { 0 } else { 1 + sizeof_sint64(*(&self.sint64_field)) } + + if self.fixed32_field == 0u32 { 0 } else { 1 + 4 } + + if self.fixed64_field == 0u64 { 0 } else { 1 + 8 } + + if self.sfixed32_field == 0i32 { 0 } else { 1 + 4 } + + if self.sfixed64_field == 0i64 { 0 } else { 1 + 8 } + + if self.bool_field == false { 0 } else { 1 + sizeof_varint(*(&self.bool_field) as u64) } + + if self.string_field == "" { 0 } else { 1 + sizeof_len((&self.string_field).len()) } + + if self.bytes_field == Cow::Borrowed(b"") { 0 } else { 1 + sizeof_len((&self.bytes_field).len()) } + + if self.enum_field == basic::TestEnumDescriptor::UNKNOWN { 0 } else { 2 + sizeof_varint(*(&self.enum_field) as u64) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if self.double_field != 0f64 { w.write_with_tag(9, |w| w.write_double(*&self.double_field))?; } + if self.float_field != 0f32 { w.write_with_tag(21, |w| w.write_float(*&self.float_field))?; } + if self.int32_field != 0i32 { w.write_with_tag(24, |w| w.write_int32(*&self.int32_field))?; } + if self.int64_field != 0i64 { w.write_with_tag(32, |w| w.write_int64(*&self.int64_field))?; } + if self.uint32_field != 0u32 { w.write_with_tag(40, |w| w.write_uint32(*&self.uint32_field))?; } + if self.uint64_field != 0u64 { w.write_with_tag(48, |w| w.write_uint64(*&self.uint64_field))?; } + if self.sint32_field != 0i32 { w.write_with_tag(56, |w| w.write_sint32(*&self.sint32_field))?; } + if self.sint64_field != 0i64 { w.write_with_tag(64, |w| w.write_sint64(*&self.sint64_field))?; } + if self.fixed32_field != 0u32 { w.write_with_tag(77, |w| w.write_fixed32(*&self.fixed32_field))?; } + if self.fixed64_field != 0u64 { w.write_with_tag(81, |w| w.write_fixed64(*&self.fixed64_field))?; } + if self.sfixed32_field != 0i32 { w.write_with_tag(93, |w| w.write_sfixed32(*&self.sfixed32_field))?; } + if self.sfixed64_field != 0i64 { w.write_with_tag(97, |w| w.write_sfixed64(*&self.sfixed64_field))?; } + if self.bool_field != false { w.write_with_tag(104, |w| w.write_bool(*&self.bool_field))?; } + if self.string_field != "" { w.write_with_tag(114, |w| w.write_string(&**&self.string_field))?; } + if self.bytes_field != Cow::Borrowed(b"") { w.write_with_tag(122, |w| w.write_bytes(&**&self.bytes_field))?; } + if self.enum_field != basic::TestEnumDescriptor::UNKNOWN { w.write_with_tag(128, |w| w.write_enum(*&self.enum_field as i32))?; } + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestTypesRepeated<'a> { + pub double_field: Vec, + pub float_field: Vec, + pub int32_field: Vec, + pub int64_field: Vec, + pub uint32_field: Vec, + pub uint64_field: Vec, + pub sint32_field: Vec, + pub sint64_field: Vec, + pub fixed32_field: Vec, + pub fixed64_field: Vec, + pub sfixed32_field: Vec, + pub sfixed64_field: Vec, + pub bool_field: Vec, + pub string_field: Vec>, + pub bytes_field: Vec>, + pub enum_field: Vec, +} + +impl<'a> MessageRead<'a> for TestTypesRepeated<'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(9) => msg.double_field.push(r.read_double(bytes)?), + Ok(21) => msg.float_field.push(r.read_float(bytes)?), + Ok(24) => msg.int32_field.push(r.read_int32(bytes)?), + Ok(32) => msg.int64_field.push(r.read_int64(bytes)?), + Ok(40) => msg.uint32_field.push(r.read_uint32(bytes)?), + Ok(48) => msg.uint64_field.push(r.read_uint64(bytes)?), + Ok(56) => msg.sint32_field.push(r.read_sint32(bytes)?), + Ok(64) => msg.sint64_field.push(r.read_sint64(bytes)?), + Ok(77) => msg.fixed32_field.push(r.read_fixed32(bytes)?), + Ok(81) => msg.fixed64_field.push(r.read_fixed64(bytes)?), + Ok(93) => msg.sfixed32_field.push(r.read_sfixed32(bytes)?), + Ok(97) => msg.sfixed64_field.push(r.read_sfixed64(bytes)?), + Ok(104) => msg.bool_field.push(r.read_bool(bytes)?), + Ok(114) => msg.string_field.push(r.read_string(bytes).map(Cow::Borrowed)?), + Ok(122) => msg.bytes_field.push(r.read_bytes(bytes).map(Cow::Borrowed)?), + Ok(128) => msg.enum_field.push(r.read_enum(bytes)?), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl<'a> MessageWrite for TestTypesRepeated<'a> { + fn get_size(&self) -> usize { + 0 + + (1 + 8) * self.double_field.len() + + (1 + 4) * self.float_field.len() + + self.int32_field.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() + + self.int64_field.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() + + self.uint32_field.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() + + self.uint64_field.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() + + self.sint32_field.iter().map(|s| 1 + sizeof_sint32(*(s))).sum::() + + self.sint64_field.iter().map(|s| 1 + sizeof_sint64(*(s))).sum::() + + (1 + 4) * self.fixed32_field.len() + + (1 + 8) * self.fixed64_field.len() + + (1 + 4) * self.sfixed32_field.len() + + (1 + 8) * self.sfixed64_field.len() + + self.bool_field.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() + + self.string_field.iter().map(|s| 1 + sizeof_len((s).len())).sum::() + + self.bytes_field.iter().map(|s| 1 + sizeof_len((s).len())).sum::() + + self.enum_field.iter().map(|s| 2 + sizeof_varint(*(s) as u64)).sum::() + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + for s in &self.double_field { w.write_with_tag(9, |w| w.write_double(*s))?; } + for s in &self.float_field { w.write_with_tag(21, |w| w.write_float(*s))?; } + for s in &self.int32_field { w.write_with_tag(24, |w| w.write_int32(*s))?; } + for s in &self.int64_field { w.write_with_tag(32, |w| w.write_int64(*s))?; } + for s in &self.uint32_field { w.write_with_tag(40, |w| w.write_uint32(*s))?; } + for s in &self.uint64_field { w.write_with_tag(48, |w| w.write_uint64(*s))?; } + for s in &self.sint32_field { w.write_with_tag(56, |w| w.write_sint32(*s))?; } + for s in &self.sint64_field { w.write_with_tag(64, |w| w.write_sint64(*s))?; } + for s in &self.fixed32_field { w.write_with_tag(77, |w| w.write_fixed32(*s))?; } + for s in &self.fixed64_field { w.write_with_tag(81, |w| w.write_fixed64(*s))?; } + for s in &self.sfixed32_field { w.write_with_tag(93, |w| w.write_sfixed32(*s))?; } + for s in &self.sfixed64_field { w.write_with_tag(97, |w| w.write_sfixed64(*s))?; } + for s in &self.bool_field { w.write_with_tag(104, |w| w.write_bool(*s))?; } + for s in &self.string_field { w.write_with_tag(114, |w| w.write_string(&**s))?; } + for s in &self.bytes_field { w.write_with_tag(122, |w| w.write_bytes(&**s))?; } + for s in &self.enum_field { w.write_with_tag(128, |w| w.write_enum(*s as i32))?; } + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestTypesRepeatedArrayVec { + pub double_field: arrayvec::ArrayVec<[f64; 10]>, + pub float_field: arrayvec::ArrayVec<[f32; 10]>, + pub int32_field: arrayvec::ArrayVec<[i32; 10]>, + pub int64_field: arrayvec::ArrayVec<[i64; 10]>, + pub uint32_field: arrayvec::ArrayVec<[u32; 10]>, + pub uint64_field: arrayvec::ArrayVec<[u64; 10]>, + pub sint32_field: arrayvec::ArrayVec<[i32; 10]>, + pub sint64_field: arrayvec::ArrayVec<[i64; 10]>, + pub fixed32_field: arrayvec::ArrayVec<[u32; 10]>, + pub fixed64_field: arrayvec::ArrayVec<[u64; 10]>, + pub sfixed32_field: arrayvec::ArrayVec<[i32; 10]>, + pub sfixed64_field: arrayvec::ArrayVec<[i64; 10]>, + pub bool_field: arrayvec::ArrayVec<[bool; 10]>, + pub enum_field: arrayvec::ArrayVec<[basic::TestEnumDescriptor; 10]>, +} + +impl<'a> MessageRead<'a> for TestTypesRepeatedArrayVec { + 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.double_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_double(bytes)?))?, + Ok(18) => msg.float_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_float(bytes)?))?, + Ok(26) => msg.int32_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_int32(bytes)?))?, + Ok(34) => msg.int64_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_int64(bytes)?))?, + Ok(42) => msg.uint32_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_uint32(bytes)?))?, + Ok(50) => msg.uint64_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_uint64(bytes)?))?, + Ok(58) => msg.sint32_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_sint32(bytes)?))?, + Ok(66) => msg.sint64_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_sint64(bytes)?))?, + Ok(74) => msg.fixed32_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_fixed32(bytes)?))?, + Ok(82) => msg.fixed64_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_fixed64(bytes)?))?, + Ok(90) => msg.sfixed32_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_sfixed32(bytes)?))?, + Ok(98) => msg.sfixed64_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_sfixed64(bytes)?))?, + Ok(106) => msg.bool_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_bool(bytes)?))?, + Ok(114) => msg.enum_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_enum(bytes)?))?, + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl MessageWrite for TestTypesRepeatedArrayVec { + fn get_size(&self) -> usize { + 0 + + if self.double_field.is_empty() { 0 } else { 1 + sizeof_len(self.double_field.len() * 8) } + + if self.float_field.is_empty() { 0 } else { 1 + sizeof_len(self.float_field.len() * 4) } + + if self.int32_field.is_empty() { 0 } else { 1 + sizeof_len(self.int32_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + + if self.int64_field.is_empty() { 0 } else { 1 + sizeof_len(self.int64_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + + if self.uint32_field.is_empty() { 0 } else { 1 + sizeof_len(self.uint32_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + + if self.uint64_field.is_empty() { 0 } else { 1 + sizeof_len(self.uint64_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + + if self.sint32_field.is_empty() { 0 } else { 1 + sizeof_len(self.sint32_field.iter().map(|s| sizeof_sint32(*(s))).sum::()) } + + if self.sint64_field.is_empty() { 0 } else { 1 + sizeof_len(self.sint64_field.iter().map(|s| sizeof_sint64(*(s))).sum::()) } + + if self.fixed32_field.is_empty() { 0 } else { 1 + sizeof_len(self.fixed32_field.len() * 4) } + + if self.fixed64_field.is_empty() { 0 } else { 1 + sizeof_len(self.fixed64_field.len() * 8) } + + if self.sfixed32_field.is_empty() { 0 } else { 1 + sizeof_len(self.sfixed32_field.len() * 4) } + + if self.sfixed64_field.is_empty() { 0 } else { 1 + sizeof_len(self.sfixed64_field.len() * 8) } + + if self.bool_field.is_empty() { 0 } else { 1 + sizeof_len(self.bool_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + + if self.enum_field.is_empty() { 0 } else { 1 + sizeof_len(self.enum_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + w.write_packed_fixed_with_tag(10, &self.double_field)?; + w.write_packed_fixed_with_tag(18, &self.float_field)?; + w.write_packed_with_tag(26, &self.int32_field, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?; + w.write_packed_with_tag(34, &self.int64_field, |w, m| w.write_int64(*m), &|m| sizeof_varint(*(m) as u64))?; + w.write_packed_with_tag(42, &self.uint32_field, |w, m| w.write_uint32(*m), &|m| sizeof_varint(*(m) as u64))?; + w.write_packed_with_tag(50, &self.uint64_field, |w, m| w.write_uint64(*m), &|m| sizeof_varint(*(m) as u64))?; + w.write_packed_with_tag(58, &self.sint32_field, |w, m| w.write_sint32(*m), &|m| sizeof_sint32(*(m)))?; + w.write_packed_with_tag(66, &self.sint64_field, |w, m| w.write_sint64(*m), &|m| sizeof_sint64(*(m)))?; + w.write_packed_fixed_with_tag(74, &self.fixed32_field)?; + w.write_packed_fixed_with_tag(82, &self.fixed64_field)?; + w.write_packed_fixed_with_tag(90, &self.sfixed32_field)?; + w.write_packed_fixed_with_tag(98, &self.sfixed64_field)?; + w.write_packed_with_tag(106, &self.bool_field, |w, m| w.write_bool(*m), &|m| sizeof_varint(*(m) as u64))?; + w.write_packed_with_tag(114, &self.enum_field, |w, m| w.write_enum(*m as i32), &|m| sizeof_varint(*(m) as u64))?; + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestTypesRepeatedPacked<'a> { + pub double_field: Cow<'a, [f64]>, + pub float_field: Cow<'a, [f32]>, + pub int32_field: Vec, + pub int64_field: Vec, + pub uint32_field: Vec, + pub uint64_field: Vec, + pub sint32_field: Vec, + pub sint64_field: Vec, + pub fixed32_field: Cow<'a, [u32]>, + pub fixed64_field: Cow<'a, [u64]>, + pub sfixed32_field: Cow<'a, [i32]>, + pub sfixed64_field: Cow<'a, [i64]>, + pub bool_field: Vec, + pub string_field: Vec>, + pub bytes_field: Vec>, + pub enum_field: Vec, +} + +impl<'a> MessageRead<'a> for TestTypesRepeatedPacked<'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.double_field = r.read_packed_fixed(bytes)?.into(), + Ok(18) => msg.float_field = r.read_packed_fixed(bytes)?.into(), + Ok(26) => msg.int32_field = r.read_packed(bytes, |r, bytes| Ok(r.read_int32(bytes)?))?, + Ok(34) => msg.int64_field = r.read_packed(bytes, |r, bytes| Ok(r.read_int64(bytes)?))?, + Ok(42) => msg.uint32_field = r.read_packed(bytes, |r, bytes| Ok(r.read_uint32(bytes)?))?, + Ok(50) => msg.uint64_field = r.read_packed(bytes, |r, bytes| Ok(r.read_uint64(bytes)?))?, + Ok(58) => msg.sint32_field = r.read_packed(bytes, |r, bytes| Ok(r.read_sint32(bytes)?))?, + Ok(66) => msg.sint64_field = r.read_packed(bytes, |r, bytes| Ok(r.read_sint64(bytes)?))?, + Ok(74) => msg.fixed32_field = r.read_packed_fixed(bytes)?.into(), + Ok(82) => msg.fixed64_field = r.read_packed_fixed(bytes)?.into(), + Ok(90) => msg.sfixed32_field = r.read_packed_fixed(bytes)?.into(), + Ok(98) => msg.sfixed64_field = r.read_packed_fixed(bytes)?.into(), + Ok(106) => msg.bool_field = r.read_packed(bytes, |r, bytes| Ok(r.read_bool(bytes)?))?, + Ok(114) => msg.string_field.push(r.read_string(bytes).map(Cow::Borrowed)?), + Ok(122) => msg.bytes_field.push(r.read_bytes(bytes).map(Cow::Borrowed)?), + Ok(130) => msg.enum_field = r.read_packed(bytes, |r, bytes| Ok(r.read_enum(bytes)?))?, + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl<'a> MessageWrite for TestTypesRepeatedPacked<'a> { + fn get_size(&self) -> usize { + 0 + + if self.double_field.is_empty() { 0 } else { 1 + sizeof_len(self.double_field.len() * 8) } + + if self.float_field.is_empty() { 0 } else { 1 + sizeof_len(self.float_field.len() * 4) } + + if self.int32_field.is_empty() { 0 } else { 1 + sizeof_len(self.int32_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + + if self.int64_field.is_empty() { 0 } else { 1 + sizeof_len(self.int64_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + + if self.uint32_field.is_empty() { 0 } else { 1 + sizeof_len(self.uint32_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + + if self.uint64_field.is_empty() { 0 } else { 1 + sizeof_len(self.uint64_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + + if self.sint32_field.is_empty() { 0 } else { 1 + sizeof_len(self.sint32_field.iter().map(|s| sizeof_sint32(*(s))).sum::()) } + + if self.sint64_field.is_empty() { 0 } else { 1 + sizeof_len(self.sint64_field.iter().map(|s| sizeof_sint64(*(s))).sum::()) } + + if self.fixed32_field.is_empty() { 0 } else { 1 + sizeof_len(self.fixed32_field.len() * 4) } + + if self.fixed64_field.is_empty() { 0 } else { 1 + sizeof_len(self.fixed64_field.len() * 8) } + + if self.sfixed32_field.is_empty() { 0 } else { 1 + sizeof_len(self.sfixed32_field.len() * 4) } + + if self.sfixed64_field.is_empty() { 0 } else { 1 + sizeof_len(self.sfixed64_field.len() * 8) } + + if self.bool_field.is_empty() { 0 } else { 1 + sizeof_len(self.bool_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + + self.string_field.iter().map(|s| 1 + sizeof_len((s).len())).sum::() + + self.bytes_field.iter().map(|s| 1 + sizeof_len((s).len())).sum::() + + if self.enum_field.is_empty() { 0 } else { 2 + sizeof_len(self.enum_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + w.write_packed_fixed_with_tag(10, &self.double_field)?; + w.write_packed_fixed_with_tag(18, &self.float_field)?; + w.write_packed_with_tag(26, &self.int32_field, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?; + w.write_packed_with_tag(34, &self.int64_field, |w, m| w.write_int64(*m), &|m| sizeof_varint(*(m) as u64))?; + w.write_packed_with_tag(42, &self.uint32_field, |w, m| w.write_uint32(*m), &|m| sizeof_varint(*(m) as u64))?; + w.write_packed_with_tag(50, &self.uint64_field, |w, m| w.write_uint64(*m), &|m| sizeof_varint(*(m) as u64))?; + w.write_packed_with_tag(58, &self.sint32_field, |w, m| w.write_sint32(*m), &|m| sizeof_sint32(*(m)))?; + w.write_packed_with_tag(66, &self.sint64_field, |w, m| w.write_sint64(*m), &|m| sizeof_sint64(*(m)))?; + w.write_packed_fixed_with_tag(74, &self.fixed32_field)?; + w.write_packed_fixed_with_tag(82, &self.fixed64_field)?; + w.write_packed_fixed_with_tag(90, &self.sfixed32_field)?; + w.write_packed_fixed_with_tag(98, &self.sfixed64_field)?; + w.write_packed_with_tag(106, &self.bool_field, |w, m| w.write_bool(*m), &|m| sizeof_varint(*(m) as u64))?; + for s in &self.string_field { w.write_with_tag(114, |w| w.write_string(&**s))?; } + for s in &self.bytes_field { w.write_with_tag(122, |w| w.write_bytes(&**s))?; } + w.write_packed_with_tag(130, &self.enum_field, |w, m| w.write_enum(*m as i32), &|m| sizeof_varint(*(m) as u64))?; + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestInvalidTag { } + +impl<'a> MessageRead<'a> for TestInvalidTag { + fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result { + r.read_to_end(); + Ok(Self::default()) + } +} + +impl MessageWrite for TestInvalidTag { } + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestTruncated<'a> { + pub ints: Cow<'a, [u32]>, +} + +impl<'a> MessageRead<'a> for TestTruncated<'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(18) => msg.ints = r.read_packed_fixed(bytes)?.into(), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl<'a> MessageWrite for TestTruncated<'a> { + fn get_size(&self) -> usize { + 0 + + if self.ints.is_empty() { 0 } else { 1 + sizeof_len(self.ints.len() * 4) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + w.write_packed_fixed_with_tag(18, &self.ints)?; + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestBugSint { + pub s32: i32, + pub s64: i64, +} + +impl<'a> MessageRead<'a> for TestBugSint { + 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.s32 = r.read_sint32(bytes)?, + Ok(16) => msg.s64 = r.read_sint64(bytes)?, + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl MessageWrite for TestBugSint { + fn get_size(&self) -> usize { + 0 + + if self.s32 == 0i32 { 0 } else { 1 + sizeof_sint32(*(&self.s32)) } + + if self.s64 == 0i64 { 0 } else { 1 + sizeof_sint64(*(&self.s64)) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if self.s32 != 0i32 { w.write_with_tag(8, |w| w.write_sint32(*&self.s32))?; } + if self.s64 != 0i64 { w.write_with_tag(16, |w| w.write_sint64(*&self.s64))?; } + Ok(()) + } +} + diff --git a/quick-protobuf/tests/rust_protobuf/v3/test_basic.rs b/quick-protobuf/tests/rust_protobuf/v3/test_basic.rs index cf032f5d..1f8bb665 100644 --- a/quick-protobuf/tests/rust_protobuf/v3/test_basic.rs +++ b/quick-protobuf/tests/rust_protobuf/v3/test_basic.rs @@ -123,6 +123,47 @@ fn test_types_repeated() { message.enum_field = vec![TestEnumDescriptor::BLUE, TestEnumDescriptor::GREEN]; test_serialize_deserialize_length_delimited!(&message, TestTypesRepeated); } +#[test] +fn test_types_repeated_arrayvec() { + let mut message = TestTypesRepeatedArrayVec::default(); + message.double_field.push(19f64); + message.double_field.push(20f64); + + message.float_field.push(20f32); + + message.int32_field.push(21i32); + message.int32_field.push(-22); + message.int32_field.push(23); + + message.int64_field.push(22i64); + + message.uint32_field.push(23u32); + message.uint32_field.push(23); + + message.uint64_field.push(24u64); + + message.sint32_field.push(25i32); + + message.sint64_field.push(26i64); + message.sint64_field.push(-27); + + message.fixed32_field.push(27u32); + + message.fixed64_field.push(28u64); + + message.sfixed32_field.push(29i32); + message.sfixed32_field.push(-30); + + message.sfixed64_field.push(30i64); + + message.bool_field.push(true); + message.bool_field.push(true); + + message.enum_field.push(TestEnumDescriptor::BLUE); + message.enum_field.push(TestEnumDescriptor::GREEN); + + test_serialize_deserialize_length_delimited!(&message, TestTypesRepeatedArrayVec); +} #[test] fn test_types_repeated_packed() { 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 c0b04227..97c59914 100644 --- a/quick-protobuf/tests/rust_protobuf/v3/test_basic_pb.proto +++ b/quick-protobuf/tests/rust_protobuf/v3/test_basic_pb.proto @@ -99,6 +99,23 @@ message TestTypesRepeated { repeated TestEnumDescriptor enum_field = 16 [packed=false]; } +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]; +} + message TestTypesRepeatedPacked { repeated double double_field = 1 [packed=true]; repeated float float_field = 2 [packed=true]; From 8ca9750d86ca88562767689b7cb676e767a134b4 Mon Sep 17 00:00:00 2001 From: Russell Mull Date: Fri, 30 Aug 2019 10:32:25 -0700 Subject: [PATCH 02/30] Introduce WriterBackend trait, eliminating hard dep on std::io This replaces all public uses of the Writer trait with the new WriterBackend, which defines only the interaction points which are actually used. It also introduces the BytesWriter struct as a new implementation of WriterBackend that will work in no_std, along with the serialize_into_slice convenience fn. This is technically a breaking change, as it will require stubs to be regenerated. --- pb-rs/src/types.rs | 5 +- perftest/src/perftest_data.rs | 154 ++++++++---- quick-protobuf/examples/pb_rs/a/b.rs | 5 +- quick-protobuf/examples/pb_rs/data_types.rs | 13 +- quick-protobuf/examples/pb_rs_v3/a/b.rs | 5 +- .../examples/pb_rs_v3/data_types.rs | 15 +- quick-protobuf/examples/pb_rs_v3/owned/a/b.rs | 5 +- .../examples/pb_rs_v3/owned/data_types.rs | 15 +- quick-protobuf/src/errors.rs | 8 + quick-protobuf/src/lib.rs | 4 +- quick-protobuf/src/message.rs | 4 +- quick-protobuf/src/reader.rs | 12 +- quick-protobuf/src/writer.rs | 223 ++++++++++++++++-- .../tests/rust_protobuf/v3/basic.rs | 39 ++- quick-protobuf/tests/write_read.rs | 24 +- 15 files changed, 397 insertions(+), 134 deletions(-) diff --git a/pb-rs/src/types.rs b/pb-rs/src/types.rs index c3f07cd0..ffc1fb17 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -1158,7 +1158,7 @@ impl Message { fn write_write_message(&self, w: &mut W, desc: &FileDescriptor) -> Result<()> { writeln!( w, - " fn write_message(&self, w: &mut Writer) -> Result<()> {{" + " fn write_message(&self, w: &mut Writer) -> Result<()> {{" )?; for f in self.fields.iter().filter(|f| !f.deprecated) { f.write_write(w, desc)?; @@ -2168,7 +2168,6 @@ impl FileDescriptor { )?; return Ok(()); } - writeln!(w, "use std::io::Write;")?; if self .messages .iter() @@ -2185,7 +2184,7 @@ impl FileDescriptor { } writeln!( w, - "use quick_protobuf::{{MessageRead, MessageWrite, BytesReader, Writer, Result}};" + "use quick_protobuf::{{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}};" )?; if self.owned { diff --git a/perftest/src/perftest_data.rs b/perftest/src/perftest_data.rs index 8c08b1c4..58ecf1c9 100644 --- a/perftest/src/perftest_data.rs +++ b/perftest/src/perftest_data.rs @@ -9,9 +9,9 @@ #![cfg_attr(rustfmt, rustfmt_skip)] -use std::io::Write; use std::borrow::Cow; -use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, Result}; +use std::collections::HashMap; +use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; use quick_protobuf::sizeofs::*; use super::*; @@ -40,7 +40,7 @@ impl MessageWrite for Test1 { + self.value.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64)) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + 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(()) } @@ -71,7 +71,7 @@ impl MessageWrite for TestRepeatedBool { + self.values.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { for s in &self.values { w.write_with_tag(8, |w| w.write_bool(*s))?; } Ok(()) } @@ -102,17 +102,48 @@ impl MessageWrite for TestRepeatedPackedInt32 { + if self.values.is_empty() { 0 } else { 1 + sizeof_len(self.values.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + 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(()) } } +#[derive(Debug, Default, PartialEq, Clone)] +pub struct TestRepeatedPackedFloat<'a> { + pub values: Cow<'a, [f32]>, +} + +impl<'a> MessageRead<'a> for TestRepeatedPackedFloat<'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.values = r.read_packed_fixed(bytes)?.into(), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl<'a> MessageWrite for TestRepeatedPackedFloat<'a> { + fn get_size(&self) -> usize { + 0 + + if self.values.is_empty() { 0 } else { 1 + sizeof_len(self.values.len() * 4) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + w.write_packed_fixed_with_tag(10, &self.values)?; + Ok(()) + } +} + #[derive(Debug, Default, PartialEq, Clone)] pub struct TestRepeatedMessages { - pub messages1: Vec, - pub messages2: Vec, - pub messages3: Vec, + pub messages1: Vec, + pub messages2: Vec, + pub messages3: Vec, } impl<'a> MessageRead<'a> for TestRepeatedMessages { @@ -120,9 +151,9 @@ impl<'a> MessageRead<'a> for TestRepeatedMessages { 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(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), } @@ -139,7 +170,7 @@ impl MessageWrite for TestRepeatedMessages { + self.messages3.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() } - fn write_message(&self, w: &mut Writer) -> Result<()> { + 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))?; } @@ -149,9 +180,9 @@ impl MessageWrite for TestRepeatedMessages { #[derive(Debug, Default, PartialEq, Clone)] pub struct TestOptionalMessages { - pub message1: Option>, - pub message2: Option>, - pub message3: Option>, + pub message1: Option>, + pub message2: Option>, + pub message3: Option>, } impl<'a> MessageRead<'a> for TestOptionalMessages { @@ -159,9 +190,9 @@ impl<'a> MessageRead<'a> for TestOptionalMessages { 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(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), } @@ -178,7 +209,7 @@ impl MessageWrite for TestOptionalMessages { + self.message3.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + 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))?; } @@ -217,7 +248,7 @@ impl<'a> MessageWrite for TestStrings<'a> { + self.s3.as_ref().map_or(0, |m| 1 + sizeof_len((m).len())) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + 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))?; } @@ -250,22 +281,58 @@ impl<'a> MessageWrite for TestBytes<'a> { + self.b1.as_ref().map_or(0, |m| 1 + sizeof_len((m).len())) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + 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(Debug, Default, PartialEq, Clone)] +pub struct TestMap<'a> { + pub value: HashMap, u32>, +} + +impl<'a> MessageRead<'a> for TestMap<'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) => { + let (key, value) = r.read_map(bytes, |r, bytes| Ok(r.read_string(bytes).map(Cow::Borrowed)?), |r, bytes| Ok(r.read_uint32(bytes)?))?; + msg.value.insert(key, value); + } + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl<'a> MessageWrite for TestMap<'a> { + fn get_size(&self) -> usize { + 0 + + self.value.iter().map(|(k, v)| 1 + sizeof_len(2 + sizeof_len((k).len()) + sizeof_varint(*(v) as u64))).sum::() + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + for (k, v) in self.value.iter() { w.write_with_tag(10, |w| w.write_map(2 + sizeof_len((k).len()) + sizeof_varint(*(v) as u64), 10, |w| w.write_string(&**k), 16, |w| w.write_uint32(*v)))?; } + Ok(()) + } +} + #[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>, + 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_repeated_packed_float: Vec>, + pub test_small_bytearrays: Vec>, + pub test_large_bytearrays: Vec>, + pub test_map: Vec>, } impl<'a> MessageRead<'a> for PerftestData<'a> { @@ -273,14 +340,16 @@ impl<'a> MessageRead<'a> for PerftestData<'a> { 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(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_repeated_packed_float.push(r.read_message::(bytes)?), + Ok(66) => msg.test_small_bytearrays.push(r.read_message::(bytes)?), + Ok(74) => msg.test_large_bytearrays.push(r.read_message::(bytes)?), + Ok(82) => msg.test_map.push(r.read_message::(bytes)?), Ok(t) => { r.read_unknown(bytes, t)?; } Err(e) => return Err(e), } @@ -298,21 +367,24 @@ impl<'a> MessageWrite for PerftestData<'a> { + 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_repeated_packed_float.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::() + + self.test_map.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() } - fn write_message(&self, w: &mut Writer) -> Result<()> { + 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))?; } + for s in &self.test_repeated_packed_float { w.write_with_tag(58, |w| w.write_message(s))?; } + for s in &self.test_small_bytearrays { w.write_with_tag(66, |w| w.write_message(s))?; } + for s in &self.test_large_bytearrays { w.write_with_tag(74, |w| w.write_message(s))?; } + for s in &self.test_map { w.write_with_tag(82, |w| w.write_message(s))?; } Ok(()) } } - diff --git a/quick-protobuf/examples/pb_rs/a/b.rs b/quick-protobuf/examples/pb_rs/a/b.rs index 146969d7..bcb32905 100644 --- a/quick-protobuf/examples/pb_rs/a/b.rs +++ b/quick-protobuf/examples/pb_rs/a/b.rs @@ -9,8 +9,7 @@ #![cfg_attr(rustfmt, rustfmt_skip)] -use std::io::Write; -use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, Result}; +use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; use quick_protobuf::sizeofs::*; use super::super::*; @@ -39,7 +38,7 @@ impl MessageWrite for ImportedMessage { + self.i.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64)) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if let Some(ref s) = self.i { w.write_with_tag(8, |w| w.write_bool(*s))?; } Ok(()) } diff --git a/quick-protobuf/examples/pb_rs/data_types.rs b/quick-protobuf/examples/pb_rs/data_types.rs index bbd88014..8a3fd1ed 100644 --- a/quick-protobuf/examples/pb_rs/data_types.rs +++ b/quick-protobuf/examples/pb_rs/data_types.rs @@ -9,10 +9,9 @@ #![cfg_attr(rustfmt, rustfmt_skip)] -use std::io::Write; use std::borrow::Cow; use std::collections::HashMap; -use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, Result}; +use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; use quick_protobuf::sizeofs::*; use super::*; @@ -73,7 +72,7 @@ impl MessageWrite for BarMessage { + 1 + sizeof_varint(*(&self.b_required_int32) as u64) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { w.write_with_tag(8, |w| w.write_int32(*&self.b_required_int32))?; Ok(()) } @@ -195,7 +194,7 @@ impl<'a> MessageWrite for FooMessage<'a> { mod_FooMessage::OneOftest_oneof::None => 0, } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if let Some(ref s) = self.f_int32 { w.write_with_tag(8, |w| w.write_int32(*s))?; } if let Some(ref s) = self.f_int64 { w.write_with_tag(16, |w| w.write_int64(*s))?; } if let Some(ref s) = self.f_uint32 { w.write_with_tag(24, |w| w.write_uint32(*s))?; } @@ -275,7 +274,7 @@ impl MessageWrite for BazMessage { + self.nested.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if let Some(ref s) = self.nested { w.write_with_tag(10, |w| w.write_message(s))?; } Ok(()) } @@ -310,7 +309,7 @@ impl MessageWrite for Nested { + 1 + sizeof_len((&self.f_nested).get_size()) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { w.write_with_tag(10, |w| w.write_message(&self.f_nested))?; Ok(()) } @@ -345,7 +344,7 @@ impl MessageWrite for NestedMessage { + 1 + sizeof_varint(*(&self.f_nested) as u64) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { w.write_with_tag(8, |w| w.write_int32(*&self.f_nested))?; Ok(()) } diff --git a/quick-protobuf/examples/pb_rs_v3/a/b.rs b/quick-protobuf/examples/pb_rs_v3/a/b.rs index 2d16e7af..a9812a8b 100644 --- a/quick-protobuf/examples/pb_rs_v3/a/b.rs +++ b/quick-protobuf/examples/pb_rs_v3/a/b.rs @@ -9,8 +9,7 @@ #![cfg_attr(rustfmt, rustfmt_skip)] -use std::io::Write; -use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, Result}; +use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; use quick_protobuf::sizeofs::*; use super::super::*; @@ -39,7 +38,7 @@ impl MessageWrite for ImportedMessage { + if self.i == false { 0 } else { 1 + sizeof_varint(*(&self.i) as u64) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.i != false { w.write_with_tag(8, |w| w.write_bool(*&self.i))?; } Ok(()) } diff --git a/quick-protobuf/examples/pb_rs_v3/data_types.rs b/quick-protobuf/examples/pb_rs_v3/data_types.rs index 1f73437e..5660cd09 100644 --- a/quick-protobuf/examples/pb_rs_v3/data_types.rs +++ b/quick-protobuf/examples/pb_rs_v3/data_types.rs @@ -9,10 +9,9 @@ #![cfg_attr(rustfmt, rustfmt_skip)] -use std::io::Write; use std::borrow::Cow; use std::collections::HashMap; -use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, Result}; +use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; use quick_protobuf::sizeofs::*; use super::*; @@ -73,7 +72,7 @@ impl MessageWrite for BarMessage { + if self.b_int32 == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.b_int32) as u64) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.b_int32 != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.b_int32))?; } Ok(()) } @@ -201,7 +200,7 @@ impl<'a> MessageWrite for FooMessage<'a> { mod_FooMessage::OneOftest_oneof::None => 0, } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.f_int32 != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.f_int32))?; } if self.f_int64 != 0i64 { w.write_with_tag(16, |w| w.write_int64(*&self.f_int64))?; } if self.f_uint32 != 0u32 { w.write_with_tag(24, |w| w.write_uint32(*&self.f_uint32))?; } @@ -289,7 +288,7 @@ impl<'a> MessageWrite for BazMessage<'a> { + if self.b_string == "" { 0 } else { 1 + sizeof_len((&self.b_string).len()) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if let Some(ref s) = self.nested { w.write_with_tag(10, |w| w.write_message(s))?; } if self.b_int64 != 0i64 { w.write_with_tag(16, |w| w.write_int64(*&self.b_int64))?; } if self.b_string != "" { w.write_with_tag(26, |w| w.write_string(&**&self.b_string))?; } @@ -326,7 +325,7 @@ impl MessageWrite for Nested { + self.f_nested.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if let Some(ref s) = self.f_nested { w.write_with_tag(10, |w| w.write_message(s))?; } Ok(()) } @@ -361,7 +360,7 @@ impl MessageWrite for NestedMessage { + if self.f_nested == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.f_nested) as u64) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.f_nested != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.f_nested))?; } Ok(()) } @@ -431,7 +430,7 @@ impl MessageWrite for RepeatedMessage { + self.bar_message.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { for s in &self.bar_message { w.write_with_tag(10, |w| w.write_message(s))?; } Ok(()) } diff --git a/quick-protobuf/examples/pb_rs_v3/owned/a/b.rs b/quick-protobuf/examples/pb_rs_v3/owned/a/b.rs index 6c922099..6b5b3507 100644 --- a/quick-protobuf/examples/pb_rs_v3/owned/a/b.rs +++ b/quick-protobuf/examples/pb_rs_v3/owned/a/b.rs @@ -9,8 +9,7 @@ #![cfg_attr(rustfmt, rustfmt_skip)] -use std::io::Write; -use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, Result}; +use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; use std::convert::TryFrom; use std::ops::Deref; use std::ops::DerefMut; @@ -42,7 +41,7 @@ impl MessageWrite for ImportedMessage { + if self.i == false { 0 } else { 1 + sizeof_varint(*(&self.i) as u64) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.i != false { w.write_with_tag(8, |w| w.write_bool(*&self.i))?; } Ok(()) } diff --git a/quick-protobuf/examples/pb_rs_v3/owned/data_types.rs b/quick-protobuf/examples/pb_rs_v3/owned/data_types.rs index adbfd6df..bd9a6619 100644 --- a/quick-protobuf/examples/pb_rs_v3/owned/data_types.rs +++ b/quick-protobuf/examples/pb_rs_v3/owned/data_types.rs @@ -9,10 +9,9 @@ #![cfg_attr(rustfmt, rustfmt_skip)] -use std::io::Write; use std::borrow::Cow; use std::collections::HashMap; -use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, Result}; +use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; use std::convert::TryFrom; use std::ops::Deref; use std::ops::DerefMut; @@ -76,7 +75,7 @@ impl MessageWrite for BarMessage { + if self.b_int32 == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.b_int32) as u64) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.b_int32 != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.b_int32))?; } Ok(()) } @@ -204,7 +203,7 @@ impl<'a> MessageWrite for FooMessage<'a> { mod_FooMessage::OneOftest_oneof::None => 0, } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.f_int32 != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.f_int32))?; } if self.f_int64 != 0i64 { w.write_with_tag(16, |w| w.write_int64(*&self.f_int64))?; } if self.f_uint32 != 0u32 { w.write_with_tag(24, |w| w.write_uint32(*&self.f_uint32))?; } @@ -376,7 +375,7 @@ impl<'a> MessageWrite for BazMessage<'a> { + if self.b_string == "" { 0 } else { 1 + sizeof_len((&self.b_string).len()) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if let Some(ref s) = self.nested { w.write_with_tag(10, |w| w.write_message(s))?; } if self.b_int64 != 0i64 { w.write_with_tag(16, |w| w.write_int64(*&self.b_int64))?; } if self.b_string != "" { w.write_with_tag(26, |w| w.write_string(&**&self.b_string))?; } @@ -497,7 +496,7 @@ impl MessageWrite for Nested { + self.f_nested.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if let Some(ref s) = self.f_nested { w.write_with_tag(10, |w| w.write_message(s))?; } Ok(()) } @@ -532,7 +531,7 @@ impl MessageWrite for NestedMessage { + if self.f_nested == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.f_nested) as u64) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.f_nested != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.f_nested))?; } Ok(()) } @@ -602,7 +601,7 @@ impl MessageWrite for RepeatedMessage { + self.bar_message.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { for s in &self.bar_message { w.write_with_tag(10, |w| w.write_message(s))?; } Ok(()) } diff --git a/quick-protobuf/src/errors.rs b/quick-protobuf/src/errors.rs index 95c1973d..84fedd2c 100644 --- a/quick-protobuf/src/errors.rs +++ b/quick-protobuf/src/errors.rs @@ -28,6 +28,14 @@ pub enum Error { /// Unexpected map tag #[fail(display = "Unexpected map tag: '{}', expecting 1 or 2", _0)] Map(u8), + + /// Out of data when reading from or writing to a byte buffer + #[fail(display = "Unexpected end of buffer")] + UnexpectedEndOfBuffer, + + /// The supplied output buffer is not large enough to serialize the message + #[fail(display = "Output buffer too small")] + OutputBufferTooSmall, } /// A wrapper for `Result` diff --git a/quick-protobuf/src/lib.rs b/quick-protobuf/src/lib.rs index 453d4742..2a5ca46c 100644 --- a/quick-protobuf/src/lib.rs +++ b/quick-protobuf/src/lib.rs @@ -17,5 +17,5 @@ pub mod writer; pub use crate::errors::{Error, Result}; pub use crate::message::{MessageRead, MessageWrite}; -pub use crate::reader::{deserialize_from_slice, BytesReader, Reader}; -pub use crate::writer::{serialize_into_vec, Writer}; +pub use crate::reader::{deserialize_from_slice, BytesReader}; +pub use crate::writer::{serialize_into_vec, serialize_into_slice, BytesWriter, Writer, WriterBackend}; diff --git a/quick-protobuf/src/message.rs b/quick-protobuf/src/message.rs index d5664199..6ab0eb29 100644 --- a/quick-protobuf/src/message.rs +++ b/quick-protobuf/src/message.rs @@ -8,12 +8,12 @@ use std::path::Path; use crate::errors::Result; use crate::reader::BytesReader; -use crate::writer::Writer; +use crate::writer::{Writer, WriterBackend}; /// A trait to handle deserialization based on parsed `Field`s pub trait MessageWrite: Sized { /// Writes `Self` into W writer - fn write_message(&self, _: &mut Writer) -> Result<()> { + fn write_message(&self, _: &mut Writer) -> Result<()> { Ok(()) } diff --git a/quick-protobuf/src/reader.rs b/quick-protobuf/src/reader.rs index e6ed2827..3395d54a 100644 --- a/quick-protobuf/src/reader.rs +++ b/quick-protobuf/src/reader.rs @@ -94,12 +94,7 @@ impl BytesReader { /// Reads the next byte #[inline(always)] pub fn read_u8(&mut self, bytes: &[u8]) -> Result { - let b = bytes.get(self.start).ok_or_else::(|| { - Error::Io(io::Error::new( - io::ErrorKind::UnexpectedEof, - "Cannot read next bytes", - )) - })?; + let b = bytes.get(self.start).ok_or(Error::UnexpectedEndOfBuffer)?; self.start += 1; Ok(*b) } @@ -398,10 +393,7 @@ impl BytesReader { pub fn read_packed_fixed<'a, M>(&mut self, bytes: &'a [u8]) -> Result<&'a [M]> { let len = self.read_varint32(bytes)? as usize; if self.len() < len { - return Err(Error::Io(io::Error::new( - io::ErrorKind::UnexpectedEof, - "Cannot read fixed packed field", - ))); + return Err(Error::UnexpectedEndOfBuffer); } let n = len / ::std::mem::size_of::(); let slice = unsafe { diff --git a/quick-protobuf/src/writer.rs b/quick-protobuf/src/writer.rs index 1adcb4bd..176ff9c6 100644 --- a/quick-protobuf/src/writer.rs +++ b/quick-protobuf/src/writer.rs @@ -2,10 +2,10 @@ use std::io::Write; -use crate::errors::Result; +use crate::errors::{Error, Result}; use crate::message::MessageWrite; -use byteorder::LittleEndian as LE; +use byteorder::{ByteOrder, LittleEndian as LE}; use byteorder::WriteBytesExt; /// A struct to write protobuf messages @@ -15,18 +15,17 @@ use byteorder::WriteBytesExt; /// ```rust /// // an automatically generated module which is in a separate file in general /// mod foo_bar { -/// # use quick_protobuf::{MessageWrite, Writer, Result}; +/// # use quick_protobuf::{MessageWrite, Writer, WriterBackend, Result}; /// # use std::borrow::Cow; -/// # use std::io::Write; /// pub struct Foo<'a> { pub name: Option>, } /// pub struct Bar { pub id: Option } /// pub struct FooBar<'a> { pub foos: Vec>, pub bars: Vec, } /// impl<'a> MessageWrite for FooBar<'a> { /// // implements /// // fn get_size(&self) -> usize { ... } -/// // fn write_message(&self, r: &mut Writer) -> Result<()> { ... } +/// // fn write_message(&self, r: &mut Writer) -> Result<()> { ... } /// # fn get_size(&self) -> usize { 0 } -/// # fn write_message(&self, _: &mut Writer) -> Result<()> { Ok(()) } +/// # fn write_message(&self, _: &mut Writer) -> Result<()> { Ok(()) } /// } /// } /// @@ -52,11 +51,11 @@ use byteorder::WriteBytesExt; /// writer.write_message(&foobar).expect("Cannot write FooBar"); /// } /// ``` -pub struct Writer { +pub struct Writer { inner: W, } -impl Writer { +impl Writer { /// Creates a new `ProtobufWriter` pub fn new(w: W) -> Writer { Writer { inner: w } @@ -64,16 +63,16 @@ impl Writer { /// Writes a byte which is NOT internally coded as a `varint` pub fn write_u8(&mut self, byte: u8) -> Result<()> { - self.inner.write_u8(byte).map_err(|e| e.into()) + self.inner.pb_write_u8(byte).map_err(|e| e.into()) } /// Writes a `varint` (compacted `u64`) pub fn write_varint(&mut self, mut v: u64) -> Result<()> { while v > 0x7F { - self.inner.write_u8(((v as u8) & 0x7F) | 0x80)?; + self.inner.pb_write_u8(((v as u8) & 0x7F) | 0x80)?; v >>= 7; } - self.inner.write_u8(v as u8).map_err(|e| e.into()) + self.inner.pb_write_u8(v as u8).map_err(|e| e.into()) } /// Writes a tag, which represents both the field number and the wire type @@ -121,44 +120,44 @@ impl Writer { /// Writes a `fixed64` which is little endian coded `u64` #[inline(always)] pub fn write_fixed64(&mut self, v: u64) -> Result<()> { - self.inner.write_u64::(v).map_err(|e| e.into()) + self.inner.pb_write_u64(v).map_err(|e| e.into()) } /// Writes a `fixed32` which is little endian coded `u32` #[inline(always)] pub fn write_fixed32(&mut self, v: u32) -> Result<()> { - self.inner.write_u32::(v).map_err(|e| e.into()) + self.inner.pb_write_u32(v).map_err(|e| e.into()) } /// Writes a `sfixed64` which is little endian coded `i64` #[inline(always)] pub fn write_sfixed64(&mut self, v: i64) -> Result<()> { - self.inner.write_i64::(v).map_err(|e| e.into()) + self.inner.pb_write_i64(v).map_err(|e| e.into()) } /// Writes a `sfixed32` which is little endian coded `i32` #[inline(always)] pub fn write_sfixed32(&mut self, v: i32) -> Result<()> { - self.inner.write_i32::(v).map_err(|e| e.into()) + self.inner.pb_write_i32(v).map_err(|e| e.into()) } /// Writes a `float` #[inline(always)] pub fn write_float(&mut self, v: f32) -> Result<()> { - self.inner.write_f32::(v).map_err(|e| e.into()) + self.inner.pb_write_f32(v).map_err(|e| e.into()) } /// Writes a `double` #[inline(always)] pub fn write_double(&mut self, v: f64) -> Result<()> { - self.inner.write_f64::(v).map_err(|e| e.into()) + self.inner.pb_write_f64(v).map_err(|e| e.into()) } /// Writes a `bool` 1 = true, 0 = false #[inline(always)] pub fn write_bool(&mut self, v: bool) -> Result<()> { self.inner - .write_u8(if v { 1 } else { 0 }) + .pb_write_u8(if v { 1 } else { 0 }) .map_err(|e| e.into()) } @@ -172,7 +171,7 @@ impl Writer { #[inline(always)] pub fn write_bytes(&mut self, bytes: &[u8]) -> Result<()> { self.write_varint(bytes.len() as u64)?; - self.inner.write_all(bytes).map_err(|e| e.into()) + self.inner.pb_write_all(bytes).map_err(|e| e.into()) } /// Writes `string`: length first then the chunk of data @@ -319,3 +318,189 @@ pub fn serialize_into_vec(message: &M) -> Result> { } Ok(v) } + +/// Serialize a `MessageWrite` into a byte slice +pub fn serialize_into_slice(message: &M, out: &mut [u8]) -> Result<()> { + let len = message.get_size(); + if out.len() < len { + return Err(Error::OutputBufferTooSmall); + } + { + let mut writer = Writer::new(BytesWriter::new(out)); + writer.write_message(message)?; + } + + Ok(()) +} + +/// Writer backend abstraction +pub trait WriterBackend { + /// Write a u8 + fn pb_write_u8(&mut self, x: u8) -> Result<()>; + + /// Write a u32 + fn pb_write_u32(&mut self, x: u32) -> Result<()>; + + /// Write a i32 + fn pb_write_i32(&mut self, x: i32) -> Result<()>; + + /// Write a f32 + fn pb_write_f32(&mut self, x: f32) -> Result<()>; + + /// Write a u64 + fn pb_write_u64(&mut self, x: u64) -> Result<()>; + + /// Write a i64 + fn pb_write_i64(&mut self, x: i64) -> Result<()>; + + /// Write a f64 + fn pb_write_f64(&mut self, x: f64) -> Result<()>; + + /// Write all bytes in buf + fn pb_write_all(&mut self, buf: &[u8]) -> Result<()>; +} + +/// A writer backend for byte buffers +pub struct BytesWriter<'a> { + buf: &'a mut [u8], + cursor: usize, +} + +impl<'a> BytesWriter<'a> { + /// Create a new BytesWriter to write into `buf` + pub fn new(buf: &'a mut [u8]) -> BytesWriter<'a> { + BytesWriter { buf, cursor: 0 } + } +} + +impl<'a> WriterBackend for BytesWriter<'a> { + #[inline(always)] + fn pb_write_u8(&mut self, x: u8) -> Result<()> { + if self.buf.len() < 1 { + Err(Error::UnexpectedEndOfBuffer) + } else { + self.buf[self.cursor] = x; + self.cursor += 1; + Ok(()) + } + } + + #[inline(always)] + fn pb_write_u32(&mut self, x: u32) -> Result<()> { + if self.buf.len() - self.cursor < 4 { + Err(Error::UnexpectedEndOfBuffer) + } else { + LE::write_u32(&mut self.buf[self.cursor..], x); + self.cursor += 4; + Ok(()) + } + } + + #[inline(always)] + fn pb_write_i32(&mut self, x: i32) -> Result<()> { + if self.buf.len() - self.cursor < 4 { + Err(Error::UnexpectedEndOfBuffer) + } else { + LE::write_i32(&mut self.buf[self.cursor..], x); + self.cursor += 4; + Ok(()) + } + } + + #[inline(always)] + fn pb_write_f32(&mut self, x: f32) -> Result<()> { + if self.buf.len() - self.cursor < 4 { + Err(Error::UnexpectedEndOfBuffer) + } else { + LE::write_f32(&mut self.buf[self.cursor..], x); + self.cursor += 4; + Ok(()) + } + } + + #[inline(always)] + fn pb_write_u64(&mut self, x: u64) -> Result<()> { + if self.buf.len() - self.cursor < 8 { + Err(Error::UnexpectedEndOfBuffer) + } else { + LE::write_u64(&mut self.buf[self.cursor..], x); + self.cursor += 8; + Ok(()) + } + } + + #[inline(always)] + fn pb_write_i64(&mut self, x: i64) -> Result<()> { + if self.buf.len() - self.cursor < 8 { + Err(Error::UnexpectedEndOfBuffer) + } else { + LE::write_i64(&mut self.buf[self.cursor..], x); + self.cursor += 8; + Ok(()) + } + } + + #[inline(always)] + fn pb_write_f64(&mut self, x: f64) -> Result<()> { + if self.buf.len() - self.cursor < 8 { + Err(Error::UnexpectedEndOfBuffer) + } else { + LE::write_f64(&mut self.buf[self.cursor..], x); + self.cursor += 8; + Ok(()) + } + } + + #[inline(always)] + fn pb_write_all(&mut self, buf: &[u8]) -> Result<()> { + if self.buf.len() - self.cursor < buf.len() { + Err(Error::UnexpectedEndOfBuffer) + } else { + self.buf[self.cursor..].copy_from_slice(buf); + self.cursor += buf.len(); + Ok(()) + } + } +} + +impl WriterBackend for W { + #[inline(always)] + fn pb_write_u8(&mut self, x: u8) -> Result<()> { + self.write_u8(x).map_err(|e| e.into()) + } + + #[inline(always)] + fn pb_write_u32(&mut self, x: u32) -> Result<()> { + self.write_u32::(x).map_err(|e| e.into()) + } + + #[inline(always)] + fn pb_write_i32(&mut self, x: i32) -> Result<()> { + self.write_i32::(x).map_err(|e| e.into()) + } + + #[inline(always)] + fn pb_write_f32(&mut self, x: f32) -> Result<()> { + self.write_f32::(x).map_err(|e| e.into()) + } + + #[inline(always)] + fn pb_write_u64(&mut self, x: u64) -> Result<()> { + self.write_u64::(x).map_err(|e| e.into()) + } + + #[inline(always)] + fn pb_write_i64(&mut self, x: i64) -> Result<()> { + self.write_i64::(x).map_err(|e| e.into()) + } + + #[inline(always)] + fn pb_write_f64(&mut self, x: f64) -> Result<()> { + self.write_f64::(x).map_err(|e| e.into()) + } + + #[inline(always)] + fn pb_write_all(&mut self, buf: &[u8]) -> Result<()> { + self.write_all(buf).map_err(|e| e.into()) + } +} diff --git a/quick-protobuf/tests/rust_protobuf/v3/basic.rs b/quick-protobuf/tests/rust_protobuf/v3/basic.rs index b0f2bd47..0ca952aa 100644 --- a/quick-protobuf/tests/rust_protobuf/v3/basic.rs +++ b/quick-protobuf/tests/rust_protobuf/v3/basic.rs @@ -9,9 +9,8 @@ #![cfg_attr(rustfmt, rustfmt_skip)] -use std::io::Write; use std::borrow::Cow; -use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, Result}; +use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; use quick_protobuf::sizeofs::*; use super::*; @@ -78,7 +77,7 @@ impl MessageWrite for Test1 { + if self.a == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.a) as u64) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.a != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.a))?; } Ok(()) } @@ -109,7 +108,7 @@ impl<'a> MessageWrite for Test2<'a> { + if self.b == "" { 0 } else { 1 + sizeof_len((&self.b).len()) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.b != "" { w.write_with_tag(18, |w| w.write_string(&**&self.b))?; } Ok(()) } @@ -140,7 +139,7 @@ impl MessageWrite for Test3 { + self.c.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if let Some(ref s) = self.c { w.write_with_tag(26, |w| w.write_message(s))?; } Ok(()) } @@ -171,7 +170,7 @@ impl MessageWrite for Test4 { + if self.d.is_empty() { 0 } else { 1 + sizeof_len(self.d.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { w.write_packed_with_tag(34, &self.d, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?; Ok(()) } @@ -205,7 +204,7 @@ impl MessageWrite for TestPackedUnpacked { + if self.packed.is_empty() { 0 } else { 1 + sizeof_len(self.packed.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { for s in &self.unpacked { w.write_with_tag(32, |w| w.write_int32(*s))?; } w.write_packed_with_tag(42, &self.packed, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?; Ok(()) @@ -237,7 +236,7 @@ impl MessageWrite for TestEmpty { + if self.foo == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.foo) as u64) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.foo != 0i32 { w.write_with_tag(80, |w| w.write_int32(*&self.foo))?; } Ok(()) } @@ -268,7 +267,7 @@ impl MessageWrite for Test { + if self.b == false { 0 } else { 1 + sizeof_varint(*(&self.b) as u64) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.b != false { w.write_with_tag(40, |w| w.write_bool(*&self.b))?; } Ok(()) } @@ -299,7 +298,7 @@ impl MessageWrite for TestUnknownFields { + if self.a == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.a) as u64) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.a != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.a))?; } Ok(()) } @@ -333,7 +332,7 @@ impl MessageWrite for TestSelfReference { + self.r2.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if let Some(ref s) = self.r1 { w.write_with_tag(10, |w| w.write_message(&**s))?; } if let Some(ref s) = self.r2 { w.write_with_tag(18, |w| w.write_message(&**s))?; } Ok(()) @@ -365,7 +364,7 @@ impl<'a> MessageWrite for TestDefaultInstanceField<'a> { + if self.s == "" { 0 } else { 1 + sizeof_len((&self.s).len()) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.s != "" { w.write_with_tag(10, |w| w.write_string(&**&self.s))?; } Ok(()) } @@ -396,7 +395,7 @@ impl<'a> MessageWrite for TestDefaultInstance<'a> { + self.field.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if let Some(ref s) = self.field { w.write_with_tag(10, |w| w.write_message(s))?; } Ok(()) } @@ -427,7 +426,7 @@ impl MessageWrite for TestDescriptor { + if self.stuff == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.stuff) as u64) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.stuff != 0i32 { w.write_with_tag(80, |w| w.write_int32(*&self.stuff))?; } Ok(()) } @@ -503,7 +502,7 @@ impl<'a> MessageWrite for TestTypesSingular<'a> { + if self.enum_field == basic::TestEnumDescriptor::UNKNOWN { 0 } else { 2 + sizeof_varint(*(&self.enum_field) as u64) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.double_field != 0f64 { w.write_with_tag(9, |w| w.write_double(*&self.double_field))?; } if self.float_field != 0f32 { w.write_with_tag(21, |w| w.write_float(*&self.float_field))?; } if self.int32_field != 0i32 { w.write_with_tag(24, |w| w.write_int32(*&self.int32_field))?; } @@ -594,7 +593,7 @@ impl<'a> MessageWrite for TestTypesRepeated<'a> { + self.enum_field.iter().map(|s| 2 + sizeof_varint(*(s) as u64)).sum::() } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { for s in &self.double_field { w.write_with_tag(9, |w| w.write_double(*s))?; } for s in &self.float_field { w.write_with_tag(21, |w| w.write_float(*s))?; } for s in &self.int32_field { w.write_with_tag(24, |w| w.write_int32(*s))?; } @@ -679,7 +678,7 @@ impl MessageWrite for TestTypesRepeatedArrayVec { + if self.enum_field.is_empty() { 0 } else { 1 + sizeof_len(self.enum_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { w.write_packed_fixed_with_tag(10, &self.double_field)?; w.write_packed_fixed_with_tag(18, &self.float_field)?; w.write_packed_with_tag(26, &self.int32_field, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?; @@ -768,7 +767,7 @@ impl<'a> MessageWrite for TestTypesRepeatedPacked<'a> { + if self.enum_field.is_empty() { 0 } else { 2 + sizeof_len(self.enum_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { w.write_packed_fixed_with_tag(10, &self.double_field)?; w.write_packed_fixed_with_tag(18, &self.float_field)?; w.write_packed_with_tag(26, &self.int32_field, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?; @@ -826,7 +825,7 @@ impl<'a> MessageWrite for TestTruncated<'a> { + if self.ints.is_empty() { 0 } else { 1 + sizeof_len(self.ints.len() * 4) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { w.write_packed_fixed_with_tag(18, &self.ints)?; Ok(()) } @@ -860,7 +859,7 @@ impl MessageWrite for TestBugSint { + if self.s64 == 0i64 { 0 } else { 1 + sizeof_sint64(*(&self.s64)) } } - fn write_message(&self, w: &mut Writer) -> Result<()> { + fn write_message(&self, w: &mut Writer) -> Result<()> { if self.s32 != 0i32 { w.write_with_tag(8, |w| w.write_sint32(*&self.s32))?; } if self.s64 != 0i64 { w.write_with_tag(16, |w| w.write_sint64(*&self.s64))?; } Ok(()) diff --git a/quick-protobuf/tests/write_read.rs b/quick-protobuf/tests/write_read.rs index f08ae328..cdf1c139 100644 --- a/quick-protobuf/tests/write_read.rs +++ b/quick-protobuf/tests/write_read.rs @@ -1,11 +1,12 @@ extern crate quick_protobuf; use quick_protobuf::sizeofs::*; -use quick_protobuf::{deserialize_from_slice, serialize_into_vec}; -use quick_protobuf::{BytesReader, MessageRead, MessageWrite, Reader, Result, Writer}; +use quick_protobuf::{deserialize_from_slice, serialize_into_slice, serialize_into_vec}; +use quick_protobuf::{ + BytesReader, MessageRead, MessageWrite, Reader, Result, Writer, WriterBackend, +}; use std::borrow::Cow; use std::collections::HashMap; -use std::io::Write; macro_rules! write_read_primitive { ($name:ident, $read:ident, $write:ident) => { @@ -128,7 +129,7 @@ impl MessageWrite for TestMessage { .sum::() } - fn write_message(&self, r: &mut Writer) -> Result<()> { + fn write_message(&self, r: &mut Writer) -> Result<()> { if let Some(ref s) = self.id { r.write_with_tag(10, |r| r.write_uint32(*s))?; } @@ -152,6 +153,19 @@ fn wr_message() { assert_eq!(buf.len(), sizeof_varint(8) + v.get_size()); } +#[test] +fn wr_message_slice() { + let v = TestMessage { + id: Some(63), + val: vec![53, 5, 76, 743, 23, 753], + }; + + let mut buf = [0u8; 1024]; + serialize_into_slice(&v, &mut buf).unwrap(); + + assert_eq!(v, deserialize_from_slice(&buf).unwrap()); +} + #[derive(PartialEq, Eq, Debug, Clone, Default)] struct TestMessageBorrow<'a> { id: Option, @@ -186,7 +200,7 @@ impl<'a> MessageWrite for TestMessageBorrow<'a> { .sum::() } - fn write_message(&self, r: &mut Writer) -> Result<()> { + fn write_message(&self, r: &mut Writer) -> Result<()> { if let Some(ref s) = self.id { r.write_with_tag(10, |r| r.write_uint32(*s))?; } From 8ec09c06c6deb38e7c57e286370bb70c6a7fd0c3 Mon Sep 17 00:00:00 2001 From: Russell Mull Date: Fri, 30 Aug 2019 10:37:21 -0700 Subject: [PATCH 03/30] Support no_std in runtime crate - Add the `std` feature to the quick-protobuf runtime crate - Put uses of Vec and std::io::Write behind the `std` feature - Change other uses of `std` to `core` - Add the `quick-protobuf/no-std-example` compile test --- quick-protobuf/Cargo.toml | 10 +- quick-protobuf/no-std-example/Cargo.toml | 11 ++ quick-protobuf/no-std-example/Readme.md | 2 + quick-protobuf/no-std-example/src/lib.rs | 17 +++ quick-protobuf/no-std-example/src/mod.rs | 2 + .../no-std-example/src/no_std.proto | 20 +++ .../no-std-example/src/protos/mod.rs | 2 + .../no-std-example/src/protos/no_std.rs | 125 ++++++++++++++++++ quick-protobuf/src/errors.rs | 24 +++- quick-protobuf/src/lib.rs | 8 +- quick-protobuf/src/message.rs | 6 +- quick-protobuf/src/reader.rs | 18 ++- quick-protobuf/src/writer.rs | 16 ++- run_test.sh | 5 + 14 files changed, 239 insertions(+), 27 deletions(-) create mode 100644 quick-protobuf/no-std-example/Cargo.toml create mode 100644 quick-protobuf/no-std-example/Readme.md create mode 100644 quick-protobuf/no-std-example/src/lib.rs create mode 100644 quick-protobuf/no-std-example/src/mod.rs create mode 100644 quick-protobuf/no-std-example/src/no_std.proto create mode 100644 quick-protobuf/no-std-example/src/protos/mod.rs create mode 100644 quick-protobuf/no-std-example/src/protos/no_std.rs diff --git a/quick-protobuf/Cargo.toml b/quick-protobuf/Cargo.toml index dcfebf12..bf610bfd 100644 --- a/quick-protobuf/Cargo.toml +++ b/quick-protobuf/Cargo.toml @@ -11,15 +11,15 @@ repository = "https://github.com/tafia/quick-protobuf" edition = "2018" [dependencies] -byteorder = "1.2.4" -failure = "0.1.1" +byteorder = { version = "1.2.4", default-features = false } +failure = { version = "0.1.1", default-features = false } failure_derive = "0.1.1" -arrayvec = {version = "0.4.11", optional = true } +arrayvec = { version = "0.4.11", optional = true, default-features = false } [dev-dependencies] lazy_static = "0.2.10" -arrayvec = "0.4.11" [features] -default = ["with_arrayvec"] +default = ["std", "with_arrayvec"] +std = ["byteorder/std", "failure/std"] with_arrayvec = ["arrayvec"] diff --git a/quick-protobuf/no-std-example/Cargo.toml b/quick-protobuf/no-std-example/Cargo.toml new file mode 100644 index 00000000..816904f2 --- /dev/null +++ b/quick-protobuf/no-std-example/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "no-std-example" +version = "0.1.0" +authors = ["Russell Mull "] +edition = "2018" + +[dependencies] +quick-protobuf = { path = "..", default-features = false, features = ["with_arrayvec"] } +arrayvec = { version = "0.4.11", default-features = false } + +[workspace] diff --git a/quick-protobuf/no-std-example/Readme.md b/quick-protobuf/no-std-example/Readme.md new file mode 100644 index 00000000..dfa6c0c8 --- /dev/null +++ b/quick-protobuf/no-std-example/Readme.md @@ -0,0 +1,2 @@ +This is just a compile-test; the actual functionality is all available in normal +builds. diff --git a/quick-protobuf/no-std-example/src/lib.rs b/quick-protobuf/no-std-example/src/lib.rs new file mode 100644 index 00000000..5501698c --- /dev/null +++ b/quick-protobuf/no-std-example/src/lib.rs @@ -0,0 +1,17 @@ +#![no_std] + +use quick_protobuf::{serialize_into_slice, deserialize_from_slice}; +use crate::protos::no_std::*; + +mod protos; + +pub fn round_trip() { + let message = NoStdMessage::default(); + + let mut buf = [0u8; 1024]; + serialize_into_slice(&message, &mut buf).unwrap(); + + let read_message = deserialize_from_slice(&buf).unwrap(); + assert_eq!(message, read_message); +} + diff --git a/quick-protobuf/no-std-example/src/mod.rs b/quick-protobuf/no-std-example/src/mod.rs new file mode 100644 index 00000000..cb5b6283 --- /dev/null +++ b/quick-protobuf/no-std-example/src/mod.rs @@ -0,0 +1,2 @@ +// Automatically generated mod.rs +pub mod protos; diff --git a/quick-protobuf/no-std-example/src/no_std.proto b/quick-protobuf/no-std-example/src/no_std.proto new file mode 100644 index 00000000..2ff021b8 --- /dev/null +++ b/quick-protobuf/no-std-example/src/no_std.proto @@ -0,0 +1,20 @@ +syntax = "proto3"; + +package protos.no_std; + +enum MyEnum { + Val0 = 0; + Val1 = 1; +} + +message EmbeddedMessage { + int32 val = 1; + MyEnum e = 2; +} + +message NoStdMessage { + fixed32 num = 1; + repeated fixed32 nums = 2 [rust_gen_arrayvec = 16]; + EmbeddedMessage message = 3; + repeated EmbeddedMessage messages = 4 [rust_gen_arrayvec = 16]; +} diff --git a/quick-protobuf/no-std-example/src/protos/mod.rs b/quick-protobuf/no-std-example/src/protos/mod.rs new file mode 100644 index 00000000..13ac3b3a --- /dev/null +++ b/quick-protobuf/no-std-example/src/protos/mod.rs @@ -0,0 +1,2 @@ +// Automatically generated mod.rs +pub mod no_std; diff --git a/quick-protobuf/no-std-example/src/protos/no_std.rs b/quick-protobuf/no-std-example/src/protos/no_std.rs new file mode 100644 index 00000000..dc424fc3 --- /dev/null +++ b/quick-protobuf/no-std-example/src/protos/no_std.rs @@ -0,0 +1,125 @@ +// Automatically generated rust module for 'no_std.proto' file + +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(non_camel_case_types)] +#![allow(unused_imports)] +#![allow(unknown_lints)] +#![allow(clippy)] +#![cfg_attr(rustfmt, rustfmt_skip)] + + +use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; +use quick_protobuf::sizeofs::*; +use super::super::*; + +#[derive(Debug, PartialEq, Eq, Clone, Copy)] +pub enum MyEnum { + Val0 = 0, + Val1 = 1, +} + +impl Default for MyEnum { + fn default() -> Self { + MyEnum::Val0 + } +} + +impl From for MyEnum { + fn from(i: i32) -> Self { + match i { + 0 => MyEnum::Val0, + 1 => MyEnum::Val1, + _ => Self::default(), + } + } +} + +impl<'a> From<&'a str> for MyEnum { + fn from(s: &'a str) -> Self { + match s { + "Val0" => MyEnum::Val0, + "Val1" => MyEnum::Val1, + _ => Self::default(), + } + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct EmbeddedMessage { + pub val: i32, + pub e: protos::no_std::MyEnum, +} + +impl<'a> MessageRead<'a> for EmbeddedMessage { + 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.val = r.read_int32(bytes)?, + Ok(16) => msg.e = r.read_enum(bytes)?, + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl MessageWrite for EmbeddedMessage { + fn get_size(&self) -> usize { + 0 + + if self.val == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.val) as u64) } + + if self.e == protos::no_std::MyEnum::Val0 { 0 } else { 1 + sizeof_varint(*(&self.e) as u64) } + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if self.val != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.val))?; } + if self.e != protos::no_std::MyEnum::Val0 { w.write_with_tag(16, |w| w.write_enum(*&self.e as i32))?; } + Ok(()) + } +} + +#[derive(Debug, Default, PartialEq, Clone)] +pub struct NoStdMessage { + pub num: u32, + pub nums: arrayvec::ArrayVec<[u32; 16]>, + pub message: Option, + pub messages: arrayvec::ArrayVec<[protos::no_std::EmbeddedMessage; 16]>, +} + +impl<'a> MessageRead<'a> for NoStdMessage { + 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(13) => msg.num = r.read_fixed32(bytes)?, + Ok(18) => msg.nums = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_fixed32(bytes)?))?, + Ok(26) => msg.message = Some(r.read_message::(bytes)?), + Ok(34) => msg.messages.push(r.read_message::(bytes)?), + Ok(t) => { r.read_unknown(bytes, t)?; } + Err(e) => return Err(e), + } + } + Ok(msg) + } +} + +impl MessageWrite for NoStdMessage { + fn get_size(&self) -> usize { + 0 + + if self.num == 0u32 { 0 } else { 1 + 4 } + + if self.nums.is_empty() { 0 } else { 1 + sizeof_len(self.nums.len() * 4) } + + self.message.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) + + self.messages.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() + } + + fn write_message(&self, w: &mut Writer) -> Result<()> { + if self.num != 0u32 { w.write_with_tag(13, |w| w.write_fixed32(*&self.num))?; } + w.write_packed_fixed_with_tag(18, &self.nums)?; + if let Some(ref s) = self.message { w.write_with_tag(26, |w| w.write_message(s))?; } + for s in &self.messages { w.write_with_tag(34, |w| w.write_message(s))?; } + Ok(()) + } +} + diff --git a/quick-protobuf/src/errors.rs b/quick-protobuf/src/errors.rs index 84fedd2c..4293bdde 100644 --- a/quick-protobuf/src/errors.rs +++ b/quick-protobuf/src/errors.rs @@ -1,30 +1,37 @@ -//! A module to handle all errors via error-chain crate +//! A module to handle all errors via failure crate -use failure::Fail; +#[cfg(feature = "std")] use std::io; /// An error enum which derives `Fail` -#[derive(Debug, Fail)] +#[derive(Debug, failure_derive::Fail)] pub enum Error { /// Io error + #[cfg(feature = "std")] #[fail(display = "{}", _0)] Io(#[cause] io::Error), + /// Utf8 Error #[fail(display = "{}", _0)] - Utf8(#[cause] ::std::str::Utf8Error), + Utf8(::core::str::Utf8Error), /// Deprecated feature (in protocol buffer specification) #[fail(display = "Feature '{}' has been deprecated", _0)] Deprecated(&'static str), + /// Unknown wire type #[fail(display = "Unknown wire type '{}', must be less than 6", _0)] UnknownWireType(u8), + /// Varint decoding error #[fail(display = "Cannot decode varint")] Varint, + /// Error while parsing protocol buffer message + #[cfg(feature = "std")] #[fail(display = "Error while parsing message: {}", _0)] Message(String), + /// Unexpected map tag #[fail(display = "Unexpected map tag: '{}', expecting 1 or 2", _0)] Map(u8), @@ -39,10 +46,12 @@ pub enum Error { } /// A wrapper for `Result` -pub type Result = ::std::result::Result; +pub type Result = ::core::result::Result; +#[cfg(feature = "std")] impl Into for Error { fn into(self) -> ::std::io::Error { + use failure::Fail; match self { Error::Io(x) => x, Error::Utf8(x) => io::Error::new(io::ErrorKind::InvalidData, x), @@ -51,14 +60,15 @@ impl Into for Error { } } +#[cfg(feature = "std")] impl From for Error { fn from(e: io::Error) -> Error { Error::Io(e) } } -impl From<::std::str::Utf8Error> for Error { - fn from(e: ::std::str::Utf8Error) -> Error { +impl From<::core::str::Utf8Error> for Error { + fn from(e: ::core::str::Utf8Error) -> Error { Error::Utf8(e) } } diff --git a/quick-protobuf/src/lib.rs b/quick-protobuf/src/lib.rs index 2a5ca46c..b8c79447 100644 --- a/quick-protobuf/src/lib.rs +++ b/quick-protobuf/src/lib.rs @@ -4,6 +4,7 @@ #![deny(missing_docs)] #![allow(dead_code)] +#![cfg_attr(not(feature = "std"), no_std)] extern crate byteorder; extern crate failure; @@ -18,4 +19,9 @@ pub mod writer; pub use crate::errors::{Error, Result}; pub use crate::message::{MessageRead, MessageWrite}; pub use crate::reader::{deserialize_from_slice, BytesReader}; -pub use crate::writer::{serialize_into_vec, serialize_into_slice, BytesWriter, Writer, WriterBackend}; +pub use crate::writer::{serialize_into_slice, BytesWriter, Writer, WriterBackend}; + +#[cfg(feature = "std")] +pub use crate::reader::Reader; +#[cfg(feature = "std")] +pub use crate::writer::serialize_into_vec; diff --git a/quick-protobuf/src/message.rs b/quick-protobuf/src/message.rs index 6ab0eb29..77e5a9fb 100644 --- a/quick-protobuf/src/message.rs +++ b/quick-protobuf/src/message.rs @@ -2,8 +2,11 @@ //! //! Creates the struct and implements a reader +#[cfg(feature = "std")] use std::fs::File; -use std::io::{BufWriter, Write}; +#[cfg(feature = "std")] +use std::io::BufWriter; +#[cfg(feature = "std")] use std::path::Path; use crate::errors::Result; @@ -23,6 +26,7 @@ pub trait MessageWrite: Sized { } /// Writes self into a file + #[cfg(feature = "std")] fn write_file>(&self, p: P) -> Result<()> { let file = BufWriter::new(File::create(p)?); let mut writer = Writer::new(file); diff --git a/quick-protobuf/src/reader.rs b/quick-protobuf/src/reader.rs index 3395d54a..67e8e01d 100644 --- a/quick-protobuf/src/reader.rs +++ b/quick-protobuf/src/reader.rs @@ -7,8 +7,11 @@ //! //! It is advised, for convenience to directly work with a `Reader`. +#[cfg(feature = "std")] use std::fs::File; -use std::io::{self, Read}; +#[cfg(feature = "std")] +use std::io::Read; +#[cfg(feature = "std")] use std::path::Path; #[cfg(feature = "with_arrayvec")] @@ -343,7 +346,7 @@ impl BytesReader { #[inline] pub fn read_string<'a>(&mut self, bytes: &'a [u8]) -> Result<&'a str> { self.read_len_varint(bytes, |r, b| { - ::std::str::from_utf8(&b[r.start..r.end]).map_err(|e| e.into()) + ::core::str::from_utf8(&b[r.start..r.end]).map_err(|e| e.into()) }) } @@ -351,6 +354,7 @@ impl BytesReader { /// /// Note: packed field are stored as a variable length chunk of data, while regular repeated /// fields behaves like an iterator, yielding their tag everytime + #[cfg(feature = "std")] #[inline] pub fn read_packed<'a, M, F>(&mut self, bytes: &'a [u8], mut read: F) -> Result> where @@ -395,9 +399,9 @@ impl BytesReader { if self.len() < len { return Err(Error::UnexpectedEndOfBuffer); } - let n = len / ::std::mem::size_of::(); + let n = len / ::core::mem::size_of::(); let slice = unsafe { - ::std::slice::from_raw_parts( + ::core::slice::from_raw_parts( bytes.get_unchecked(self.start) as *const u8 as *const M, n, ) @@ -440,8 +444,8 @@ impl BytesReader { where F: FnMut(&mut BytesReader, &'a [u8]) -> Result, G: FnMut(&mut BytesReader, &'a [u8]) -> Result, - K: ::std::fmt::Debug + Default, - V: ::std::fmt::Debug + Default, + K: ::core::fmt::Debug + Default, + V: ::core::fmt::Debug + Default, { self.read_len_varint(bytes, |r, bytes| { let mut k = K::default(); @@ -547,11 +551,13 @@ impl BytesReader { /// println!("Found {} foos and {} bars!", foobar.foos.len(), foobar.bars.len()); /// } /// ``` +#[cfg(feature = "std")] pub struct Reader { buffer: Vec, inner: BytesReader, } +#[cfg(feature = "std")] impl Reader { /// Creates a new `Reader` pub fn from_reader(mut r: R, capacity: usize) -> Result { diff --git a/quick-protobuf/src/writer.rs b/quick-protobuf/src/writer.rs index 176ff9c6..f98d9707 100644 --- a/quick-protobuf/src/writer.rs +++ b/quick-protobuf/src/writer.rs @@ -1,11 +1,11 @@ //! A module to manage protobuf serialization -use std::io::Write; - use crate::errors::{Error, Result}; use crate::message::MessageWrite; use byteorder::{ByteOrder, LittleEndian as LE}; + +#[cfg(feature = "std")] use byteorder::WriteBytesExt; /// A struct to write protobuf messages @@ -204,8 +204,8 @@ impl Writer { /// all data at once #[inline] pub fn write_packed_fixed(&mut self, v: &[M]) -> Result<()> { - let len = v.len() * ::std::mem::size_of::(); - let bytes = unsafe { ::std::slice::from_raw_parts(v.as_ptr() as *const u8, len) }; + let len = v.len() * ::core::mem::size_of::(); + let bytes = unsafe { ::core::slice::from_raw_parts(v.as_ptr() as *const u8, len) }; self.write_bytes(bytes) } @@ -263,8 +263,8 @@ impl Writer { } self.write_tag(tag)?; - let len = ::std::mem::size_of::() * v.len(); - let bytes = unsafe { ::std::slice::from_raw_parts(v.as_ptr() as *const u8, len) }; + let len = ::core::mem::size_of::() * v.len(); + let bytes = unsafe { ::core::slice::from_raw_parts(v.as_ptr() as *const u8, len) }; self.write_bytes(bytes) } @@ -283,7 +283,7 @@ impl Writer { self.write_tag(tag)?; let len = v.len() * item_size; let bytes = - unsafe { ::std::slice::from_raw_parts(v as *const [M] as *const M as *const u8, len) }; + unsafe { ::core::slice::from_raw_parts(v as *const [M] as *const M as *const u8, len) }; self.write_bytes(bytes) } @@ -309,6 +309,7 @@ impl Writer { } /// Serialize a `MessageWrite` into a `Vec` +#[cfg(feature = "std")] pub fn serialize_into_vec(message: &M) -> Result> { let len = message.get_size(); let mut v = Vec::with_capacity(len + crate::sizeofs::sizeof_len(len)); @@ -463,6 +464,7 @@ impl<'a> WriterBackend for BytesWriter<'a> { } } +#[cfg(feature = "std")] impl WriterBackend for W { #[inline(always)] fn pb_write_u8(&mut self, x: u8) -> Result<()> { diff --git a/run_test.sh b/run_test.sh index 2fc10863..d25bd06c 100755 --- a/run_test.sh +++ b/run_test.sh @@ -8,4 +8,9 @@ cargo run -p quick-protobuf --example pb_rs_example_v3_owned cargo run -p quick-protobuf --example pb_rs_example cargo run -p quick-protobuf --example pb_rs_example_v3 +# test that no_std can build +pushd quick-protobuf/no-std-example + cargo build +popd + cargo test -p pb-rs -p quick-protobuf From b4db89e5be53fbd8322b0024e8b4e73ddcc43c42 Mon Sep 17 00:00:00 2001 From: Russell Mull Date: Fri, 6 Sep 2019 15:04:37 -0700 Subject: [PATCH 04/30] Add no-std example to codegen script --- generate_modules.sh | 1 + perftest/src/perftest_data.rs | 2324 ++++++++++++++++++++++++++++----- 2 files changed, 2033 insertions(+), 292 deletions(-) diff --git a/generate_modules.sh b/generate_modules.sh index a98aa7f6..9122f0f4 100755 --- a/generate_modules.sh +++ b/generate_modules.sh @@ -19,6 +19,7 @@ proto_sets=( quick-protobuf/examples/pb_rs_v3 quick-protobuf/tests/packed_primitives quick-protobuf/tests/rust_protobuf/common + quick-protobuf/no-std-example/src ) for ps in "${proto_sets[@]}"; do diff --git a/perftest/src/perftest_data.rs b/perftest/src/perftest_data.rs index 58ecf1c9..cebe0abf 100644 --- a/perftest/src/perftest_data.rs +++ b/perftest/src/perftest_data.rs @@ -1,390 +1,2130 @@ -// Automatically generated rust module for 'perftest_data.proto' file +// This file is generated by rust-protobuf 2.8.0. Do not edit +// @generated +// 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(non_camel_case_types)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] #![allow(unused_imports)] -#![allow(unknown_lints)] -#![allow(clippy)] -#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_results)] +//! Generated file from `perftest_data.proto` +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; -use std::borrow::Cow; -use std::collections::HashMap; -use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; -use quick_protobuf::sizeofs::*; -use super::*; +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_8_0; -#[derive(Debug, Default, PartialEq, Clone)] +#[derive(PartialEq,Clone,Default)] pub struct Test1 { - pub value: Option, + // message fields + value: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, } -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), - } +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); + } +} + +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) } - Ok(msg) } } -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 ::protobuf::Clear for Test1 { + fn clear(&mut self) { + self.value = ::std::option::Option::None; + self.unknown_fields.clear(); } +} + +impl ::std::fmt::Debug for Test1 { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} - 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(()) +impl ::protobuf::reflect::ProtobufValue for Test1 { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) } } -#[derive(Debug, Default, PartialEq, Clone)] +#[derive(PartialEq,Clone,Default)] pub struct TestRepeatedBool { - pub values: Vec, + // message fields + values: ::std::vec::Vec, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, } -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<'a> ::std::default::Default for &'a TestRepeatedBool { + fn default() -> &'a TestRepeatedBool { + ::default_instance() } } -impl MessageWrite for TestRepeatedBool { - fn get_size(&self) -> usize { - 0 - + self.values.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() +impl TestRepeatedBool { + pub fn new() -> TestRepeatedBool { + ::std::default::Default::default() } - fn write_message(&self, w: &mut Writer) -> Result<()> { - for s in &self.values { w.write_with_tag(8, |w| w.write_bool(*s))?; } - Ok(()) + // repeated bool values = 1; + + + pub fn get_values(&self) -> &[bool] { + &self.values + } + pub fn clear_values(&mut self) { + self.values.clear(); } -} -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestRepeatedPackedInt32 { - pub values: Vec, + // 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()) + } } -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), - } +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() + ) + }) } - Ok(msg) + } + + 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 ::protobuf::Clear for TestRepeatedBool { + fn clear(&mut self) { + self.values.clear(); + self.unknown_fields.clear(); } } -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::()) } +impl ::std::fmt::Debug for TestRepeatedBool { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) } +} - 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::reflect::ProtobufValue for TestRepeatedBool { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) } } -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestRepeatedPackedFloat<'a> { - pub values: Cow<'a, [f32]>, +#[derive(PartialEq,Clone,Default)] +pub struct TestRepeatedPackedInt32 { + // message fields + values: ::std::vec::Vec, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, } -impl<'a> MessageRead<'a> for TestRepeatedPackedFloat<'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.values = r.read_packed_fixed(bytes)?.into(), - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) +impl<'a> ::std::default::Default for &'a TestRepeatedPackedInt32 { + fn default() -> &'a TestRepeatedPackedInt32 { + ::default_instance() } } -impl<'a> MessageWrite for TestRepeatedPackedFloat<'a> { - fn get_size(&self) -> usize { - 0 - + if self.values.is_empty() { 0 } else { 1 + sizeof_len(self.values.len() * 4) } +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 } - fn write_message(&self, w: &mut Writer) -> Result<()> { - w.write_packed_fixed_with_tag(10, &self.values)?; - Ok(()) + // Take field + pub fn take_values(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.values, ::std::vec::Vec::new()) } } -#[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), - } +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())?; + }, + }; } - Ok(msg) + ::std::result::Result::Ok(()) } -} -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::() + // 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_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(()) + 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)?; + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) } -} -#[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), - } + 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() + } + + 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() + ) + }) + } + } + + 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) } - Ok(msg) } } -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::Clear for TestRepeatedPackedInt32 { + fn clear(&mut self) { + self.values.clear(); + self.unknown_fields.clear(); } +} - 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(()) +impl ::std::fmt::Debug for TestRepeatedPackedInt32 { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) } } -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestStrings<'a> { - pub s1: Option>, - pub s2: Option>, - pub s3: Option>, +impl ::protobuf::reflect::ProtobufValue for TestRepeatedPackedInt32 { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } } -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) +#[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, +} + +impl<'a> ::std::default::Default for &'a TestRepeatedMessages { + fn default() -> &'a TestRepeatedMessages { + ::default_instance() } } -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())) +impl TestRepeatedMessages { + pub fn new() -> TestRepeatedMessages { + ::std::default::Default::default() } - 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(()) + // 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()) + } + + // repeated .perftest_data.TestRepeatedMessages messages2 = 2; + + + pub fn get_messages2(&self) -> &[TestRepeatedMessages] { + &self.messages2 + } + pub fn clear_messages2(&mut self) { + self.messages2.clear(); } -} -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestBytes<'a> { - pub b1: Option>, + // 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 + } + + // Take field + pub fn take_messages3(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.messages3, ::protobuf::RepeatedField::new()) + } } -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), +impl ::protobuf::Message for TestRepeatedMessages { + fn is_initialized(&self) -> bool { + for v in &self.messages1 { + if !v.is_initialized() { + return false; } + }; + 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<'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 ::protobuf::Clear for TestRepeatedMessages { + fn clear(&mut self) { + self.messages1.clear(); + self.messages2.clear(); + self.messages3.clear(); + self.unknown_fields.clear(); } +} - 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(()) +impl ::std::fmt::Debug for TestRepeatedMessages { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) } } -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestMap<'a> { - pub value: HashMap, u32>, +impl ::protobuf::reflect::ProtobufValue for TestRepeatedMessages { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) + } } -impl<'a> MessageRead<'a> for TestMap<'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) => { - let (key, value) = r.read_map(bytes, |r, bytes| Ok(r.read_string(bytes).map(Cow::Borrowed)?), |r, bytes| Ok(r.read_uint32(bytes)?))?; - msg.value.insert(key, value); - } - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } +#[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() + } +} + +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(); } - Ok(msg) - } -} - -impl<'a> MessageWrite for TestMap<'a> { - fn get_size(&self) -> usize { - 0 - + self.value.iter().map(|(k, v)| 1 + sizeof_len(2 + sizeof_len((k).len()) + sizeof_varint(*(v) as u64))).sum::() - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - for (k, v) in self.value.iter() { w.write_with_tag(10, |w| w.write_map(2 + sizeof_len((k).len()) + sizeof_varint(*(v) as u64), 10, |w| w.write_string(&**k), 16, |w| w.write_uint32(*v)))?; } - Ok(()) - } -} - -#[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_repeated_packed_float: Vec>, - pub test_small_bytearrays: Vec>, - pub test_large_bytearrays: Vec>, - pub test_map: Vec>, -} - -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_repeated_packed_float.push(r.read_message::(bytes)?), - Ok(66) => msg.test_small_bytearrays.push(r.read_message::(bytes)?), - Ok(74) => msg.test_large_bytearrays.push(r.read_message::(bytes)?), - Ok(82) => msg.test_map.push(r.read_message::(bytes)?), - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } + 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(); } - Ok(msg) + 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() } -} -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_repeated_packed_float.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::() - + self.test_map.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() + // Param is passed by value, moved + pub fn set_message3(&mut self, v: TestOptionalMessages) { + self.message3 = ::protobuf::SingularPtrField::some(v); } - 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_repeated_packed_float { w.write_with_tag(58, |w| w.write_message(s))?; } - for s in &self.test_small_bytearrays { w.write_with_tag(66, |w| w.write_message(s))?; } - for s in &self.test_large_bytearrays { w.write_with_tag(74, |w| w.write_message(s))?; } - for s in &self.test_map { w.write_with_tag(82, |w| w.write_message(s))?; } - Ok(()) + // 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() + } + + // Take field + pub fn take_message3(&mut self) -> TestOptionalMessages { + self.message3.take().unwrap_or_else(|| TestOptionalMessages::new()) } } +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() + }) + } +} From d5bf6f77fc124b0915e0cfbf8a693dc8238631c9 Mon Sep 17 00:00:00 2001 From: Russell Mull Date: Mon, 9 Sep 2019 09:15:04 -0700 Subject: [PATCH 05/30] 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 { From 6ae5e9e85be8ea4959e316536ea5b6cd1a344554 Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Thu, 12 Sep 2019 11:37:06 -0700 Subject: [PATCH 06/30] remove arrayvec and max_length parameter; use alloc::vec::Vec when in nostd mode --- pb-rs/src/parser.rs | 26 +- pb-rs/src/types.rs | 39 +- perftest/Cargo.toml | 2 +- perftest/src/perftest_data.rs | 2269 +++++++++++++++-- quick-protobuf/Cargo.toml | 4 +- quick-protobuf/no-std-example/Cargo.toml | 3 +- .../no-std-example/src/no_std.proto | 4 +- quick-protobuf/src/reader.rs | 26 +- quick-protobuf/src/writer.rs | 7 +- .../rust_protobuf/v3/test_basic_pb.proto | 28 +- 10 files changed, 2079 insertions(+), 329 deletions(-) diff --git a/pb-rs/src/parser.rs b/pb-rs/src/parser.rs index 0fdbaddc..dcf7de7f 100644 --- a/pb-rs/src/parser.rs +++ b/pb-rs/src/parser.rs @@ -148,18 +148,12 @@ 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: option_key + >> key: word_ref >> many0!(br) >> tag!("=") >> many0!(br) @@ -271,12 +265,6 @@ named!( .find(|&&(k, _)| k == "deprecated") .map_or(false, |&(_, v)| str::FromStr::from_str(v) .expect("Cannot parse Deprecated value")), - max_length: key_vals - .iter() - .find(|&&(k, _)| k == "rust_max_length") - .map(|&(_, v)| v - .parse::() - .expect("Cannot parse rust_max_length value")), }) ) ); @@ -679,16 +667,4 @@ 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 ac5195bb..52e4ec2f 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -264,7 +264,6 @@ impl FieldType { fn has_lifetime( &self, desc: &FileDescriptor, - max_length: bool, packed: bool, ignore: &mut Vec, ) -> bool { @@ -278,10 +277,9 @@ impl FieldType { | FieldType::Sfixed32 | FieldType::String_ | FieldType::Bytes_ - | FieldType::Float => !max_length && packed, // Cow<[M]> + | FieldType::Float => packed, // Cow<[M]> FieldType::Map(ref key, ref value) => { - key.has_lifetime(desc, false, false, ignore) - || value.has_lifetime(desc, false, false, ignore) + key.has_lifetime(desc, false, ignore) || value.has_lifetime(desc, false, ignore) } _ => false, } @@ -434,14 +432,9 @@ pub struct Field { pub packed: Option, pub boxed: bool, pub deprecated: bool, - pub max_length: Option, } impl Field { - fn max_length(&self) -> bool { - self.max_length.is_some() - } - fn packed(&self) -> bool { self.packed.unwrap_or(false) } @@ -502,12 +495,6 @@ impl Field { { writeln!(w, "Option<{}>,", rust_type)? } - Frequency::Repeated if self.max_length.is_some() => writeln!( - w, - "arrayvec::ArrayVec<[{}; {}]>,", - rust_type, - self.max_length.unwrap() - )?, Frequency::Repeated if self.packed() && self.typ.is_fixed_size() && !config.dont_use_cow => { @@ -553,13 +540,6 @@ impl Field { Frequency::Required | Frequency::Optional => { writeln!(w, "msg.{} = {},", name, val_cow)? } - Frequency::Repeated if self.packed() && self.max_length.is_some() => { - writeln!( - w, - "msg.{} = r.read_packed_arrayvec(bytes, |r, bytes| Ok({}))?,", - name, val - )?; - } Frequency::Repeated if self.packed() && self.typ.is_fixed_size() => { writeln!(w, "msg.{} = r.read_packed_fixed(bytes)?.into(),", name)?; } @@ -820,10 +800,9 @@ impl Message { return false; } ignore.push(self.index.clone()); - let res = self.all_fields().any(|f| { - f.typ - .has_lifetime(desc, f.max_length(), f.packed(), ignore) - }); + let res = self + .all_fields() + .any(|f| f.typ.has_lifetime(desc, f.packed(), ignore)); ignore.pop(); res } @@ -1455,11 +1434,9 @@ pub struct OneOf { impl OneOf { fn has_lifetime(&self, desc: &FileDescriptor) -> bool { - self.fields.iter().any(|f| { - !f.deprecated - && f.typ - .has_lifetime(desc, f.max_length(), f.packed(), &mut Vec::new()) - }) + self.fields + .iter() + .any(|f| !f.deprecated && f.typ.has_lifetime(desc, f.packed(), &mut Vec::new())) } fn set_package(&mut self, package: &str, module: &str) { diff --git a/perftest/Cargo.toml b/perftest/Cargo.toml index cac2aff0..d0ddafec 100644 --- a/perftest/Cargo.toml +++ b/perftest/Cargo.toml @@ -7,7 +7,7 @@ build = "build.rs" [dependencies] protobuf = "2.0.4" -quick-protobuf = { path = "../quick-protobuf", default-features = false, features = ["with_arrayvec"] } +quick-protobuf = { path = "../quick-protobuf", default-features = false } time = "0.1.40" rand = "0.5.5" prost = "0.4.0" diff --git a/perftest/src/perftest_data.rs b/perftest/src/perftest_data.rs index 1ea21071..63e9a1a0 100644 --- a/perftest/src/perftest_data.rs +++ b/perftest/src/perftest_data.rs @@ -1,317 +1,2130 @@ -// Automatically generated rust module for 'perftest_data.proto' file +// This file is generated by rust-protobuf 2.8.1. Do not edit +// @generated +// 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(non_camel_case_types)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] #![allow(unused_imports)] -#![allow(unknown_lints)] -#![allow(clippy)] -#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_results)] +//! Generated file from `perftest_data.proto` +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; -use std::borrow::Cow; -use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; -use quick_protobuf::sizeofs::*; -use super::*; +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_8_1; -#[derive(Debug, Default, PartialEq, Clone)] +#[derive(PartialEq,Clone,Default)] pub struct Test1 { - pub value: Option, + // message fields + value: ::std::option::Option, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, } -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), - } +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); + } +} + +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) } - Ok(msg) } } -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 ::protobuf::Clear for Test1 { + fn clear(&mut self) { + self.value = ::std::option::Option::None; + self.unknown_fields.clear(); } +} + +impl ::std::fmt::Debug for Test1 { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} - 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(()) +impl ::protobuf::reflect::ProtobufValue for Test1 { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) } } -#[derive(Debug, Default, PartialEq, Clone)] +#[derive(PartialEq,Clone,Default)] pub struct TestRepeatedBool { - pub values: Vec, + // message fields + values: ::std::vec::Vec, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, } -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), - } +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()) + } +} + +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) } - Ok(msg) } } -impl MessageWrite for TestRepeatedBool { - fn get_size(&self) -> usize { - 0 - + self.values.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() +impl ::protobuf::Clear for TestRepeatedBool { + fn clear(&mut self) { + self.values.clear(); + self.unknown_fields.clear(); } +} + +impl ::std::fmt::Debug for TestRepeatedBool { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} - fn write_message(&self, w: &mut Writer) -> Result<()> { - for s in &self.values { w.write_with_tag(8, |w| w.write_bool(*s))?; } - Ok(()) +impl ::protobuf::reflect::ProtobufValue for TestRepeatedBool { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) } } -#[derive(Debug, Default, PartialEq, Clone)] +#[derive(PartialEq,Clone,Default)] pub struct TestRepeatedPackedInt32 { - pub values: Vec, + // message fields + values: ::std::vec::Vec, + // special fields + pub unknown_fields: ::protobuf::UnknownFields, + pub cached_size: ::protobuf::CachedSize, } -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<'a> ::std::default::Default for &'a TestRepeatedPackedInt32 { + fn default() -> &'a TestRepeatedPackedInt32 { + ::default_instance() } } -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::()) } +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 } - 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(()) + // Take field + pub fn take_values(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.values, ::std::vec::Vec::new()) } } -#[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), - } +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())?; + }, + }; } - Ok(msg) + ::std::result::Result::Ok(()) } -} -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::() + // 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_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(()) + 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)?; + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) } -} -#[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), - } + 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() + } + + 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() + ) + }) + } + } + + 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) } - Ok(msg) } } -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::Clear for TestRepeatedPackedInt32 { + fn clear(&mut self) { + self.values.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for TestRepeatedPackedInt32 { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) } +} - 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(()) +impl ::protobuf::reflect::ProtobufValue for TestRepeatedPackedInt32 { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) } } -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestStrings<'a> { - pub s1: Option>, - pub s2: Option>, - pub s3: Option>, +#[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, } -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<'a> ::std::default::Default for &'a TestRepeatedMessages { + fn default() -> &'a TestRepeatedMessages { + ::default_instance() } } -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())) +impl TestRepeatedMessages { + pub fn new() -> TestRepeatedMessages { + ::std::default::Default::default() } - 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(()) + // 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()) + } + + // repeated .perftest_data.TestRepeatedMessages messages2 = 2; -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestBytes<'a> { - pub b1: Option>, + + 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 + } + + // Take field + pub fn take_messages3(&mut self) -> ::protobuf::RepeatedField { + ::std::mem::replace(&mut self.messages3, ::protobuf::RepeatedField::new()) + } } -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), +impl ::protobuf::Message for TestRepeatedMessages { + fn is_initialized(&self) -> bool { + for v in &self.messages1 { + if !v.is_initialized() { + return false; } + }; + 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())?; + }, + }; } - Ok(msg) + ::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() } -} -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())) + 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 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(()) + 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) + } } } -#[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 ::protobuf::Clear for TestRepeatedMessages { + fn clear(&mut self) { + self.messages1.clear(); + self.messages2.clear(); + self.messages3.clear(); + self.unknown_fields.clear(); + } } -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), - } - } - Ok(msg) +impl ::std::fmt::Debug for TestRepeatedMessages { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) } } -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::() +impl ::protobuf::reflect::ProtobufValue for TestRepeatedMessages { + fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { + ::protobuf::reflect::ProtobufValueRef::Message(self) } +} + +#[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, +} - 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<'a> ::std::default::Default for &'a TestOptionalMessages { + fn default() -> &'a TestOptionalMessages { + ::default_instance() } } +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(); + } + 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); + } + + // 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() + } + + // Take field + pub fn take_message3(&mut self) -> TestOptionalMessages { + self.message3.take().unwrap_or_else(|| TestOptionalMessages::new()) + } +} +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/Cargo.toml b/quick-protobuf/Cargo.toml index bf610bfd..89c96503 100644 --- a/quick-protobuf/Cargo.toml +++ b/quick-protobuf/Cargo.toml @@ -14,12 +14,10 @@ edition = "2018" byteorder = { version = "1.2.4", default-features = false } failure = { version = "0.1.1", default-features = false } failure_derive = "0.1.1" -arrayvec = { version = "0.4.11", optional = true, default-features = false } [dev-dependencies] lazy_static = "0.2.10" [features] -default = ["std", "with_arrayvec"] +default = ["std"] std = ["byteorder/std", "failure/std"] -with_arrayvec = ["arrayvec"] diff --git a/quick-protobuf/no-std-example/Cargo.toml b/quick-protobuf/no-std-example/Cargo.toml index 816904f2..89e2d1a6 100644 --- a/quick-protobuf/no-std-example/Cargo.toml +++ b/quick-protobuf/no-std-example/Cargo.toml @@ -5,7 +5,6 @@ authors = ["Russell Mull "] edition = "2018" [dependencies] -quick-protobuf = { path = "..", default-features = false, features = ["with_arrayvec"] } -arrayvec = { version = "0.4.11", default-features = false } +quick-protobuf = { path = "..", default-features = false } [workspace] diff --git a/quick-protobuf/no-std-example/src/no_std.proto b/quick-protobuf/no-std-example/src/no_std.proto index 03c340af..a8278707 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_max_length)=16]; + repeated fixed32 nums = 2; EmbeddedMessage message = 3; - repeated EmbeddedMessage messages = 4 [(rust_max_length)=16]; + repeated EmbeddedMessage messages = 4; } diff --git a/quick-protobuf/src/reader.rs b/quick-protobuf/src/reader.rs index 67e8e01d..6358c023 100644 --- a/quick-protobuf/src/reader.rs +++ b/quick-protobuf/src/reader.rs @@ -14,8 +14,10 @@ use std::io::Read; #[cfg(feature = "std")] use std::path::Path; -#[cfg(feature = "with_arrayvec")] -use arrayvec::{self, ArrayVec}; +#[cfg(not(feature = "std"))] +extern crate alloc; +#[cfg(not(feature = "std"))] +use alloc::vec::Vec; use crate::errors::{Error, Result}; use crate::message::MessageRead; @@ -369,26 +371,6 @@ impl BytesReader { }) } - /// Reads packed repeated field (ArrayVec) - #[cfg(feature = "with_arrayvec")] - pub fn read_packed_arrayvec<'a, A, F>( - &mut self, - bytes: &'a [u8], - mut read: F, - ) -> Result> - where - A: arrayvec::Array, - F: FnMut(&mut BytesReader, &'a [u8]) -> Result<::Item>, - { - self.read_len_varint(bytes, |r, b| { - let mut v = arrayvec::ArrayVec::::new(); - while !r.is_eof() { - v.push(read(r, b)?); - } - Ok(v) - }) - } - /// Reads packed repeated field where M can directly be transmutted from raw bytes /// /// Note: packed field are stored as a variable length chunk of data, while regular repeated diff --git a/quick-protobuf/src/writer.rs b/quick-protobuf/src/writer.rs index f98d9707..2451a826 100644 --- a/quick-protobuf/src/writer.rs +++ b/quick-protobuf/src/writer.rs @@ -8,6 +8,12 @@ use byteorder::{ByteOrder, LittleEndian as LE}; #[cfg(feature = "std")] use byteorder::WriteBytesExt; +#[cfg(not(feature = "std"))] +extern crate alloc; +#[cfg(not(feature = "std"))] +use alloc::vec::Vec; + + /// A struct to write protobuf messages /// /// # Examples @@ -309,7 +315,6 @@ impl Writer { } /// Serialize a `MessageWrite` into a `Vec` -#[cfg(feature = "std")] pub fn serialize_into_vec(message: &M) -> Result> { let len = message.get_size(); let mut v = Vec::with_capacity(len + crate::sizeofs::sizeof_len(len)); 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 4aaaa7e9..20612a50 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_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]; + repeated double double_field = 1; + repeated float float_field = 2; + repeated int32 int32_field = 3; + repeated int64 int64_field = 4; + repeated uint32 uint32_field = 5; + repeated uint64 uint64_field = 6; + repeated sint32 sint32_field = 7; + repeated sint64 sint64_field = 8; + repeated fixed32 fixed32_field = 9; + repeated fixed64 fixed64_field = 10; + repeated sfixed32 sfixed32_field = 11; + repeated sfixed64 sfixed64_field = 12; + repeated bool bool_field = 13; + repeated TestEnumDescriptor enum_field = 14; } message TestTypesRepeatedPacked { From 34a8fb7838fca76f96e043256ab9f16e8a4e3954 Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Thu, 12 Sep 2019 11:44:12 -0700 Subject: [PATCH 07/30] let reader use Vec in nostd mode, but not File --- quick-protobuf/src/reader.rs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/quick-protobuf/src/reader.rs b/quick-protobuf/src/reader.rs index 6358c023..e9d3e207 100644 --- a/quick-protobuf/src/reader.rs +++ b/quick-protobuf/src/reader.rs @@ -356,7 +356,6 @@ impl BytesReader { /// /// Note: packed field are stored as a variable length chunk of data, while regular repeated /// fields behaves like an iterator, yielding their tag everytime - #[cfg(feature = "std")] #[inline] pub fn read_packed<'a, M, F>(&mut self, bytes: &'a [u8], mut read: F) -> Result> where @@ -533,13 +532,11 @@ impl BytesReader { /// println!("Found {} foos and {} bars!", foobar.foos.len(), foobar.bars.len()); /// } /// ``` -#[cfg(feature = "std")] pub struct Reader { buffer: Vec, inner: BytesReader, } -#[cfg(feature = "std")] impl Reader { /// Creates a new `Reader` pub fn from_reader(mut r: R, capacity: usize) -> Result { @@ -553,6 +550,7 @@ impl Reader { } /// Creates a new `Reader` out of a file path + #[cfg(feature = "std")] pub fn from_file>(src: P) -> Result { let len = src.as_ref().metadata().unwrap().len() as usize; let f = File::open(src)?; From 6139007199ff6b7374012716b1265f674237432e Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Thu, 12 Sep 2019 12:07:12 -0700 Subject: [PATCH 08/30] add nostd flag to pb-rs --- pb-rs/src/lib.rs | 8 +++ pb-rs/src/main.rs | 8 ++- pb-rs/src/types.rs | 1 + .../tests/rust_protobuf/v3/basic.rs | 66 +++++++++---------- 4 files changed, 49 insertions(+), 34 deletions(-) diff --git a/pb-rs/src/lib.rs b/pb-rs/src/lib.rs index b18fe3d5..07edfa56 100644 --- a/pb-rs/src/lib.rs +++ b/pb-rs/src/lib.rs @@ -68,6 +68,7 @@ pub struct ConfigBuilder { dont_use_cow: bool, custom_struct_derive: Vec, owned: bool, + nostd: bool, } impl ConfigBuilder { @@ -168,6 +169,12 @@ impl ConfigBuilder { self } + /// Generate no_std compliant code + pub fn nostd(mut self, val: bool) -> Self { + self.nostd = val; + self + } + /// Build Config from this ConfigBuilder pub fn build(self) -> Vec { self.in_files @@ -196,6 +203,7 @@ impl ConfigBuilder { custom_rpc_generator: Box::new(|_, _| Ok(())), custom_includes: Vec::new(), owned: self.owned, + nostd: self.nostd, } }) .collect() diff --git a/pb-rs/src/main.rs b/pb-rs/src/main.rs index c00598ab..1dbbbbeb 100644 --- a/pb-rs/src/main.rs +++ b/pb-rs/src/main.rs @@ -86,6 +86,11 @@ fn run() -> Result<(), ::failure::Error> { .long("owned") .required(false) .help("Generate Owned structs when the proto stuct has a lifetime"), + ).arg( + Arg::with_name("NOSTD") + .long("nostd") + .required(false) + .help("Generate no_std compliant code"), ).get_matches(); let in_files = path_vec(values_t!(matches, "INPUT", String)); @@ -111,7 +116,8 @@ fn run() -> Result<(), ::failure::Error> { .headers(!matches.is_present("NO_HEADERS")) .dont_use_cow(matches.is_present("DONT_USE_COW")) .custom_struct_derive(custom_struct_derive) - .owned(matches.is_present("OWNED")); + .owned(matches.is_present("OWNED")) + .nostd(matches.is_present("NOSTD")); FileDescriptor::run(&compiler.build()).map_err(|e| e.into()) } diff --git a/pb-rs/src/types.rs b/pb-rs/src/types.rs index 52e4ec2f..70187141 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -1650,6 +1650,7 @@ pub struct Config { pub custom_rpc_generator: RpcGeneratorFunction, pub custom_includes: Vec, pub owned: bool, + pub nostd: bool, } #[derive(Debug, Default, Clone)] diff --git a/quick-protobuf/tests/rust_protobuf/v3/basic.rs b/quick-protobuf/tests/rust_protobuf/v3/basic.rs index 0ca952aa..e6787b67 100644 --- a/quick-protobuf/tests/rust_protobuf/v3/basic.rs +++ b/quick-protobuf/tests/rust_protobuf/v3/basic.rs @@ -615,42 +615,42 @@ impl<'a> MessageWrite for TestTypesRepeated<'a> { } #[derive(Debug, Default, PartialEq, Clone)] -pub struct TestTypesRepeatedArrayVec { - pub double_field: arrayvec::ArrayVec<[f64; 10]>, - pub float_field: arrayvec::ArrayVec<[f32; 10]>, - pub int32_field: arrayvec::ArrayVec<[i32; 10]>, - pub int64_field: arrayvec::ArrayVec<[i64; 10]>, - pub uint32_field: arrayvec::ArrayVec<[u32; 10]>, - pub uint64_field: arrayvec::ArrayVec<[u64; 10]>, - pub sint32_field: arrayvec::ArrayVec<[i32; 10]>, - pub sint64_field: arrayvec::ArrayVec<[i64; 10]>, - pub fixed32_field: arrayvec::ArrayVec<[u32; 10]>, - pub fixed64_field: arrayvec::ArrayVec<[u64; 10]>, - pub sfixed32_field: arrayvec::ArrayVec<[i32; 10]>, - pub sfixed64_field: arrayvec::ArrayVec<[i64; 10]>, - pub bool_field: arrayvec::ArrayVec<[bool; 10]>, - pub enum_field: arrayvec::ArrayVec<[basic::TestEnumDescriptor; 10]>, -} - -impl<'a> MessageRead<'a> for TestTypesRepeatedArrayVec { +pub struct TestTypesRepeatedArrayVec<'a> { + pub double_field: Cow<'a, [f64]>, + pub float_field: Cow<'a, [f32]>, + pub int32_field: Vec, + pub int64_field: Vec, + pub uint32_field: Vec, + pub uint64_field: Vec, + pub sint32_field: Vec, + pub sint64_field: Vec, + pub fixed32_field: Cow<'a, [u32]>, + pub fixed64_field: Cow<'a, [u64]>, + pub sfixed32_field: Cow<'a, [i32]>, + pub sfixed64_field: Cow<'a, [i64]>, + pub bool_field: Vec, + pub enum_field: Vec, +} + +impl<'a> MessageRead<'a> for TestTypesRepeatedArrayVec<'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.double_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_double(bytes)?))?, - Ok(18) => msg.float_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_float(bytes)?))?, - Ok(26) => msg.int32_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_int32(bytes)?))?, - Ok(34) => msg.int64_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_int64(bytes)?))?, - Ok(42) => msg.uint32_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_uint32(bytes)?))?, - Ok(50) => msg.uint64_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_uint64(bytes)?))?, - Ok(58) => msg.sint32_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_sint32(bytes)?))?, - Ok(66) => msg.sint64_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_sint64(bytes)?))?, - Ok(74) => msg.fixed32_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_fixed32(bytes)?))?, - Ok(82) => msg.fixed64_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_fixed64(bytes)?))?, - Ok(90) => msg.sfixed32_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_sfixed32(bytes)?))?, - Ok(98) => msg.sfixed64_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_sfixed64(bytes)?))?, - Ok(106) => msg.bool_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_bool(bytes)?))?, - Ok(114) => msg.enum_field = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_enum(bytes)?))?, + Ok(10) => msg.double_field = r.read_packed_fixed(bytes)?.into(), + Ok(18) => msg.float_field = r.read_packed_fixed(bytes)?.into(), + Ok(26) => msg.int32_field = r.read_packed(bytes, |r, bytes| Ok(r.read_int32(bytes)?))?, + Ok(34) => msg.int64_field = r.read_packed(bytes, |r, bytes| Ok(r.read_int64(bytes)?))?, + Ok(42) => msg.uint32_field = r.read_packed(bytes, |r, bytes| Ok(r.read_uint32(bytes)?))?, + Ok(50) => msg.uint64_field = r.read_packed(bytes, |r, bytes| Ok(r.read_uint64(bytes)?))?, + Ok(58) => msg.sint32_field = r.read_packed(bytes, |r, bytes| Ok(r.read_sint32(bytes)?))?, + Ok(66) => msg.sint64_field = r.read_packed(bytes, |r, bytes| Ok(r.read_sint64(bytes)?))?, + Ok(74) => msg.fixed32_field = r.read_packed_fixed(bytes)?.into(), + Ok(82) => msg.fixed64_field = r.read_packed_fixed(bytes)?.into(), + Ok(90) => msg.sfixed32_field = r.read_packed_fixed(bytes)?.into(), + Ok(98) => msg.sfixed64_field = r.read_packed_fixed(bytes)?.into(), + Ok(106) => msg.bool_field = r.read_packed(bytes, |r, bytes| Ok(r.read_bool(bytes)?))?, + Ok(114) => msg.enum_field = r.read_packed(bytes, |r, bytes| Ok(r.read_enum(bytes)?))?, Ok(t) => { r.read_unknown(bytes, t)?; } Err(e) => return Err(e), } @@ -659,7 +659,7 @@ impl<'a> MessageRead<'a> for TestTypesRepeatedArrayVec { } } -impl MessageWrite for TestTypesRepeatedArrayVec { +impl<'a> MessageWrite for TestTypesRepeatedArrayVec<'a> { fn get_size(&self) -> usize { 0 + if self.double_field.is_empty() { 0 } else { 1 + sizeof_len(self.double_field.len() * 8) } From 3dd078e22eb0421d51b335246d78bdf6dc6bd4fa Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Thu, 12 Sep 2019 13:02:21 -0700 Subject: [PATCH 09/30] use alloc collections in nostd mode --- pb-rs/src/types.rs | 36 ++++++++++++++++--- .../tests/rust_protobuf/v3/basic.rs | 4 ++- 2 files changed, 35 insertions(+), 5 deletions(-) diff --git a/pb-rs/src/types.rs b/pb-rs/src/types.rs index 70187141..66da5aa2 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -847,19 +847,32 @@ impl Message { writeln!(w, "")?; writeln!(w, "pub mod mod_{} {{", self.name)?; writeln!(w, "")?; + if config.nostd { + writeln!(w, "extern crate alloc;")?; + writeln!(w, "use alloc::vec::Vec;")?; + } if self .messages .iter() .any(|m| m.all_fields().any(|f| f.typ.has_cow())) { - writeln!(w, "use std::borrow::Cow;")?; + if config.nostd { + writeln!(w, "use alloc::borrow::Cow;")?; + } else { + writeln!(w, "use std::borrow::Cow;")?; + } } if self .messages .iter() .any(|m| m.all_fields().any(|f| f.typ.is_map())) { - writeln!(w, "use std::collections::HashMap;")?; + if config.nostd { + writeln!(w, "use alloc::collections::BTreeHashMap;")?; + writeln!(w, "pub type HashMap = BTreeHashMap;")?; + } else { + writeln!(w, "use std::collections::HashMap;")?; + } } if !self.messages.is_empty() || !self.oneofs.is_empty() { writeln!(w, "use super::*;")?; @@ -2146,19 +2159,34 @@ impl FileDescriptor { )?; return Ok(()); } + + if config.nostd { + writeln!(w, "extern crate alloc;")?; + writeln!(w, "use alloc::vec::Vec;")?; + } + if self .messages .iter() .any(|m| m.all_fields().any(|f| f.typ.has_cow())) { - writeln!(w, "use std::borrow::Cow;")?; + if config.nostd { + writeln!(w, "use alloc::borrow::Cow;")?; + } else { + writeln!(w, "use std::borrow::Cow;")?; + } } if self .messages .iter() .any(|m| m.all_fields().any(|f| f.typ.is_map())) { - writeln!(w, "use std::collections::HashMap;")?; + if config.nostd { + writeln!(w, "use alloc::collections::BTreeHashMap;")?; + writeln!(w, "pub type HashMap = BTreeHashMap;")?; + } else { + writeln!(w, "use std::collections::HashMap;")?; + } } writeln!( w, diff --git a/quick-protobuf/tests/rust_protobuf/v3/basic.rs b/quick-protobuf/tests/rust_protobuf/v3/basic.rs index e6787b67..d773e301 100644 --- a/quick-protobuf/tests/rust_protobuf/v3/basic.rs +++ b/quick-protobuf/tests/rust_protobuf/v3/basic.rs @@ -9,7 +9,9 @@ #![cfg_attr(rustfmt, rustfmt_skip)] -use std::borrow::Cow; +extern crate alloc; +use alloc::vec::Vec; +use alloc::borrow::Cow; use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; use quick_protobuf::sizeofs::*; use super::*; From 93ed580601db555c134eaad6f95d8efa24e2dc00 Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Thu, 12 Sep 2019 14:16:29 -0700 Subject: [PATCH 10/30] don't allow from_reader in nostd mode --- quick-protobuf/src/reader.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/quick-protobuf/src/reader.rs b/quick-protobuf/src/reader.rs index e9d3e207..df4a81bf 100644 --- a/quick-protobuf/src/reader.rs +++ b/quick-protobuf/src/reader.rs @@ -539,6 +539,7 @@ pub struct Reader { impl Reader { /// Creates a new `Reader` + #[cfg(feature = "std")] pub fn from_reader(mut r: R, capacity: usize) -> Result { let mut buf = Vec::with_capacity(capacity); unsafe { From 56a565963d550c1ebe4dab98ab4002d3a7753d4e Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Thu, 12 Sep 2019 14:21:20 -0700 Subject: [PATCH 11/30] restrict serialize_into_vec to std mode; fix perftest config --- perftest/build.rs | 1 + quick-protobuf/src/writer.rs | 1 + 2 files changed, 2 insertions(+) diff --git a/perftest/build.rs b/perftest/build.rs index 01e05eac..4713d063 100644 --- a/perftest/build.rs +++ b/perftest/build.rs @@ -61,6 +61,7 @@ fn main() { custom_rpc_generator: Box::new(|rpc, writer| generate_rpc_test(rpc, writer)), custom_includes: Vec::new(), owned: false, + nostd: false, }; FileDescriptor::write_proto(&config).unwrap(); diff --git a/quick-protobuf/src/writer.rs b/quick-protobuf/src/writer.rs index 2451a826..41c80b51 100644 --- a/quick-protobuf/src/writer.rs +++ b/quick-protobuf/src/writer.rs @@ -315,6 +315,7 @@ impl Writer { } /// Serialize a `MessageWrite` into a `Vec` +#[cfg(feature = "std")] pub fn serialize_into_vec(message: &M) -> Result> { let len = message.get_size(); let mut v = Vec::with_capacity(len + crate::sizeofs::sizeof_len(len)); From 25be3e9b62c44759cb0da1522b3c75fc119056fc Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Fri, 13 Sep 2019 10:52:29 -0700 Subject: [PATCH 12/30] hashmap typedef needs generic args; revert nostd test protobuf --- pb-rs/src/types.rs | 8 ++++---- quick-protobuf/tests/rust_protobuf/v3/basic.rs | 4 +--- 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/pb-rs/src/types.rs b/pb-rs/src/types.rs index 66da5aa2..0b5fa8ec 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -868,8 +868,8 @@ impl Message { .any(|m| m.all_fields().any(|f| f.typ.is_map())) { if config.nostd { - writeln!(w, "use alloc::collections::BTreeHashMap;")?; - writeln!(w, "pub type HashMap = BTreeHashMap;")?; + writeln!(w, "use alloc::collections::BTreeMap;")?; + writeln!(w, "pub type HashMap = BTreeMap;")?; } else { writeln!(w, "use std::collections::HashMap;")?; } @@ -2182,8 +2182,8 @@ impl FileDescriptor { .any(|m| m.all_fields().any(|f| f.typ.is_map())) { if config.nostd { - writeln!(w, "use alloc::collections::BTreeHashMap;")?; - writeln!(w, "pub type HashMap = BTreeHashMap;")?; + writeln!(w, "use alloc::collections::BTreeMap;")?; + writeln!(w, "pub type HashMap = BTreeMap;")?; } else { writeln!(w, "use std::collections::HashMap;")?; } diff --git a/quick-protobuf/tests/rust_protobuf/v3/basic.rs b/quick-protobuf/tests/rust_protobuf/v3/basic.rs index d773e301..e6787b67 100644 --- a/quick-protobuf/tests/rust_protobuf/v3/basic.rs +++ b/quick-protobuf/tests/rust_protobuf/v3/basic.rs @@ -9,9 +9,7 @@ #![cfg_attr(rustfmt, rustfmt_skip)] -extern crate alloc; -use alloc::vec::Vec; -use alloc::borrow::Cow; +use std::borrow::Cow; use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; use quick_protobuf::sizeofs::*; use super::*; From 35a94a96b47d6ec23a2683a58ce487786e90cea4 Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Fri, 13 Sep 2019 11:22:24 -0700 Subject: [PATCH 13/30] regenerate nostd test proto --- quick-protobuf/no-std-example/src/protos/no_std.rs | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/quick-protobuf/no-std-example/src/protos/no_std.rs b/quick-protobuf/no-std-example/src/protos/no_std.rs index dc424fc3..9719ba83 100644 --- a/quick-protobuf/no-std-example/src/protos/no_std.rs +++ b/quick-protobuf/no-std-example/src/protos/no_std.rs @@ -9,6 +9,8 @@ #![cfg_attr(rustfmt, rustfmt_skip)] +extern crate alloc; +use alloc::vec::Vec; use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; use quick_protobuf::sizeofs::*; use super::super::*; @@ -81,20 +83,20 @@ impl MessageWrite for EmbeddedMessage { } #[derive(Debug, Default, PartialEq, Clone)] -pub struct NoStdMessage { +pub struct NoStdMessage<'a> { pub num: u32, - pub nums: arrayvec::ArrayVec<[u32; 16]>, + pub nums: Cow<'a, [u32]>, pub message: Option, - pub messages: arrayvec::ArrayVec<[protos::no_std::EmbeddedMessage; 16]>, + pub messages: Vec, } -impl<'a> MessageRead<'a> for NoStdMessage { +impl<'a> MessageRead<'a> for NoStdMessage<'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(13) => msg.num = r.read_fixed32(bytes)?, - Ok(18) => msg.nums = r.read_packed_arrayvec(bytes, |r, bytes| Ok(r.read_fixed32(bytes)?))?, + Ok(18) => msg.nums = r.read_packed_fixed(bytes)?.into(), Ok(26) => msg.message = Some(r.read_message::(bytes)?), Ok(34) => msg.messages.push(r.read_message::(bytes)?), Ok(t) => { r.read_unknown(bytes, t)?; } @@ -105,7 +107,7 @@ impl<'a> MessageRead<'a> for NoStdMessage { } } -impl MessageWrite for NoStdMessage { +impl<'a> MessageWrite for NoStdMessage<'a> { fn get_size(&self) -> usize { 0 + if self.num == 0u32 { 0 } else { 1 + 4 } From 52c8c5f4cb5ddb022afbfa776963ea675dde65dc Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Fri, 13 Sep 2019 11:38:14 -0700 Subject: [PATCH 14/30] packed/fixed fields use Cow, so add the appropriate use statement in nostd mode; regenerate nostd test proto --- pb-rs/src/types.rs | 4 ++-- quick-protobuf/no-std-example/src/protos/no_std.rs | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/pb-rs/src/types.rs b/pb-rs/src/types.rs index 0b5fa8ec..c60340fa 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -854,7 +854,7 @@ impl Message { if self .messages .iter() - .any(|m| m.all_fields().any(|f| f.typ.has_cow())) + .any(|m| m.all_fields().any(|f| (f.typ.has_cow() || (f.packed() && f.typ.is_fixed_size())))) { if config.nostd { writeln!(w, "use alloc::borrow::Cow;")?; @@ -2168,7 +2168,7 @@ impl FileDescriptor { if self .messages .iter() - .any(|m| m.all_fields().any(|f| f.typ.has_cow())) + .any(|m| m.all_fields().any(|f| (f.typ.has_cow() || (f.packed() && f.typ.is_fixed_size())))) { if config.nostd { writeln!(w, "use alloc::borrow::Cow;")?; diff --git a/quick-protobuf/no-std-example/src/protos/no_std.rs b/quick-protobuf/no-std-example/src/protos/no_std.rs index 9719ba83..7a327a9d 100644 --- a/quick-protobuf/no-std-example/src/protos/no_std.rs +++ b/quick-protobuf/no-std-example/src/protos/no_std.rs @@ -11,6 +11,7 @@ extern crate alloc; use alloc::vec::Vec; +use alloc::borrow::Cow; use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; use quick_protobuf::sizeofs::*; use super::super::*; From 3fa017ec5fce3cb40ab9673b0bda9fdcba881a18 Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Fri, 13 Sep 2019 11:52:31 -0700 Subject: [PATCH 15/30] remove alloc Vec in nostd mode since the only code that uses it require std::io --- quick-protobuf/src/writer.rs | 6 ------ 1 file changed, 6 deletions(-) diff --git a/quick-protobuf/src/writer.rs b/quick-protobuf/src/writer.rs index 41c80b51..f98d9707 100644 --- a/quick-protobuf/src/writer.rs +++ b/quick-protobuf/src/writer.rs @@ -8,12 +8,6 @@ use byteorder::{ByteOrder, LittleEndian as LE}; #[cfg(feature = "std")] use byteorder::WriteBytesExt; -#[cfg(not(feature = "std"))] -extern crate alloc; -#[cfg(not(feature = "std"))] -use alloc::vec::Vec; - - /// A struct to write protobuf messages /// /// # Examples From 38ec3733b31fb7e6884f3bcec0ba0db385d639a6 Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Fri, 13 Sep 2019 11:58:30 -0700 Subject: [PATCH 16/30] generate the nostd test modules using the --nostd flag --- generate_modules.sh | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/generate_modules.sh b/generate_modules.sh index 9122f0f4..d8bb1013 100755 --- a/generate_modules.sh +++ b/generate_modules.sh @@ -19,6 +19,9 @@ proto_sets=( quick-protobuf/examples/pb_rs_v3 quick-protobuf/tests/packed_primitives quick-protobuf/tests/rust_protobuf/common +) + +nostd_proto_sets=( quick-protobuf/no-std-example/src ) @@ -26,6 +29,9 @@ for ps in "${proto_sets[@]}"; do cargo run -p pb-rs -- -I "$ps" -d "$ps" "$ps"/*.proto done +for ps in "${nostd_proto_sets[@]}"; do + cargo run -p pb-rs -- --nostd -I "$ps" -d "$ps" "$ps"/*.proto +done rm -rf quick-protobuf/examples/pb_rs_v3/owned mkdir -p quick-protobuf/examples/pb_rs_v3/owned From 9dfa1b1127c3a9f1360b65f758daa578f3f90482 Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Fri, 13 Sep 2019 12:07:18 -0700 Subject: [PATCH 17/30] remove arrayvec test code --- .../tests/rust_protobuf/v3/test_basic.rs | 41 ------------------- 1 file changed, 41 deletions(-) diff --git a/quick-protobuf/tests/rust_protobuf/v3/test_basic.rs b/quick-protobuf/tests/rust_protobuf/v3/test_basic.rs index 1f8bb665..cf032f5d 100644 --- a/quick-protobuf/tests/rust_protobuf/v3/test_basic.rs +++ b/quick-protobuf/tests/rust_protobuf/v3/test_basic.rs @@ -123,47 +123,6 @@ fn test_types_repeated() { message.enum_field = vec![TestEnumDescriptor::BLUE, TestEnumDescriptor::GREEN]; test_serialize_deserialize_length_delimited!(&message, TestTypesRepeated); } -#[test] -fn test_types_repeated_arrayvec() { - let mut message = TestTypesRepeatedArrayVec::default(); - message.double_field.push(19f64); - message.double_field.push(20f64); - - message.float_field.push(20f32); - - message.int32_field.push(21i32); - message.int32_field.push(-22); - message.int32_field.push(23); - - message.int64_field.push(22i64); - - message.uint32_field.push(23u32); - message.uint32_field.push(23); - - message.uint64_field.push(24u64); - - message.sint32_field.push(25i32); - - message.sint64_field.push(26i64); - message.sint64_field.push(-27); - - message.fixed32_field.push(27u32); - - message.fixed64_field.push(28u64); - - message.sfixed32_field.push(29i32); - message.sfixed32_field.push(-30); - - message.sfixed64_field.push(30i64); - - message.bool_field.push(true); - message.bool_field.push(true); - - message.enum_field.push(TestEnumDescriptor::BLUE); - message.enum_field.push(TestEnumDescriptor::GREEN); - - test_serialize_deserialize_length_delimited!(&message, TestTypesRepeatedArrayVec); -} #[test] fn test_types_repeated_packed() { From 22910263a8c5c78e69140f2c6d75f999a8f1af4e Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Fri, 13 Sep 2019 12:13:27 -0700 Subject: [PATCH 18/30] format fixes --- pb-rs/src/lib.rs | 2 +- pb-rs/src/types.rs | 22 ++++++++++------------ 2 files changed, 11 insertions(+), 13 deletions(-) diff --git a/pb-rs/src/lib.rs b/pb-rs/src/lib.rs index 07edfa56..85040831 100644 --- a/pb-rs/src/lib.rs +++ b/pb-rs/src/lib.rs @@ -174,7 +174,7 @@ impl ConfigBuilder { self.nostd = val; self } - + /// Build Config from this ConfigBuilder pub fn build(self) -> Vec { self.in_files diff --git a/pb-rs/src/types.rs b/pb-rs/src/types.rs index c60340fa..6dcb061a 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -851,11 +851,10 @@ impl Message { writeln!(w, "extern crate alloc;")?; writeln!(w, "use alloc::vec::Vec;")?; } - if self - .messages - .iter() - .any(|m| m.all_fields().any(|f| (f.typ.has_cow() || (f.packed() && f.typ.is_fixed_size())))) - { + if self.messages.iter().any(|m| { + m.all_fields() + .any(|f| (f.typ.has_cow() || (f.packed() && f.typ.is_fixed_size()))) + }) { if config.nostd { writeln!(w, "use alloc::borrow::Cow;")?; } else { @@ -2159,17 +2158,16 @@ impl FileDescriptor { )?; return Ok(()); } - + if config.nostd { writeln!(w, "extern crate alloc;")?; writeln!(w, "use alloc::vec::Vec;")?; } - - if self - .messages - .iter() - .any(|m| m.all_fields().any(|f| (f.typ.has_cow() || (f.packed() && f.typ.is_fixed_size())))) - { + + if self.messages.iter().any(|m| { + m.all_fields() + .any(|f| (f.typ.has_cow() || (f.packed() && f.typ.is_fixed_size()))) + }) { if config.nostd { writeln!(w, "use alloc::borrow::Cow;")?; } else { From ca414b28a9ff886e40dc29f170a5952f722d68c6 Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Fri, 13 Sep 2019 14:44:00 -0700 Subject: [PATCH 19/30] copy_from_slice requires both slices to have equal length --- quick-protobuf/src/writer.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/quick-protobuf/src/writer.rs b/quick-protobuf/src/writer.rs index f98d9707..92ac37a1 100644 --- a/quick-protobuf/src/writer.rs +++ b/quick-protobuf/src/writer.rs @@ -457,7 +457,7 @@ impl<'a> WriterBackend for BytesWriter<'a> { if self.buf.len() - self.cursor < buf.len() { Err(Error::UnexpectedEndOfBuffer) } else { - self.buf[self.cursor..].copy_from_slice(buf); + self.buf[self.cursor..(self.cursor+buf.len())].copy_from_slice(buf); self.cursor += buf.len(); Ok(()) } From 5ccfe712ed22e4608ce489ecbf31b91a738b881d Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Fri, 13 Sep 2019 14:50:13 -0700 Subject: [PATCH 20/30] fmt fixes --- quick-protobuf/src/writer.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/quick-protobuf/src/writer.rs b/quick-protobuf/src/writer.rs index 92ac37a1..300eed2e 100644 --- a/quick-protobuf/src/writer.rs +++ b/quick-protobuf/src/writer.rs @@ -457,7 +457,7 @@ impl<'a> WriterBackend for BytesWriter<'a> { if self.buf.len() - self.cursor < buf.len() { Err(Error::UnexpectedEndOfBuffer) } else { - self.buf[self.cursor..(self.cursor+buf.len())].copy_from_slice(buf); + self.buf[self.cursor..(self.cursor + buf.len())].copy_from_slice(buf); self.cursor += buf.len(); Ok(()) } From a2a06c239053874e6c06a798a1b43350d6a41b1e Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Mon, 30 Sep 2019 14:51:56 -0700 Subject: [PATCH 21/30] remove generated files; remove ArrayVec type from test proto --- perftest/src/perftest_data.rs | 2130 ----------------- .../tests/rust_protobuf/v3/basic.rs | 868 ------- .../rust_protobuf/v3/test_basic_pb.proto | 17 - 3 files changed, 3015 deletions(-) delete mode 100644 perftest/src/perftest_data.rs delete mode 100644 quick-protobuf/tests/rust_protobuf/v3/basic.rs diff --git a/perftest/src/perftest_data.rs b/perftest/src/perftest_data.rs deleted file mode 100644 index 63e9a1a0..00000000 --- a/perftest/src/perftest_data.rs +++ /dev/null @@ -1,2130 +0,0 @@ -// This file is generated by rust-protobuf 2.8.1. Do not edit -// @generated - -// 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(unused_imports)] -#![allow(unused_results)] -//! Generated file from `perftest_data.proto` - -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_1; - -#[derive(PartialEq,Clone,Default)] -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); - } -} - -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 ::protobuf::Clear for Test1 { - fn clear(&mut self) { - self.value = ::std::option::Option::None; - self.unknown_fields.clear(); - } -} - -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) - } -} - -#[derive(PartialEq,Clone,Default)] -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()) - } -} - -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 ::protobuf::Clear for TestRepeatedBool { - fn clear(&mut self) { - self.values.clear(); - self.unknown_fields.clear(); - } -} - -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) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct TestRepeatedPackedInt32 { - // 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 TestRepeatedPackedInt32 { - fn default() -> &'a TestRepeatedPackedInt32 { - ::default_instance() - } -} - -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 - } - - // Take field - pub fn take_values(&mut self) -> ::std::vec::Vec { - ::std::mem::replace(&mut self.values, ::std::vec::Vec::new()) - } -} - -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)?; - }; - } - 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() - } - - 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() - ) - }) - } - } - - 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) - } - } -} - -impl ::protobuf::Clear for TestRepeatedPackedInt32 { - fn clear(&mut self) { - self.values.clear(); - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for TestRepeatedPackedInt32 { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for TestRepeatedPackedInt32 { - fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { - ::protobuf::reflect::ProtobufValueRef::Message(self) - } -} - -#[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, -} - -impl<'a> ::std::default::Default for &'a TestRepeatedMessages { - fn default() -> &'a TestRepeatedMessages { - ::default_instance() - } -} - -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()) - } - - // 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 - } - - // Take field - pub fn take_messages3(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.messages3, ::protobuf::RepeatedField::new()) - } -} - -impl ::protobuf::Message for TestRepeatedMessages { - fn is_initialized(&self) -> bool { - for v in &self.messages1 { - if !v.is_initialized() { - return false; - } - }; - 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) - } - } -} - -impl ::protobuf::Clear for TestRepeatedMessages { - fn clear(&mut self) { - self.messages1.clear(); - self.messages2.clear(); - self.messages3.clear(); - self.unknown_fields.clear(); - } -} - -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) - } -} - -#[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() - } -} - -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(); - } - 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); - } - - // 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() - } - - // Take field - pub fn take_message3(&mut self) -> TestOptionalMessages { - self.message3.take().unwrap_or_else(|| TestOptionalMessages::new()) - } -} - -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/tests/rust_protobuf/v3/basic.rs b/quick-protobuf/tests/rust_protobuf/v3/basic.rs deleted file mode 100644 index e6787b67..00000000 --- a/quick-protobuf/tests/rust_protobuf/v3/basic.rs +++ /dev/null @@ -1,868 +0,0 @@ -// Automatically generated rust module for 'test_basic_pb.proto' file - -#![allow(non_snake_case)] -#![allow(non_upper_case_globals)] -#![allow(non_camel_case_types)] -#![allow(unused_imports)] -#![allow(unknown_lints)] -#![allow(clippy)] -#![cfg_attr(rustfmt, rustfmt_skip)] - - -use std::borrow::Cow; -use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; -use quick_protobuf::sizeofs::*; -use super::*; - -#[derive(Debug, PartialEq, Eq, Clone, Copy)] -pub enum TestEnumDescriptor { - UNKNOWN = 0, - RED = 1, - BLUE = 2, - GREEN = 3, -} - -impl Default for TestEnumDescriptor { - fn default() -> Self { - TestEnumDescriptor::UNKNOWN - } -} - -impl From for TestEnumDescriptor { - fn from(i: i32) -> Self { - match i { - 0 => TestEnumDescriptor::UNKNOWN, - 1 => TestEnumDescriptor::RED, - 2 => TestEnumDescriptor::BLUE, - 3 => TestEnumDescriptor::GREEN, - _ => Self::default(), - } - } -} - -impl<'a> From<&'a str> for TestEnumDescriptor { - fn from(s: &'a str) -> Self { - match s { - "UNKNOWN" => TestEnumDescriptor::UNKNOWN, - "RED" => TestEnumDescriptor::RED, - "BLUE" => TestEnumDescriptor::BLUE, - "GREEN" => TestEnumDescriptor::GREEN, - _ => Self::default(), - } - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct Test1 { - pub a: i32, -} - -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.a = r.read_int32(bytes)?, - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl MessageWrite for Test1 { - fn get_size(&self) -> usize { - 0 - + if self.a == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.a) as u64) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if self.a != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.a))?; } - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct Test2<'a> { - pub b: Cow<'a, str>, -} - -impl<'a> MessageRead<'a> for Test2<'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(18) => msg.b = r.read_string(bytes).map(Cow::Borrowed)?, - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl<'a> MessageWrite for Test2<'a> { - fn get_size(&self) -> usize { - 0 - + if self.b == "" { 0 } else { 1 + sizeof_len((&self.b).len()) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if self.b != "" { w.write_with_tag(18, |w| w.write_string(&**&self.b))?; } - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct Test3 { - pub c: Option, -} - -impl<'a> MessageRead<'a> for Test3 { - 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(26) => msg.c = Some(r.read_message::(bytes)?), - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl MessageWrite for Test3 { - fn get_size(&self) -> usize { - 0 - + self.c.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if let Some(ref s) = self.c { w.write_with_tag(26, |w| w.write_message(s))?; } - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct Test4 { - pub d: Vec, -} - -impl<'a> MessageRead<'a> for Test4 { - 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(34) => msg.d = 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 MessageWrite for Test4 { - fn get_size(&self) -> usize { - 0 - + if self.d.is_empty() { 0 } else { 1 + sizeof_len(self.d.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - w.write_packed_with_tag(34, &self.d, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?; - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestPackedUnpacked { - pub unpacked: Vec, - pub packed: Vec, -} - -impl<'a> MessageRead<'a> for TestPackedUnpacked { - 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(32) => msg.unpacked.push(r.read_int32(bytes)?), - Ok(42) => msg.packed = 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 MessageWrite for TestPackedUnpacked { - fn get_size(&self) -> usize { - 0 - + self.unpacked.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() - + if self.packed.is_empty() { 0 } else { 1 + sizeof_len(self.packed.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - for s in &self.unpacked { w.write_with_tag(32, |w| w.write_int32(*s))?; } - w.write_packed_with_tag(42, &self.packed, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?; - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestEmpty { - pub foo: i32, -} - -impl<'a> MessageRead<'a> for TestEmpty { - 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(80) => msg.foo = r.read_int32(bytes)?, - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl MessageWrite for TestEmpty { - fn get_size(&self) -> usize { - 0 - + if self.foo == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.foo) as u64) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if self.foo != 0i32 { w.write_with_tag(80, |w| w.write_int32(*&self.foo))?; } - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct Test { - pub b: bool, -} - -impl<'a> MessageRead<'a> for Test { - 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(40) => msg.b = r.read_bool(bytes)?, - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl MessageWrite for Test { - fn get_size(&self) -> usize { - 0 - + if self.b == false { 0 } else { 1 + sizeof_varint(*(&self.b) as u64) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if self.b != false { w.write_with_tag(40, |w| w.write_bool(*&self.b))?; } - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestUnknownFields { - pub a: i32, -} - -impl<'a> MessageRead<'a> for TestUnknownFields { - 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.a = r.read_int32(bytes)?, - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl MessageWrite for TestUnknownFields { - fn get_size(&self) -> usize { - 0 - + if self.a == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.a) as u64) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if self.a != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.a))?; } - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestSelfReference { - pub r1: Option>, - pub r2: Option>, -} - -impl<'a> MessageRead<'a> for TestSelfReference { - 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.r1 = Some(Box::new(r.read_message::(bytes)?)), - Ok(18) => msg.r2 = Some(Box::new(r.read_message::(bytes)?)), - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl MessageWrite for TestSelfReference { - fn get_size(&self) -> usize { - 0 - + self.r1.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) - + self.r2.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if let Some(ref s) = self.r1 { w.write_with_tag(10, |w| w.write_message(&**s))?; } - if let Some(ref s) = self.r2 { w.write_with_tag(18, |w| w.write_message(&**s))?; } - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestDefaultInstanceField<'a> { - pub s: Cow<'a, str>, -} - -impl<'a> MessageRead<'a> for TestDefaultInstanceField<'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.s = r.read_string(bytes).map(Cow::Borrowed)?, - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl<'a> MessageWrite for TestDefaultInstanceField<'a> { - fn get_size(&self) -> usize { - 0 - + if self.s == "" { 0 } else { 1 + sizeof_len((&self.s).len()) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if self.s != "" { w.write_with_tag(10, |w| w.write_string(&**&self.s))?; } - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestDefaultInstance<'a> { - pub field: Option>, -} - -impl<'a> MessageRead<'a> for TestDefaultInstance<'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.field = Some(r.read_message::(bytes)?), - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl<'a> MessageWrite for TestDefaultInstance<'a> { - fn get_size(&self) -> usize { - 0 - + self.field.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if let Some(ref s) = self.field { w.write_with_tag(10, |w| w.write_message(s))?; } - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestDescriptor { - pub stuff: i32, -} - -impl<'a> MessageRead<'a> for TestDescriptor { - 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(80) => msg.stuff = r.read_int32(bytes)?, - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl MessageWrite for TestDescriptor { - fn get_size(&self) -> usize { - 0 - + if self.stuff == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.stuff) as u64) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if self.stuff != 0i32 { w.write_with_tag(80, |w| w.write_int32(*&self.stuff))?; } - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestTypesSingular<'a> { - pub double_field: f64, - pub float_field: f32, - pub int32_field: i32, - pub int64_field: i64, - pub uint32_field: u32, - pub uint64_field: u64, - pub sint32_field: i32, - pub sint64_field: i64, - pub fixed32_field: u32, - pub fixed64_field: u64, - pub sfixed32_field: i32, - pub sfixed64_field: i64, - pub bool_field: bool, - pub string_field: Cow<'a, str>, - pub bytes_field: Cow<'a, [u8]>, - pub enum_field: basic::TestEnumDescriptor, -} - -impl<'a> MessageRead<'a> for TestTypesSingular<'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(9) => msg.double_field = r.read_double(bytes)?, - Ok(21) => msg.float_field = r.read_float(bytes)?, - Ok(24) => msg.int32_field = r.read_int32(bytes)?, - Ok(32) => msg.int64_field = r.read_int64(bytes)?, - Ok(40) => msg.uint32_field = r.read_uint32(bytes)?, - Ok(48) => msg.uint64_field = r.read_uint64(bytes)?, - Ok(56) => msg.sint32_field = r.read_sint32(bytes)?, - Ok(64) => msg.sint64_field = r.read_sint64(bytes)?, - Ok(77) => msg.fixed32_field = r.read_fixed32(bytes)?, - Ok(81) => msg.fixed64_field = r.read_fixed64(bytes)?, - Ok(93) => msg.sfixed32_field = r.read_sfixed32(bytes)?, - Ok(97) => msg.sfixed64_field = r.read_sfixed64(bytes)?, - Ok(104) => msg.bool_field = r.read_bool(bytes)?, - Ok(114) => msg.string_field = r.read_string(bytes).map(Cow::Borrowed)?, - Ok(122) => msg.bytes_field = r.read_bytes(bytes).map(Cow::Borrowed)?, - Ok(128) => msg.enum_field = r.read_enum(bytes)?, - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl<'a> MessageWrite for TestTypesSingular<'a> { - fn get_size(&self) -> usize { - 0 - + if self.double_field == 0f64 { 0 } else { 1 + 8 } - + if self.float_field == 0f32 { 0 } else { 1 + 4 } - + if self.int32_field == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.int32_field) as u64) } - + if self.int64_field == 0i64 { 0 } else { 1 + sizeof_varint(*(&self.int64_field) as u64) } - + if self.uint32_field == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.uint32_field) as u64) } - + if self.uint64_field == 0u64 { 0 } else { 1 + sizeof_varint(*(&self.uint64_field) as u64) } - + if self.sint32_field == 0i32 { 0 } else { 1 + sizeof_sint32(*(&self.sint32_field)) } - + if self.sint64_field == 0i64 { 0 } else { 1 + sizeof_sint64(*(&self.sint64_field)) } - + if self.fixed32_field == 0u32 { 0 } else { 1 + 4 } - + if self.fixed64_field == 0u64 { 0 } else { 1 + 8 } - + if self.sfixed32_field == 0i32 { 0 } else { 1 + 4 } - + if self.sfixed64_field == 0i64 { 0 } else { 1 + 8 } - + if self.bool_field == false { 0 } else { 1 + sizeof_varint(*(&self.bool_field) as u64) } - + if self.string_field == "" { 0 } else { 1 + sizeof_len((&self.string_field).len()) } - + if self.bytes_field == Cow::Borrowed(b"") { 0 } else { 1 + sizeof_len((&self.bytes_field).len()) } - + if self.enum_field == basic::TestEnumDescriptor::UNKNOWN { 0 } else { 2 + sizeof_varint(*(&self.enum_field) as u64) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if self.double_field != 0f64 { w.write_with_tag(9, |w| w.write_double(*&self.double_field))?; } - if self.float_field != 0f32 { w.write_with_tag(21, |w| w.write_float(*&self.float_field))?; } - if self.int32_field != 0i32 { w.write_with_tag(24, |w| w.write_int32(*&self.int32_field))?; } - if self.int64_field != 0i64 { w.write_with_tag(32, |w| w.write_int64(*&self.int64_field))?; } - if self.uint32_field != 0u32 { w.write_with_tag(40, |w| w.write_uint32(*&self.uint32_field))?; } - if self.uint64_field != 0u64 { w.write_with_tag(48, |w| w.write_uint64(*&self.uint64_field))?; } - if self.sint32_field != 0i32 { w.write_with_tag(56, |w| w.write_sint32(*&self.sint32_field))?; } - if self.sint64_field != 0i64 { w.write_with_tag(64, |w| w.write_sint64(*&self.sint64_field))?; } - if self.fixed32_field != 0u32 { w.write_with_tag(77, |w| w.write_fixed32(*&self.fixed32_field))?; } - if self.fixed64_field != 0u64 { w.write_with_tag(81, |w| w.write_fixed64(*&self.fixed64_field))?; } - if self.sfixed32_field != 0i32 { w.write_with_tag(93, |w| w.write_sfixed32(*&self.sfixed32_field))?; } - if self.sfixed64_field != 0i64 { w.write_with_tag(97, |w| w.write_sfixed64(*&self.sfixed64_field))?; } - if self.bool_field != false { w.write_with_tag(104, |w| w.write_bool(*&self.bool_field))?; } - if self.string_field != "" { w.write_with_tag(114, |w| w.write_string(&**&self.string_field))?; } - if self.bytes_field != Cow::Borrowed(b"") { w.write_with_tag(122, |w| w.write_bytes(&**&self.bytes_field))?; } - if self.enum_field != basic::TestEnumDescriptor::UNKNOWN { w.write_with_tag(128, |w| w.write_enum(*&self.enum_field as i32))?; } - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestTypesRepeated<'a> { - pub double_field: Vec, - pub float_field: Vec, - pub int32_field: Vec, - pub int64_field: Vec, - pub uint32_field: Vec, - pub uint64_field: Vec, - pub sint32_field: Vec, - pub sint64_field: Vec, - pub fixed32_field: Vec, - pub fixed64_field: Vec, - pub sfixed32_field: Vec, - pub sfixed64_field: Vec, - pub bool_field: Vec, - pub string_field: Vec>, - pub bytes_field: Vec>, - pub enum_field: Vec, -} - -impl<'a> MessageRead<'a> for TestTypesRepeated<'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(9) => msg.double_field.push(r.read_double(bytes)?), - Ok(21) => msg.float_field.push(r.read_float(bytes)?), - Ok(24) => msg.int32_field.push(r.read_int32(bytes)?), - Ok(32) => msg.int64_field.push(r.read_int64(bytes)?), - Ok(40) => msg.uint32_field.push(r.read_uint32(bytes)?), - Ok(48) => msg.uint64_field.push(r.read_uint64(bytes)?), - Ok(56) => msg.sint32_field.push(r.read_sint32(bytes)?), - Ok(64) => msg.sint64_field.push(r.read_sint64(bytes)?), - Ok(77) => msg.fixed32_field.push(r.read_fixed32(bytes)?), - Ok(81) => msg.fixed64_field.push(r.read_fixed64(bytes)?), - Ok(93) => msg.sfixed32_field.push(r.read_sfixed32(bytes)?), - Ok(97) => msg.sfixed64_field.push(r.read_sfixed64(bytes)?), - Ok(104) => msg.bool_field.push(r.read_bool(bytes)?), - Ok(114) => msg.string_field.push(r.read_string(bytes).map(Cow::Borrowed)?), - Ok(122) => msg.bytes_field.push(r.read_bytes(bytes).map(Cow::Borrowed)?), - Ok(128) => msg.enum_field.push(r.read_enum(bytes)?), - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl<'a> MessageWrite for TestTypesRepeated<'a> { - fn get_size(&self) -> usize { - 0 - + (1 + 8) * self.double_field.len() - + (1 + 4) * self.float_field.len() - + self.int32_field.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() - + self.int64_field.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() - + self.uint32_field.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() - + self.uint64_field.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() - + self.sint32_field.iter().map(|s| 1 + sizeof_sint32(*(s))).sum::() - + self.sint64_field.iter().map(|s| 1 + sizeof_sint64(*(s))).sum::() - + (1 + 4) * self.fixed32_field.len() - + (1 + 8) * self.fixed64_field.len() - + (1 + 4) * self.sfixed32_field.len() - + (1 + 8) * self.sfixed64_field.len() - + self.bool_field.iter().map(|s| 1 + sizeof_varint(*(s) as u64)).sum::() - + self.string_field.iter().map(|s| 1 + sizeof_len((s).len())).sum::() - + self.bytes_field.iter().map(|s| 1 + sizeof_len((s).len())).sum::() - + self.enum_field.iter().map(|s| 2 + sizeof_varint(*(s) as u64)).sum::() - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - for s in &self.double_field { w.write_with_tag(9, |w| w.write_double(*s))?; } - for s in &self.float_field { w.write_with_tag(21, |w| w.write_float(*s))?; } - for s in &self.int32_field { w.write_with_tag(24, |w| w.write_int32(*s))?; } - for s in &self.int64_field { w.write_with_tag(32, |w| w.write_int64(*s))?; } - for s in &self.uint32_field { w.write_with_tag(40, |w| w.write_uint32(*s))?; } - for s in &self.uint64_field { w.write_with_tag(48, |w| w.write_uint64(*s))?; } - for s in &self.sint32_field { w.write_with_tag(56, |w| w.write_sint32(*s))?; } - for s in &self.sint64_field { w.write_with_tag(64, |w| w.write_sint64(*s))?; } - for s in &self.fixed32_field { w.write_with_tag(77, |w| w.write_fixed32(*s))?; } - for s in &self.fixed64_field { w.write_with_tag(81, |w| w.write_fixed64(*s))?; } - for s in &self.sfixed32_field { w.write_with_tag(93, |w| w.write_sfixed32(*s))?; } - for s in &self.sfixed64_field { w.write_with_tag(97, |w| w.write_sfixed64(*s))?; } - for s in &self.bool_field { w.write_with_tag(104, |w| w.write_bool(*s))?; } - for s in &self.string_field { w.write_with_tag(114, |w| w.write_string(&**s))?; } - for s in &self.bytes_field { w.write_with_tag(122, |w| w.write_bytes(&**s))?; } - for s in &self.enum_field { w.write_with_tag(128, |w| w.write_enum(*s as i32))?; } - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestTypesRepeatedArrayVec<'a> { - pub double_field: Cow<'a, [f64]>, - pub float_field: Cow<'a, [f32]>, - pub int32_field: Vec, - pub int64_field: Vec, - pub uint32_field: Vec, - pub uint64_field: Vec, - pub sint32_field: Vec, - pub sint64_field: Vec, - pub fixed32_field: Cow<'a, [u32]>, - pub fixed64_field: Cow<'a, [u64]>, - pub sfixed32_field: Cow<'a, [i32]>, - pub sfixed64_field: Cow<'a, [i64]>, - pub bool_field: Vec, - pub enum_field: Vec, -} - -impl<'a> MessageRead<'a> for TestTypesRepeatedArrayVec<'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.double_field = r.read_packed_fixed(bytes)?.into(), - Ok(18) => msg.float_field = r.read_packed_fixed(bytes)?.into(), - Ok(26) => msg.int32_field = r.read_packed(bytes, |r, bytes| Ok(r.read_int32(bytes)?))?, - Ok(34) => msg.int64_field = r.read_packed(bytes, |r, bytes| Ok(r.read_int64(bytes)?))?, - Ok(42) => msg.uint32_field = r.read_packed(bytes, |r, bytes| Ok(r.read_uint32(bytes)?))?, - Ok(50) => msg.uint64_field = r.read_packed(bytes, |r, bytes| Ok(r.read_uint64(bytes)?))?, - Ok(58) => msg.sint32_field = r.read_packed(bytes, |r, bytes| Ok(r.read_sint32(bytes)?))?, - Ok(66) => msg.sint64_field = r.read_packed(bytes, |r, bytes| Ok(r.read_sint64(bytes)?))?, - Ok(74) => msg.fixed32_field = r.read_packed_fixed(bytes)?.into(), - Ok(82) => msg.fixed64_field = r.read_packed_fixed(bytes)?.into(), - Ok(90) => msg.sfixed32_field = r.read_packed_fixed(bytes)?.into(), - Ok(98) => msg.sfixed64_field = r.read_packed_fixed(bytes)?.into(), - Ok(106) => msg.bool_field = r.read_packed(bytes, |r, bytes| Ok(r.read_bool(bytes)?))?, - Ok(114) => msg.enum_field = r.read_packed(bytes, |r, bytes| Ok(r.read_enum(bytes)?))?, - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl<'a> MessageWrite for TestTypesRepeatedArrayVec<'a> { - fn get_size(&self) -> usize { - 0 - + if self.double_field.is_empty() { 0 } else { 1 + sizeof_len(self.double_field.len() * 8) } - + if self.float_field.is_empty() { 0 } else { 1 + sizeof_len(self.float_field.len() * 4) } - + if self.int32_field.is_empty() { 0 } else { 1 + sizeof_len(self.int32_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - + if self.int64_field.is_empty() { 0 } else { 1 + sizeof_len(self.int64_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - + if self.uint32_field.is_empty() { 0 } else { 1 + sizeof_len(self.uint32_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - + if self.uint64_field.is_empty() { 0 } else { 1 + sizeof_len(self.uint64_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - + if self.sint32_field.is_empty() { 0 } else { 1 + sizeof_len(self.sint32_field.iter().map(|s| sizeof_sint32(*(s))).sum::()) } - + if self.sint64_field.is_empty() { 0 } else { 1 + sizeof_len(self.sint64_field.iter().map(|s| sizeof_sint64(*(s))).sum::()) } - + if self.fixed32_field.is_empty() { 0 } else { 1 + sizeof_len(self.fixed32_field.len() * 4) } - + if self.fixed64_field.is_empty() { 0 } else { 1 + sizeof_len(self.fixed64_field.len() * 8) } - + if self.sfixed32_field.is_empty() { 0 } else { 1 + sizeof_len(self.sfixed32_field.len() * 4) } - + if self.sfixed64_field.is_empty() { 0 } else { 1 + sizeof_len(self.sfixed64_field.len() * 8) } - + if self.bool_field.is_empty() { 0 } else { 1 + sizeof_len(self.bool_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - + if self.enum_field.is_empty() { 0 } else { 1 + sizeof_len(self.enum_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - w.write_packed_fixed_with_tag(10, &self.double_field)?; - w.write_packed_fixed_with_tag(18, &self.float_field)?; - w.write_packed_with_tag(26, &self.int32_field, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?; - w.write_packed_with_tag(34, &self.int64_field, |w, m| w.write_int64(*m), &|m| sizeof_varint(*(m) as u64))?; - w.write_packed_with_tag(42, &self.uint32_field, |w, m| w.write_uint32(*m), &|m| sizeof_varint(*(m) as u64))?; - w.write_packed_with_tag(50, &self.uint64_field, |w, m| w.write_uint64(*m), &|m| sizeof_varint(*(m) as u64))?; - w.write_packed_with_tag(58, &self.sint32_field, |w, m| w.write_sint32(*m), &|m| sizeof_sint32(*(m)))?; - w.write_packed_with_tag(66, &self.sint64_field, |w, m| w.write_sint64(*m), &|m| sizeof_sint64(*(m)))?; - w.write_packed_fixed_with_tag(74, &self.fixed32_field)?; - w.write_packed_fixed_with_tag(82, &self.fixed64_field)?; - w.write_packed_fixed_with_tag(90, &self.sfixed32_field)?; - w.write_packed_fixed_with_tag(98, &self.sfixed64_field)?; - w.write_packed_with_tag(106, &self.bool_field, |w, m| w.write_bool(*m), &|m| sizeof_varint(*(m) as u64))?; - w.write_packed_with_tag(114, &self.enum_field, |w, m| w.write_enum(*m as i32), &|m| sizeof_varint(*(m) as u64))?; - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestTypesRepeatedPacked<'a> { - pub double_field: Cow<'a, [f64]>, - pub float_field: Cow<'a, [f32]>, - pub int32_field: Vec, - pub int64_field: Vec, - pub uint32_field: Vec, - pub uint64_field: Vec, - pub sint32_field: Vec, - pub sint64_field: Vec, - pub fixed32_field: Cow<'a, [u32]>, - pub fixed64_field: Cow<'a, [u64]>, - pub sfixed32_field: Cow<'a, [i32]>, - pub sfixed64_field: Cow<'a, [i64]>, - pub bool_field: Vec, - pub string_field: Vec>, - pub bytes_field: Vec>, - pub enum_field: Vec, -} - -impl<'a> MessageRead<'a> for TestTypesRepeatedPacked<'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.double_field = r.read_packed_fixed(bytes)?.into(), - Ok(18) => msg.float_field = r.read_packed_fixed(bytes)?.into(), - Ok(26) => msg.int32_field = r.read_packed(bytes, |r, bytes| Ok(r.read_int32(bytes)?))?, - Ok(34) => msg.int64_field = r.read_packed(bytes, |r, bytes| Ok(r.read_int64(bytes)?))?, - Ok(42) => msg.uint32_field = r.read_packed(bytes, |r, bytes| Ok(r.read_uint32(bytes)?))?, - Ok(50) => msg.uint64_field = r.read_packed(bytes, |r, bytes| Ok(r.read_uint64(bytes)?))?, - Ok(58) => msg.sint32_field = r.read_packed(bytes, |r, bytes| Ok(r.read_sint32(bytes)?))?, - Ok(66) => msg.sint64_field = r.read_packed(bytes, |r, bytes| Ok(r.read_sint64(bytes)?))?, - Ok(74) => msg.fixed32_field = r.read_packed_fixed(bytes)?.into(), - Ok(82) => msg.fixed64_field = r.read_packed_fixed(bytes)?.into(), - Ok(90) => msg.sfixed32_field = r.read_packed_fixed(bytes)?.into(), - Ok(98) => msg.sfixed64_field = r.read_packed_fixed(bytes)?.into(), - Ok(106) => msg.bool_field = r.read_packed(bytes, |r, bytes| Ok(r.read_bool(bytes)?))?, - Ok(114) => msg.string_field.push(r.read_string(bytes).map(Cow::Borrowed)?), - Ok(122) => msg.bytes_field.push(r.read_bytes(bytes).map(Cow::Borrowed)?), - Ok(130) => msg.enum_field = r.read_packed(bytes, |r, bytes| Ok(r.read_enum(bytes)?))?, - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl<'a> MessageWrite for TestTypesRepeatedPacked<'a> { - fn get_size(&self) -> usize { - 0 - + if self.double_field.is_empty() { 0 } else { 1 + sizeof_len(self.double_field.len() * 8) } - + if self.float_field.is_empty() { 0 } else { 1 + sizeof_len(self.float_field.len() * 4) } - + if self.int32_field.is_empty() { 0 } else { 1 + sizeof_len(self.int32_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - + if self.int64_field.is_empty() { 0 } else { 1 + sizeof_len(self.int64_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - + if self.uint32_field.is_empty() { 0 } else { 1 + sizeof_len(self.uint32_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - + if self.uint64_field.is_empty() { 0 } else { 1 + sizeof_len(self.uint64_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - + if self.sint32_field.is_empty() { 0 } else { 1 + sizeof_len(self.sint32_field.iter().map(|s| sizeof_sint32(*(s))).sum::()) } - + if self.sint64_field.is_empty() { 0 } else { 1 + sizeof_len(self.sint64_field.iter().map(|s| sizeof_sint64(*(s))).sum::()) } - + if self.fixed32_field.is_empty() { 0 } else { 1 + sizeof_len(self.fixed32_field.len() * 4) } - + if self.fixed64_field.is_empty() { 0 } else { 1 + sizeof_len(self.fixed64_field.len() * 8) } - + if self.sfixed32_field.is_empty() { 0 } else { 1 + sizeof_len(self.sfixed32_field.len() * 4) } - + if self.sfixed64_field.is_empty() { 0 } else { 1 + sizeof_len(self.sfixed64_field.len() * 8) } - + if self.bool_field.is_empty() { 0 } else { 1 + sizeof_len(self.bool_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - + self.string_field.iter().map(|s| 1 + sizeof_len((s).len())).sum::() - + self.bytes_field.iter().map(|s| 1 + sizeof_len((s).len())).sum::() - + if self.enum_field.is_empty() { 0 } else { 2 + sizeof_len(self.enum_field.iter().map(|s| sizeof_varint(*(s) as u64)).sum::()) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - w.write_packed_fixed_with_tag(10, &self.double_field)?; - w.write_packed_fixed_with_tag(18, &self.float_field)?; - w.write_packed_with_tag(26, &self.int32_field, |w, m| w.write_int32(*m), &|m| sizeof_varint(*(m) as u64))?; - w.write_packed_with_tag(34, &self.int64_field, |w, m| w.write_int64(*m), &|m| sizeof_varint(*(m) as u64))?; - w.write_packed_with_tag(42, &self.uint32_field, |w, m| w.write_uint32(*m), &|m| sizeof_varint(*(m) as u64))?; - w.write_packed_with_tag(50, &self.uint64_field, |w, m| w.write_uint64(*m), &|m| sizeof_varint(*(m) as u64))?; - w.write_packed_with_tag(58, &self.sint32_field, |w, m| w.write_sint32(*m), &|m| sizeof_sint32(*(m)))?; - w.write_packed_with_tag(66, &self.sint64_field, |w, m| w.write_sint64(*m), &|m| sizeof_sint64(*(m)))?; - w.write_packed_fixed_with_tag(74, &self.fixed32_field)?; - w.write_packed_fixed_with_tag(82, &self.fixed64_field)?; - w.write_packed_fixed_with_tag(90, &self.sfixed32_field)?; - w.write_packed_fixed_with_tag(98, &self.sfixed64_field)?; - w.write_packed_with_tag(106, &self.bool_field, |w, m| w.write_bool(*m), &|m| sizeof_varint(*(m) as u64))?; - for s in &self.string_field { w.write_with_tag(114, |w| w.write_string(&**s))?; } - for s in &self.bytes_field { w.write_with_tag(122, |w| w.write_bytes(&**s))?; } - w.write_packed_with_tag(130, &self.enum_field, |w, m| w.write_enum(*m as i32), &|m| sizeof_varint(*(m) as u64))?; - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestInvalidTag { } - -impl<'a> MessageRead<'a> for TestInvalidTag { - fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result { - r.read_to_end(); - Ok(Self::default()) - } -} - -impl MessageWrite for TestInvalidTag { } - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestTruncated<'a> { - pub ints: Cow<'a, [u32]>, -} - -impl<'a> MessageRead<'a> for TestTruncated<'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(18) => msg.ints = r.read_packed_fixed(bytes)?.into(), - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl<'a> MessageWrite for TestTruncated<'a> { - fn get_size(&self) -> usize { - 0 - + if self.ints.is_empty() { 0 } else { 1 + sizeof_len(self.ints.len() * 4) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - w.write_packed_fixed_with_tag(18, &self.ints)?; - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct TestBugSint { - pub s32: i32, - pub s64: i64, -} - -impl<'a> MessageRead<'a> for TestBugSint { - 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.s32 = r.read_sint32(bytes)?, - Ok(16) => msg.s64 = r.read_sint64(bytes)?, - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl MessageWrite for TestBugSint { - fn get_size(&self) -> usize { - 0 - + if self.s32 == 0i32 { 0 } else { 1 + sizeof_sint32(*(&self.s32)) } - + if self.s64 == 0i64 { 0 } else { 1 + sizeof_sint64(*(&self.s64)) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if self.s32 != 0i32 { w.write_with_tag(8, |w| w.write_sint32(*&self.s32))?; } - if self.s64 != 0i64 { w.write_with_tag(16, |w| w.write_sint64(*&self.s64))?; } - Ok(()) - } -} - 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 20612a50..c0b04227 100644 --- a/quick-protobuf/tests/rust_protobuf/v3/test_basic_pb.proto +++ b/quick-protobuf/tests/rust_protobuf/v3/test_basic_pb.proto @@ -99,23 +99,6 @@ message TestTypesRepeated { repeated TestEnumDescriptor enum_field = 16 [packed=false]; } -message TestTypesRepeatedArrayVec { - repeated double double_field = 1; - repeated float float_field = 2; - repeated int32 int32_field = 3; - repeated int64 int64_field = 4; - repeated uint32 uint32_field = 5; - repeated uint64 uint64_field = 6; - repeated sint32 sint32_field = 7; - repeated sint64 sint64_field = 8; - repeated fixed32 fixed32_field = 9; - repeated fixed64 fixed64_field = 10; - repeated sfixed32 sfixed32_field = 11; - repeated sfixed64 sfixed64_field = 12; - repeated bool bool_field = 13; - repeated TestEnumDescriptor enum_field = 14; -} - message TestTypesRepeatedPacked { repeated double double_field = 1 [packed=true]; repeated float float_field = 2 [packed=true]; From fcae141974fd4f0b4bec46d844e0305c83a06a58 Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Mon, 30 Sep 2019 17:07:14 -0700 Subject: [PATCH 22/30] move nostd example into standard examples dir and run it with the others --- generate_modules.sh | 2 +- .../src/lib.rs => examples/pb_rs_example_nostd.rs} | 10 ++++++---- .../src => examples/pb_rs_nostd}/no_std.proto | 0 run_test.sh | 6 +----- 4 files changed, 8 insertions(+), 10 deletions(-) rename quick-protobuf/{no-std-example/src/lib.rs => examples/pb_rs_example_nostd.rs} (73%) rename quick-protobuf/{no-std-example/src => examples/pb_rs_nostd}/no_std.proto (100%) diff --git a/generate_modules.sh b/generate_modules.sh index d8bb1013..a2f20393 100755 --- a/generate_modules.sh +++ b/generate_modules.sh @@ -22,7 +22,7 @@ proto_sets=( ) nostd_proto_sets=( - quick-protobuf/no-std-example/src + quick-protobuf/examples/pb_rs_nostd ) for ps in "${proto_sets[@]}"; do diff --git a/quick-protobuf/no-std-example/src/lib.rs b/quick-protobuf/examples/pb_rs_example_nostd.rs similarity index 73% rename from quick-protobuf/no-std-example/src/lib.rs rename to quick-protobuf/examples/pb_rs_example_nostd.rs index 5501698c..8904c497 100644 --- a/quick-protobuf/no-std-example/src/lib.rs +++ b/quick-protobuf/examples/pb_rs_example_nostd.rs @@ -1,11 +1,13 @@ #![no_std] -use quick_protobuf::{serialize_into_slice, deserialize_from_slice}; -use crate::protos::no_std::*; +extern crate quick_protobuf; + +mod pb_rs_nostd; -mod protos; +use crate::pb_rs_nostd::protos::no_std::NoStdMessage; +use quick_protobuf::{serialize_into_slice, deserialize_from_slice}; -pub fn round_trip() { +fn main() { let message = NoStdMessage::default(); let mut buf = [0u8; 1024]; diff --git a/quick-protobuf/no-std-example/src/no_std.proto b/quick-protobuf/examples/pb_rs_nostd/no_std.proto similarity index 100% rename from quick-protobuf/no-std-example/src/no_std.proto rename to quick-protobuf/examples/pb_rs_nostd/no_std.proto diff --git a/run_test.sh b/run_test.sh index d25bd06c..3872eee7 100755 --- a/run_test.sh +++ b/run_test.sh @@ -7,10 +7,6 @@ set -e cargo run -p quick-protobuf --example pb_rs_example_v3_owned cargo run -p quick-protobuf --example pb_rs_example cargo run -p quick-protobuf --example pb_rs_example_v3 - -# test that no_std can build -pushd quick-protobuf/no-std-example - cargo build -popd +cargo run --no-default-features -p quick-protobuf --example pb_rs_example_nostd cargo test -p pb-rs -p quick-protobuf From 1dcef8619edf412c0e8a7e596ac51ca014e59981 Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Mon, 30 Sep 2019 17:07:52 -0700 Subject: [PATCH 23/30] remove old nostd example --- quick-protobuf/no-std-example/Cargo.toml | 10 -- quick-protobuf/no-std-example/Readme.md | 2 - quick-protobuf/no-std-example/src/mod.rs | 2 - .../no-std-example/src/protos/mod.rs | 2 - .../no-std-example/src/protos/no_std.rs | 128 ------------------ 5 files changed, 144 deletions(-) delete mode 100644 quick-protobuf/no-std-example/Cargo.toml delete mode 100644 quick-protobuf/no-std-example/Readme.md delete mode 100644 quick-protobuf/no-std-example/src/mod.rs delete mode 100644 quick-protobuf/no-std-example/src/protos/mod.rs delete mode 100644 quick-protobuf/no-std-example/src/protos/no_std.rs diff --git a/quick-protobuf/no-std-example/Cargo.toml b/quick-protobuf/no-std-example/Cargo.toml deleted file mode 100644 index 89e2d1a6..00000000 --- a/quick-protobuf/no-std-example/Cargo.toml +++ /dev/null @@ -1,10 +0,0 @@ -[package] -name = "no-std-example" -version = "0.1.0" -authors = ["Russell Mull "] -edition = "2018" - -[dependencies] -quick-protobuf = { path = "..", default-features = false } - -[workspace] diff --git a/quick-protobuf/no-std-example/Readme.md b/quick-protobuf/no-std-example/Readme.md deleted file mode 100644 index dfa6c0c8..00000000 --- a/quick-protobuf/no-std-example/Readme.md +++ /dev/null @@ -1,2 +0,0 @@ -This is just a compile-test; the actual functionality is all available in normal -builds. diff --git a/quick-protobuf/no-std-example/src/mod.rs b/quick-protobuf/no-std-example/src/mod.rs deleted file mode 100644 index cb5b6283..00000000 --- a/quick-protobuf/no-std-example/src/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -// Automatically generated mod.rs -pub mod protos; diff --git a/quick-protobuf/no-std-example/src/protos/mod.rs b/quick-protobuf/no-std-example/src/protos/mod.rs deleted file mode 100644 index 13ac3b3a..00000000 --- a/quick-protobuf/no-std-example/src/protos/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -// Automatically generated mod.rs -pub mod no_std; diff --git a/quick-protobuf/no-std-example/src/protos/no_std.rs b/quick-protobuf/no-std-example/src/protos/no_std.rs deleted file mode 100644 index 7a327a9d..00000000 --- a/quick-protobuf/no-std-example/src/protos/no_std.rs +++ /dev/null @@ -1,128 +0,0 @@ -// Automatically generated rust module for 'no_std.proto' file - -#![allow(non_snake_case)] -#![allow(non_upper_case_globals)] -#![allow(non_camel_case_types)] -#![allow(unused_imports)] -#![allow(unknown_lints)] -#![allow(clippy)] -#![cfg_attr(rustfmt, rustfmt_skip)] - - -extern crate alloc; -use alloc::vec::Vec; -use alloc::borrow::Cow; -use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}; -use quick_protobuf::sizeofs::*; -use super::super::*; - -#[derive(Debug, PartialEq, Eq, Clone, Copy)] -pub enum MyEnum { - Val0 = 0, - Val1 = 1, -} - -impl Default for MyEnum { - fn default() -> Self { - MyEnum::Val0 - } -} - -impl From for MyEnum { - fn from(i: i32) -> Self { - match i { - 0 => MyEnum::Val0, - 1 => MyEnum::Val1, - _ => Self::default(), - } - } -} - -impl<'a> From<&'a str> for MyEnum { - fn from(s: &'a str) -> Self { - match s { - "Val0" => MyEnum::Val0, - "Val1" => MyEnum::Val1, - _ => Self::default(), - } - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct EmbeddedMessage { - pub val: i32, - pub e: protos::no_std::MyEnum, -} - -impl<'a> MessageRead<'a> for EmbeddedMessage { - 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.val = r.read_int32(bytes)?, - Ok(16) => msg.e = r.read_enum(bytes)?, - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl MessageWrite for EmbeddedMessage { - fn get_size(&self) -> usize { - 0 - + if self.val == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.val) as u64) } - + if self.e == protos::no_std::MyEnum::Val0 { 0 } else { 1 + sizeof_varint(*(&self.e) as u64) } - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if self.val != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.val))?; } - if self.e != protos::no_std::MyEnum::Val0 { w.write_with_tag(16, |w| w.write_enum(*&self.e as i32))?; } - Ok(()) - } -} - -#[derive(Debug, Default, PartialEq, Clone)] -pub struct NoStdMessage<'a> { - pub num: u32, - pub nums: Cow<'a, [u32]>, - pub message: Option, - pub messages: Vec, -} - -impl<'a> MessageRead<'a> for NoStdMessage<'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(13) => msg.num = r.read_fixed32(bytes)?, - Ok(18) => msg.nums = r.read_packed_fixed(bytes)?.into(), - Ok(26) => msg.message = Some(r.read_message::(bytes)?), - Ok(34) => msg.messages.push(r.read_message::(bytes)?), - Ok(t) => { r.read_unknown(bytes, t)?; } - Err(e) => return Err(e), - } - } - Ok(msg) - } -} - -impl<'a> MessageWrite for NoStdMessage<'a> { - fn get_size(&self) -> usize { - 0 - + if self.num == 0u32 { 0 } else { 1 + 4 } - + if self.nums.is_empty() { 0 } else { 1 + sizeof_len(self.nums.len() * 4) } - + self.message.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size())) - + self.messages.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::() - } - - fn write_message(&self, w: &mut Writer) -> Result<()> { - if self.num != 0u32 { w.write_with_tag(13, |w| w.write_fixed32(*&self.num))?; } - w.write_packed_fixed_with_tag(18, &self.nums)?; - if let Some(ref s) = self.message { w.write_with_tag(26, |w| w.write_message(s))?; } - for s in &self.messages { w.write_with_tag(34, |w| w.write_message(s))?; } - Ok(()) - } -} - From b56b68e54033ab026436f01676cf66929589aa34 Mon Sep 17 00:00:00 2001 From: Joey Yandle Date: Mon, 30 Sep 2019 17:28:10 -0700 Subject: [PATCH 24/30] show that compiler doesn't care about multiple extern crate from separate modules --- quick-protobuf/examples/pb_rs_example_nostd.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/quick-protobuf/examples/pb_rs_example_nostd.rs b/quick-protobuf/examples/pb_rs_example_nostd.rs index 8904c497..a2beeeea 100644 --- a/quick-protobuf/examples/pb_rs_example_nostd.rs +++ b/quick-protobuf/examples/pb_rs_example_nostd.rs @@ -1,6 +1,7 @@ #![no_std] extern crate quick_protobuf; +extern crate alloc; mod pb_rs_nostd; From 64f2b2cb64ca69c7a6c4624ec2c3439798294647 Mon Sep 17 00:00:00 2001 From: Julian Popescu Date: Thu, 23 Jan 2020 10:20:00 +0100 Subject: [PATCH 25/30] Adds a hashbrown option --- pb-rs/src/lib.rs | 9 +++++++++ pb-rs/src/main.rs | 8 +++++++- pb-rs/src/types.rs | 27 +++++++++++++++++---------- 3 files changed, 33 insertions(+), 11 deletions(-) diff --git a/pb-rs/src/lib.rs b/pb-rs/src/lib.rs index 85040831..1d62d56e 100644 --- a/pb-rs/src/lib.rs +++ b/pb-rs/src/lib.rs @@ -69,6 +69,7 @@ pub struct ConfigBuilder { custom_struct_derive: Vec, owned: bool, nostd: bool, + hashbrown: bool, } impl ConfigBuilder { @@ -175,6 +176,13 @@ impl ConfigBuilder { self } + /// Use hashbrown as HashMap implementation instead of [std::collections::HashMap] or + /// [alloc::collections::BTreeMap] in a `no_std` environment + pub fn hashbrown(mut self, val: bool) -> Self { + self.hashbrown = val; + self + } + /// Build Config from this ConfigBuilder pub fn build(self) -> Vec { self.in_files @@ -204,6 +212,7 @@ impl ConfigBuilder { custom_includes: Vec::new(), owned: self.owned, nostd: self.nostd, + hashbrown: self.hashbrown, } }) .collect() diff --git a/pb-rs/src/main.rs b/pb-rs/src/main.rs index 1dbbbbeb..544ca3a2 100644 --- a/pb-rs/src/main.rs +++ b/pb-rs/src/main.rs @@ -91,6 +91,11 @@ fn run() -> Result<(), ::failure::Error> { .long("nostd") .required(false) .help("Generate no_std compliant code"), + ).arg( + Arg::with_name("HASHBROWN") + .long("hashrown") + .required(false) + .help("Use hashrown for HashMap implementation"), ).get_matches(); let in_files = path_vec(values_t!(matches, "INPUT", String)); @@ -117,7 +122,8 @@ fn run() -> Result<(), ::failure::Error> { .dont_use_cow(matches.is_present("DONT_USE_COW")) .custom_struct_derive(custom_struct_derive) .owned(matches.is_present("OWNED")) - .nostd(matches.is_present("NOSTD")); + .nostd(matches.is_present("NOSTD")) + .hashbrown(matches.is_present("HASHBROWN")); FileDescriptor::run(&compiler.build()).map_err(|e| e.into()) } diff --git a/pb-rs/src/types.rs b/pb-rs/src/types.rs index 6dcb061a..52fdeeee 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -312,7 +312,7 @@ impl FieldType { format!("{}{}{}", m.get_modules(desc), m.name, lifetime) } FieldType::Map(ref key, ref value) => format!( - "HashMap<{}, {}>", + "KVMap<{}, {}>", key.rust_type(desc)?, value.rust_type(desc)? ), @@ -848,7 +848,6 @@ impl Message { writeln!(w, "pub mod mod_{} {{", self.name)?; writeln!(w, "")?; if config.nostd { - writeln!(w, "extern crate alloc;")?; writeln!(w, "use alloc::vec::Vec;")?; } if self.messages.iter().any(|m| { @@ -866,11 +865,15 @@ impl Message { .iter() .any(|m| m.all_fields().any(|f| f.typ.is_map())) { - if config.nostd { + if config.hashbrown { + writeln!(w, "use hashbrown::HashMap;")?; + writeln!(w, "type KVMap = HashMap;")?; + } else if config.nostd { writeln!(w, "use alloc::collections::BTreeMap;")?; - writeln!(w, "pub type HashMap = BTreeMap;")?; + writeln!(w, "type KVMap = BTreeMap;")?; } else { writeln!(w, "use std::collections::HashMap;")?; + writeln!(w, "type KVMap = HashMap;")?; } } if !self.messages.is_empty() || !self.oneofs.is_empty() { @@ -1663,6 +1666,7 @@ pub struct Config { pub custom_includes: Vec, pub owned: bool, pub nostd: bool, + pub hashbrown: bool, } #[derive(Debug, Default, Clone)] @@ -2160,7 +2164,6 @@ impl FileDescriptor { } if config.nostd { - writeln!(w, "extern crate alloc;")?; writeln!(w, "use alloc::vec::Vec;")?; } @@ -2179,11 +2182,15 @@ impl FileDescriptor { .iter() .any(|m| m.all_fields().any(|f| f.typ.is_map())) { - if config.nostd { + if config.hashbrown { + writeln!(w, "use hashbrown::HashMap;")?; + writeln!(w, "type KVMap = HashMap;")?; + } else if config.nostd { writeln!(w, "use alloc::collections::BTreeMap;")?; - writeln!(w, "pub type HashMap = BTreeMap;")?; + writeln!(w, "type KVMap = BTreeMap;")?; } else { writeln!(w, "use std::collections::HashMap;")?; + writeln!(w, "type KVMap = HashMap;")?; } } writeln!( @@ -2195,9 +2202,9 @@ impl FileDescriptor { write!( w, "\ - use std::convert::TryFrom;\n\ - use std::ops::Deref;\n\ - use std::ops::DerefMut;\n\ + use core::convert::TryFrom;\n\ + use core::ops::Deref;\n\ + use core::ops::DerefMut;\n\ " )?; } From 7f407efff5986210bba29998b86f612d883d604c Mon Sep 17 00:00:00 2001 From: Julian Popescu Date: Thu, 23 Jan 2020 10:26:21 +0100 Subject: [PATCH 26/30] added global allocator to the pb_rs no_std sample --- quick-protobuf/examples/pb_rs_example_nostd.rs | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/quick-protobuf/examples/pb_rs_example_nostd.rs b/quick-protobuf/examples/pb_rs_example_nostd.rs index a2beeeea..9371a48d 100644 --- a/quick-protobuf/examples/pb_rs_example_nostd.rs +++ b/quick-protobuf/examples/pb_rs_example_nostd.rs @@ -1,12 +1,17 @@ #![no_std] -extern crate quick_protobuf; +extern crate std as ext_std; + extern crate alloc; +extern crate quick_protobuf; + +#[global_allocator] +static A: ext_std::alloc::System = ext_std::alloc::System; mod pb_rs_nostd; use crate::pb_rs_nostd::protos::no_std::NoStdMessage; -use quick_protobuf::{serialize_into_slice, deserialize_from_slice}; +use quick_protobuf::{deserialize_from_slice, serialize_into_slice}; fn main() { let message = NoStdMessage::default(); @@ -17,4 +22,3 @@ fn main() { let read_message = deserialize_from_slice(&buf).unwrap(); assert_eq!(message, read_message); } - From 0fd2d725abfb86044db8bead5d89ce2ca5db4bbe Mon Sep 17 00:00:00 2001 From: Julian Popescu Date: Thu, 23 Jan 2020 16:46:47 +0100 Subject: [PATCH 27/30] fixes impl fields with core references and alloc Box --- pb-rs/src/types.rs | 41 +++++++++++++++++++++++------------------ 1 file changed, 23 insertions(+), 18 deletions(-) diff --git a/pb-rs/src/types.rs b/pb-rs/src/types.rs index 52fdeeee..dcdc030c 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -447,15 +447,15 @@ impl Field { "i32" => format!("{}i32", *d), "i64" => format!("{}i64", *d), "f32" => match &*d.to_lowercase() { - "inf" => "::std::f32::INFINITY".to_string(), - "-inf" => "::std::f32::NEG_INFINITY".to_string(), - "nan" => "::std::f32::NAN".to_string(), + "inf" => "::core::f32::INFINITY".to_string(), + "-inf" => "::core::f32::NEG_INFINITY".to_string(), + "nan" => "::core::f32::NAN".to_string(), _ => format!("{}f32", *d), }, "f64" => match &*d.to_lowercase() { - "inf" => "::std::f64::INFINITY".to_string(), - "-inf" => "::std::f64::NEG_INFINITY".to_string(), - "nan" => "::std::f64::NAN".to_string(), + "inf" => "::core::f64::INFINITY".to_string(), + "-inf" => "::core::f64::NEG_INFINITY".to_string(), + "nan" => "::core::f64::NAN".to_string(), _ => format!("{}f64", *d), }, "Cow<'a, str>" => format!("Cow::Borrowed({})", d), @@ -840,7 +840,7 @@ impl Message { if desc.owned && self.has_lifetime(desc, &mut Vec::new()) { writeln!(w)?; - self.write_impl_owned(w)?; + self.write_impl_owned(w, config)?; } if !(self.messages.is_empty() && self.enums.is_empty() && self.oneofs.is_empty()) { @@ -1045,7 +1045,7 @@ impl Message { Ok(()) } - fn write_impl_owned(&self, w: &mut W) -> Result<()> { + fn write_impl_owned(&self, w: &mut W, config: &Config) -> Result<()> { write!( w, r#" @@ -1053,23 +1053,23 @@ impl Message { struct {name}OwnedInner {{ buf: Vec, proto: {name}<'static>, - _pin: std::marker::PhantomPinned, + _pin: core::marker::PhantomPinned, }} impl {name}OwnedInner {{ - fn new(buf: Vec) -> Result>> {{ + fn new(buf: Vec) -> Result>> {{ let inner = Self {{ buf, - proto: unsafe {{ std::mem::MaybeUninit::zeroed().assume_init() }}, - _pin: std::marker::PhantomPinned, + proto: unsafe {{ core::mem::MaybeUninit::zeroed().assume_init() }}, + _pin: core::marker::PhantomPinned, }}; - let mut pinned = Box::pin(inner); + let mut pinned = {boxed}::pin(inner); let mut reader = BytesReader::from_bytes(&pinned.buf); let proto = {name}::from_reader(&mut reader, &pinned.buf)?; unsafe {{ - let proto = std::mem::transmute::<_, {name}<'static>>(proto); + let proto = core::mem::transmute::<_, {name}<'static>>(proto); pinned.as_mut().get_unchecked_mut().proto = proto; }} Ok(pinned) @@ -1077,7 +1077,7 @@ impl Message { }} pub struct {name}Owned {{ - inner: std::pin::Pin>, + inner: core::pin::Pin<{boxed}<{name}OwnedInner>>, }} #[allow(dead_code)] @@ -1091,8 +1091,8 @@ impl Message { }} }} - impl std::fmt::Debug for {name}Owned {{ - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {{ + impl core::fmt::Debug for {name}Owned {{ + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {{ self.inner.proto.fmt(f) }} }} @@ -1131,7 +1131,12 @@ impl Message { }} }} "#, - name = self.name + name = self.name, + boxed = if config.nostd { + "::alloc::boxed::Box" + } else { + "Box" + } )?; Ok(()) } From a963dc30ff291666f00d505b68fde0388454e987 Mon Sep 17 00:00:00 2001 From: Julian Popescu Date: Thu, 23 Jan 2020 17:02:37 +0100 Subject: [PATCH 28/30] use mod level Box import when necessary for field or impl Owned --- pb-rs/src/types.rs | 29 +++++++++++++++++++++-------- 1 file changed, 21 insertions(+), 8 deletions(-) diff --git a/pb-rs/src/types.rs b/pb-rs/src/types.rs index dcdc030c..19e322ff 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -860,6 +860,15 @@ impl Message { writeln!(w, "use std::borrow::Cow;")?; } } + if config.nostd + && self.messages.iter().any(|m| { + desc.owned && m.has_lifetime(desc, &mut Vec::new()) + || m.all_fields().any(|f| f.boxed) + }) + { + writeln!(w)?; + writeln!(w, "use alloc::boxed::Box;")?; + } if self .messages .iter() @@ -1057,13 +1066,13 @@ impl Message { }} impl {name}OwnedInner {{ - fn new(buf: Vec) -> Result>> {{ + fn new(buf: Vec) -> Result>> {{ let inner = Self {{ buf, proto: unsafe {{ core::mem::MaybeUninit::zeroed().assume_init() }}, _pin: core::marker::PhantomPinned, }}; - let mut pinned = {boxed}::pin(inner); + let mut pinned = Box::pin(inner); let mut reader = BytesReader::from_bytes(&pinned.buf); let proto = {name}::from_reader(&mut reader, &pinned.buf)?; @@ -1077,7 +1086,7 @@ impl Message { }} pub struct {name}Owned {{ - inner: core::pin::Pin<{boxed}<{name}OwnedInner>>, + inner: core::pin::Pin>, }} #[allow(dead_code)] @@ -1132,11 +1141,6 @@ impl Message { }} "#, name = self.name, - boxed = if config.nostd { - "::alloc::boxed::Box" - } else { - "Box" - } )?; Ok(()) } @@ -2182,6 +2186,15 @@ impl FileDescriptor { writeln!(w, "use std::borrow::Cow;")?; } } + if config.nostd + && self.messages.iter().any(|m| { + self.owned && m.has_lifetime(&self, &mut Vec::new()) + || m.all_fields().any(|f| f.boxed) + }) + { + writeln!(w)?; + writeln!(w, "use alloc::boxed::Box;")?; + } if self .messages .iter() From 70690905c79dee08ada376901f3cb1b788192ca8 Mon Sep 17 00:00:00 2001 From: Julian Popescu Date: Thu, 23 Jan 2020 17:38:22 +0100 Subject: [PATCH 29/30] Reverts write_impl_owned back to no Config --- pb-rs/src/types.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pb-rs/src/types.rs b/pb-rs/src/types.rs index 19e322ff..b0b0d424 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -840,7 +840,7 @@ impl Message { if desc.owned && self.has_lifetime(desc, &mut Vec::new()) { writeln!(w)?; - self.write_impl_owned(w, config)?; + self.write_impl_owned(w)?; } if !(self.messages.is_empty() && self.enums.is_empty() && self.oneofs.is_empty()) { @@ -1054,7 +1054,7 @@ impl Message { Ok(()) } - fn write_impl_owned(&self, w: &mut W, config: &Config) -> Result<()> { + fn write_impl_owned(&self, w: &mut W) -> Result<()> { write!( w, r#" From 39ad744779e0c51a710d791e961d13ba83523648 Mon Sep 17 00:00:00 2001 From: Julian Popescu Date: Sat, 21 Mar 2020 19:05:43 +0100 Subject: [PATCH 30/30] fix perftest to work with no_std --- perftest/Cargo.toml | 2 +- perftest/build.rs | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/perftest/Cargo.toml b/perftest/Cargo.toml index d0ddafec..7a5d5467 100644 --- a/perftest/Cargo.toml +++ b/perftest/Cargo.toml @@ -7,7 +7,7 @@ build = "build.rs" [dependencies] protobuf = "2.0.4" -quick-protobuf = { path = "../quick-protobuf", default-features = false } +quick-protobuf = { path = "../quick-protobuf" } time = "0.1.40" rand = "0.5.5" prost = "0.4.0" diff --git a/perftest/build.rs b/perftest/build.rs index 8887a8b9..de9c1fa1 100644 --- a/perftest/build.rs +++ b/perftest/build.rs @@ -62,6 +62,7 @@ fn main() { custom_rpc_generator: Box::new(|rpc, writer| generate_rpc_test(rpc, writer)), custom_includes: Vec::new(), owned: false, + hashbrown: false, nostd: false, }; FileDescriptor::write_proto(&config).unwrap();