diff --git a/generate_modules.sh b/generate_modules.sh index a98aa7f6..a2f20393 100755 --- a/generate_modules.sh +++ b/generate_modules.sh @@ -21,10 +21,17 @@ proto_sets=( quick-protobuf/tests/rust_protobuf/common ) +nostd_proto_sets=( + quick-protobuf/examples/pb_rs_nostd +) + 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 diff --git a/pb-rs/src/lib.rs b/pb-rs/src/lib.rs index e0697fdc..7534ba19 100644 --- a/pb-rs/src/lib.rs +++ b/pb-rs/src/lib.rs @@ -63,6 +63,8 @@ pub struct ConfigBuilder { custom_struct_derive: Vec, custom_repr: Option, owned: bool, + nostd: bool, + hashbrown: bool, } impl ConfigBuilder { @@ -169,6 +171,19 @@ impl ConfigBuilder { self } + /// Generate no_std compliant code + pub fn nostd(mut self, val: bool) -> Self { + self.nostd = val; + 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 @@ -198,6 +213,8 @@ impl ConfigBuilder { custom_rpc_generator: Box::new(|_, _| Ok(())), 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 2443078a..e8b7b9e8 100644 --- a/pb-rs/src/main.rs +++ b/pb-rs/src/main.rs @@ -87,6 +87,16 @@ 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"), + ).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)); @@ -113,6 +123,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) + .nostd(matches.is_present("NOSTD")) + .hashbrown(matches.is_present("HASHBROWN")) .custom_repr(custom_repr) .owned(matches.is_present("OWNED")); diff --git a/pb-rs/src/types.rs b/pb-rs/src/types.rs index d94da044..1fc643eb 100644 --- a/pb-rs/src/types.rs +++ b/pb-rs/src/types.rs @@ -314,7 +314,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)? ), @@ -449,15 +449,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), @@ -849,19 +849,43 @@ impl Message { writeln!(w)?; writeln!(w, "pub mod mod_{} {{", self.name)?; writeln!(w)?; - if self - .messages - .iter() - .any(|m| m.all_fields().any(|f| f.typ.has_cow())) + if config.nostd { + 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 config.nostd { + writeln!(w, "use alloc::borrow::Cow;")?; + } else { + 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, "use std::borrow::Cow;")?; + writeln!(w)?; + writeln!(w, "use alloc::boxed::Box;")?; } if self .messages .iter() .any(|m| m.all_fields().any(|f| f.typ.is_map())) { - writeln!(w, "use std::collections::HashMap;")?; + 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, "type KVMap = BTreeMap;")?; + } else { + writeln!(w, "use std::collections::HashMap;")?; + writeln!(w, "type KVMap = HashMap;")?; + } } if !self.messages.is_empty() || !self.oneofs.is_empty() { writeln!(w, "use super::*;")?; @@ -1045,15 +1069,15 @@ 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); @@ -1061,7 +1085,7 @@ impl Message { 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) @@ -1069,7 +1093,7 @@ impl Message { }} pub struct {name}Owned {{ - inner: std::pin::Pin>, + inner: core::pin::Pin>, }} #[allow(dead_code)] @@ -1083,8 +1107,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) }} }} @@ -1123,7 +1147,7 @@ impl Message { }} }} "#, - name = self.name + name = self.name, )?; Ok(()) } @@ -1144,7 +1168,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)?; @@ -1658,6 +1682,8 @@ pub struct Config { pub custom_rpc_generator: RpcGeneratorFunction, pub custom_includes: Vec, pub owned: bool, + pub nostd: bool, + pub hashbrown: bool, } #[derive(Debug, Default, Clone)] @@ -2153,33 +2179,58 @@ impl FileDescriptor { )?; return Ok(()); } - writeln!(w, "use std::io::Write;")?; - if self - .messages - .iter() - .any(|m| m.all_fields().any(|f| f.typ.has_cow())) + + if config.nostd { + 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 config.nostd { + writeln!(w, "use alloc::borrow::Cow;")?; + } else { + 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, "use std::borrow::Cow;")?; + writeln!(w)?; + writeln!(w, "use alloc::boxed::Box;")?; } if self .messages .iter() .any(|m| m.all_fields().any(|f| f.typ.is_map())) { - writeln!(w, "use std::collections::HashMap;")?; + 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, "type KVMap = BTreeMap;")?; + } else { + writeln!(w, "use std::collections::HashMap;")?; + writeln!(w, "type KVMap = HashMap;")?; + } } writeln!( w, - "use quick_protobuf::{{MessageRead, MessageWrite, BytesReader, Writer, Result}};" + "use quick_protobuf::{{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result}};" )?; if self.owned { 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\ " )?; } diff --git a/perftest/Cargo.toml b/perftest/Cargo.toml index 60016a1e..7a5d5467 100644 --- a/perftest/Cargo.toml +++ b/perftest/Cargo.toml @@ -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/build.rs b/perftest/build.rs index 0b532494..de9c1fa1 100644 --- a/perftest/build.rs +++ b/perftest/build.rs @@ -62,6 +62,8 @@ 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(); diff --git a/perftest/src/perftest_data.rs b/perftest/src/perftest_data.rs deleted file mode 100644 index cebe0abf..00000000 --- a/perftest/src/perftest_data.rs +++ /dev/null @@ -1,2130 +0,0 @@ -// 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(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_0; - -#[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/Cargo.toml b/quick-protobuf/Cargo.toml index 304ebf07..1accacb9 100644 --- a/quick-protobuf/Cargo.toml +++ b/quick-protobuf/Cargo.toml @@ -11,9 +11,13 @@ 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" [dev-dependencies] lazy_static = "0.2.10" + +[features] +default = ["std"] +std = ["byteorder/std", "failure/std"] 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_example_nostd.rs b/quick-protobuf/examples/pb_rs_example_nostd.rs new file mode 100644 index 00000000..9371a48d --- /dev/null +++ b/quick-protobuf/examples/pb_rs_example_nostd.rs @@ -0,0 +1,24 @@ +#![no_std] + +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::{deserialize_from_slice, serialize_into_slice}; + +fn main() { + 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/examples/pb_rs_nostd/no_std.proto b/quick-protobuf/examples/pb_rs_nostd/no_std.proto new file mode 100644 index 00000000..a8278707 --- /dev/null +++ b/quick-protobuf/examples/pb_rs_nostd/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; + EmbeddedMessage message = 3; + repeated EmbeddedMessage messages = 4; +} 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..4293bdde 100644 --- a/quick-protobuf/src/errors.rs +++ b/quick-protobuf/src/errors.rs @@ -1,40 +1,57 @@ -//! 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), + + /// 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` -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), @@ -43,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 453d4742..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; @@ -17,5 +18,10 @@ 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_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 d5664199..77e5a9fb 100644 --- a/quick-protobuf/src/message.rs +++ b/quick-protobuf/src/message.rs @@ -2,18 +2,21 @@ //! //! 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; 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(()) } @@ -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 a3e99708..63f8f5c5 100644 --- a/quick-protobuf/src/reader.rs +++ b/quick-protobuf/src/reader.rs @@ -7,10 +7,18 @@ //! //! 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(not(feature = "std"))] +extern crate alloc; +#[cfg(not(feature = "std"))] +use alloc::vec::Vec; + use crate::errors::{Error, Result}; use crate::message::MessageRead; @@ -91,12 +99,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) } @@ -258,12 +261,11 @@ impl BytesReader { /// Reads fixed64 (little endian u64) #[inline] fn read_fixed M>(&mut self, bytes: &[u8], len: usize, read: F) -> Result { - let v = read(&bytes.get(self.start..self.start + len).ok_or_else(|| { - Error::Io(io::Error::new( - io::ErrorKind::UnexpectedEof, - "Cannot read next bytes", - )) - })?); + let v = read( + &bytes + .get(self.start..self.start + len) + .ok_or_else(|| Error::UnexpectedEndOfBuffer)?, + ); self.start += len; Ok(v) } @@ -344,12 +346,8 @@ impl BytesReader { #[inline] pub fn read_bytes<'a>(&mut self, bytes: &'a [u8]) -> Result<&'a [u8]> { self.read_len_varint(bytes, |r, b| { - b.get(r.start..r.end).ok_or_else(|| { - Error::Io(io::Error::new( - io::ErrorKind::UnexpectedEof, - "Cannot read next bytes", - )) - }) + b.get(r.start..r.end) + .ok_or_else(|| Error::UnexpectedEndOfBuffer) }) } @@ -358,13 +356,8 @@ impl BytesReader { pub fn read_string<'a>(&mut self, bytes: &'a [u8]) -> Result<&'a str> { self.read_len_varint(bytes, |r, b| { b.get(r.start..r.end) - .ok_or_else(|| { - Error::Io(io::Error::new( - io::ErrorKind::UnexpectedEof, - "Cannot read next bytes", - )) - }) - .and_then(|x| ::std::str::from_utf8(x).map_err(|e| e.into())) + .ok_or_else(|| Error::UnexpectedEndOfBuffer) + .and_then(|x| ::core::str::from_utf8(x).map_err(|e| e.into())) }) } @@ -394,14 +387,11 @@ 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 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, ) @@ -444,8 +434,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(); @@ -558,6 +548,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 { @@ -569,6 +560,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)?; diff --git a/quick-protobuf/src/writer.rs b/quick-protobuf/src/writer.rs index 1adcb4bd..300eed2e 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::Result; +use crate::errors::{Error, Result}; use crate::message::MessageWrite; -use byteorder::LittleEndian as LE; +use byteorder::{ByteOrder, LittleEndian as LE}; + +#[cfg(feature = "std")] 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 @@ -205,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) } @@ -264,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) } @@ -284,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) } @@ -310,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)); @@ -319,3 +319,190 @@ 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..(self.cursor + buf.len())].copy_from_slice(buf); + self.cursor += buf.len(); + Ok(()) + } + } +} + +#[cfg(feature = "std")] +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/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))?; } diff --git a/run_test.sh b/run_test.sh index 2fc10863..391b48c4 100755 --- a/run_test.sh +++ b/run_test.sh @@ -4,8 +4,11 @@ set -e ./generate_modules.sh -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 +pushd quick-protobuf +cargo run --example pb_rs_example_v3_owned +cargo run --example pb_rs_example +cargo run --example pb_rs_example_v3 +cargo run --example pb_rs_example_nostd --no-default-features +popd cargo test -p pb-rs -p quick-protobuf