Snap for 8270536 from 0af506eab5a6d52635e775e0ad9b6439da826a3a to tm-release
Change-Id: I1afc3e5e65c4576b5c9584ef20cb5bdbf6211d5a
diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index 051cfa6..ca74a42 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,6 @@
{
"git": {
- "sha1": "d65abd3c6cee1dacef1448146b488ee168492a7d"
- }
-}
+ "sha1": "ec31ce829473039ac598ca6fdcb245cbd6fa82ba"
+ },
+ "path_in_vcs": "protobuf"
+}
\ No newline at end of file
diff --git a/Android.bp b/Android.bp
index d7d1318..78e5734 100644
--- a/Android.bp
+++ b/Android.bp
@@ -30,7 +30,7 @@
host_supported: true,
crate_name: "protobuf",
cargo_env_compat: true,
- cargo_pkg_version: "2.25.1",
+ cargo_pkg_version: "2.27.1",
srcs: [
"src/lib.rs",
":copy_protobuf_build_out",
diff --git a/Cargo.toml b/Cargo.toml
index 005d7bf..9e4935f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,19 +12,23 @@
[package]
edition = "2018"
name = "protobuf"
-version = "2.25.1"
+version = "2.27.1"
authors = ["Stepan Koltsov <stepan.koltsov@gmail.com>"]
-description = "Rust implementation of Google protocol buffers\n"
+description = """
+Rust implementation of Google protocol buffers
+"""
homepage = "https://github.com/stepancheg/rust-protobuf/"
documentation = "https://github.com/stepancheg/rust-protobuf/blob/master/README.md"
license = "MIT"
repository = "https://github.com/stepancheg/rust-protobuf/"
+
[package.metadata.docs.rs]
all-features = true
[lib]
doctest = false
bench = false
+
[dependencies.bytes]
version = "1.0"
optional = true
@@ -40,4 +44,7 @@
[features]
with-bytes = ["bytes"]
-with-serde = ["serde", "serde_derive"]
+with-serde = [
+ "serde",
+ "serde_derive",
+]
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index 058e8f1..c1be2f7 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,7 +1,7 @@
[package]
name = "protobuf"
-version = "2.25.1"
+version = "2.27.1"
authors = ["Stepan Koltsov <stepan.koltsov@gmail.com>"]
edition = "2018"
license = "MIT"
diff --git a/METADATA b/METADATA
index 08ae782..2bcb504 100644
--- a/METADATA
+++ b/METADATA
@@ -7,13 +7,13 @@
}
url {
type: ARCHIVE
- value: "https://static.crates.io/crates/protobuf/protobuf-2.25.1.crate"
+ value: "https://static.crates.io/crates/protobuf/protobuf-2.27.1.crate"
}
- version: "2.25.1"
+ version: "2.27.1"
license_type: NOTICE
last_upgrade_date {
- year: 2021
- month: 9
- day: 22
+ year: 2022
+ month: 3
+ day: 1
}
}
diff --git a/README.md b/README.md
index c16838b..af32486 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,95 @@
-## How to develop rust-protobuf itself
+<!-- cargo-sync-readme start -->
-`cargo test --all` to build everything.
+# Library to read and write protocol buffers data
-If code generator is changed, code needs to be regenerated, see
-`regenerate.sh`.
+# Version 2 is stable
+
+Currently developed branch of rust-protobuf [is 3](https://docs.rs/protobuf/%3E=3.0.0-alpha).
+It has the same spirit as version 2, but contains numerous improvements like:
+* runtime reflection for mutability, not just for access
+* protobuf text format and JSON parsing (which rely on reflection)
+* dynamic message support: work with protobuf data without generating code from schema
+
+Stable version of rust-protobuf will be supported until version 3 released.
+
+[Tracking issue for version 3](https://github.com/stepancheg/rust-protobuf/issues/518).
+
+# How to generate rust code
+
+There are several ways to generate rust code from `.proto` files
+
+## Invoke `protoc` programmatically with protoc-rust crate (recommended)
+
+Have a look at readme in [protoc-rust crate](https://docs.rs/protoc-rust/=2).
+
+## Use pure rust protobuf parser and code generator
+
+Readme should be in
+[protobuf-codegen-pure crate](https://docs.rs/protobuf-codegen-pure/=2).
+
+## Use protoc-gen-rust plugin
+
+Readme is [here](https://docs.rs/protobuf-codegen/=2).
+
+## Generated code
+
+Have a look at generated files (for current development version),
+used internally in rust-protobuf:
+
+* [descriptor.rs](https://github.com/stepancheg/rust-protobuf/blob/master/protobuf/src/descriptor.rs)
+ for [descriptor.proto](https://github.com/stepancheg/rust-protobuf/blob/master/protoc-bin-vendored/include/google/protobuf/descriptor.proto)
+ (that is part of Google protobuf)
+
+# Copy on write
+
+Rust-protobuf can be used with [bytes crate](https://github.com/tokio-rs/bytes).
+
+To enable `Bytes` you need to:
+
+1. Enable `with-bytes` feature in rust-protobuf:
+
+```rust
+[dependencies]
+protobuf = { version = "~2.0", features = ["with-bytes"] }
+```
+
+2. Enable bytes option
+
+with `Customize` when codegen is invoked programmatically:
+
+```rust
+protoc_rust::run(protoc_rust::Args {
+ ...
+ customize: Customize {
+ carllerche_bytes_for_bytes: Some(true),
+ carllerche_bytes_for_string: Some(true),
+ ..Default::default()
+ },
+});
+```
+
+or in `.proto` file:
+
+```rust
+import "rustproto.proto";
+
+option (rustproto.carllerche_bytes_for_bytes_all) = true;
+option (rustproto.carllerche_bytes_for_string_all) = true;
+```
+
+With these options enabled, fields of type `bytes` or `string` are
+generated as `Bytes` or `Chars` respectively. When `CodedInputStream` is constructed
+from `Bytes` object, fields of these types get subslices of original `Bytes` object,
+instead of being allocated on heap.
+
+# Accompanying crates
+
+* [`protoc-rust`](https://docs.rs/protoc-rust/=2)
+ and [`protobuf-codegen-pure`](https://docs.rs/protobuf-codegen-pure/=2)
+ can be used to rust code from `.proto` crates.
+* [`protobuf-codegen`](https://docs.rs/protobuf-codegen/=2) for `protoc-gen-rust` protoc plugin.
+* [`protoc`](https://docs.rs/protoc/=2) crate can be used to invoke `protoc` programmatically.
+* [`protoc-bin-vendored`](https://docs.rs/protoc-bin-vendored/=2) contains `protoc` command
+ packed into the crate.
+
+<!-- cargo-sync-readme end -->
diff --git a/TEST_MAPPING b/TEST_MAPPING
index b7c1df9..8229f22 100644
--- a/TEST_MAPPING
+++ b/TEST_MAPPING
@@ -2,6 +2,9 @@
{
"presubmit": [
{
+ "name": "authfs_device_test_src_lib"
+ },
+ {
"name": "microdroid_manager_test"
},
{
@@ -10,6 +13,9 @@
],
"presubmit-rust": [
{
+ "name": "authfs_device_test_src_lib"
+ },
+ {
"name": "microdroid_manager_test"
},
{
diff --git a/benches/coded_output_stream.rs b/benches/coded_output_stream.rs
index 0f57a38..9edf95c 100644
--- a/benches/coded_output_stream.rs
+++ b/benches/coded_output_stream.rs
@@ -5,9 +5,10 @@
extern crate protobuf;
extern crate test;
-use self::test::Bencher;
use protobuf::CodedOutputStream;
+use self::test::Bencher;
+
#[inline]
fn buffer_write_byte(os: &mut CodedOutputStream) {
for i in 0..10 {
diff --git a/out/version.rs b/out/version.rs
index fd20f6c..18bbac5 100644
--- a/out/version.rs
+++ b/out/version.rs
@@ -1,7 +1,7 @@
/// protobuf crate version
-pub const VERSION: &'static str = "2.25.1";
+pub const VERSION: &'static str = "2.27.1";
/// This symbol is used by codegen
#[doc(hidden)]
-pub const VERSION_IDENT: &'static str = "VERSION_2_25_1";
+pub const VERSION_IDENT: &'static str = "VERSION_2_27_1";
/// This symbol can be referenced to assert that proper version of crate is used
-pub const VERSION_2_25_1: () = ();
+pub const VERSION_2_27_1: () = ();
diff --git a/regenerate.sh b/regenerate.sh
index 672106e..0173496 100755
--- a/regenerate.sh
+++ b/regenerate.sh
@@ -1,6 +1,6 @@
#!/bin/sh -ex
-cd $(dirname $0)
+cd "$(dirname "$0")"
die() {
echo "$@" >&2
@@ -9,29 +9,35 @@
protoc_ver=$(protoc --version)
case "$protoc_ver" in
- "libprotoc 3"*) ;;
- *)
- die "you need to use protobuf 3 to regenerate .rs from .proto"
+"libprotoc 3"*) ;;
+*)
+ die "you need to use protobuf 3 to regenerate .rs from .proto"
;;
esac
cargo build --manifest-path=../protobuf-codegen/Cargo.toml
+cargo build --manifest-path=../protoc-bin-vendored/Cargo.toml --bin protoc-bin-which
-where_am_i=$(cd ..; pwd)
+PROTOC=$(cargo run --manifest-path=../protoc-bin-vendored/Cargo.toml --bin protoc-bin-which)
+
+where_am_i=$(
+ cd ..
+ pwd
+)
rm -rf tmp-generated
mkdir tmp-generated
-case `uname` in
- Linux)
- exe_suffix=""
+case $(uname) in
+Linux)
+ exe_suffix=""
;;
- MSYS_NT*)
- exe_suffix=".exe"
+MSYS_NT*)
+ exe_suffix=".exe"
;;
esac
-protoc \
+"$PROTOC" \
--plugin=protoc-gen-rust="$where_am_i/target/debug/protoc-gen-rust$exe_suffix" \
--rust_out tmp-generated \
--rust_opt 'serde_derive=true inside_protobuf=true' \
@@ -45,13 +51,14 @@
mv tmp-generated/*.rs src/well_known_types/
(
cd src/well_known_types
- exec > mod.rs
+ exec >mod.rs
echo "// This file is generated. Do not edit"
echo '//! Generated code for "well known types"'
echo "//!"
echo "//! [This document](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf) describes these types."
mod_list() {
+ # shellcheck disable=SC2010
ls | grep -v mod.rs | sed -e 's,\.rs$,,'
}
@@ -59,7 +66,7 @@
mod_list | sed -e 's,^,mod ,; s,$,;,'
echo
- mod_list | while read mod; do
+ mod_list | while read -r mod; do
echo "pub use self::$mod::*;"
done
)
diff --git a/src/buf_read_iter.rs b/src/buf_read_iter.rs
index 37bc353..ff1fce2 100644
--- a/src/buf_read_iter.rs
+++ b/src/buf_read_iter.rs
@@ -3,6 +3,7 @@
use std::io::BufReader;
use std::io::Read;
use std::mem;
+use std::mem::MaybeUninit;
use std::u64;
#[cfg(feature = "bytes")]
@@ -14,8 +15,11 @@
#[cfg(feature = "bytes")]
use bytes::BytesMut;
+use crate::buf_read_or_reader::BufReadOrReader;
use crate::coded_input_stream::READ_RAW_BYTES_MAX_ALLOC;
use crate::error::WireError;
+use crate::misc::maybe_uninit_write_slice;
+use crate::misc::vec_spare_capacity_mut;
use crate::ProtobufError;
use crate::ProtobufResult;
@@ -29,8 +33,7 @@
/// Hold all possible combinations of input source
enum InputSource<'a> {
- BufRead(&'a mut dyn BufRead),
- Read(BufReader<&'a mut dyn Read>),
+ Read(BufReadOrReader<'a>),
Slice(&'a [u8]),
#[cfg(feature = "bytes")]
Bytes(&'a Bytes),
@@ -50,7 +53,7 @@
/// It is important for `CodedInputStream` performance that small reads
/// (e. g. 4 bytes reads) do not involve virtual calls or switches.
/// This is achievable with `BufReadIter`.
-pub struct BufReadIter<'a> {
+pub(crate) struct BufReadIter<'a> {
input_source: InputSource<'a>,
buf: &'a [u8],
pos_within_buf: usize,
@@ -62,22 +65,19 @@
impl<'a> Drop for BufReadIter<'a> {
fn drop(&mut self) {
match self.input_source {
- InputSource::BufRead(ref mut buf_read) => buf_read.consume(self.pos_within_buf),
- InputSource::Read(_) => {
- // Nothing to flush, because we own BufReader
- }
+ InputSource::Read(ref mut buf_read) => buf_read.consume(self.pos_within_buf),
_ => {}
}
}
}
impl<'ignore> BufReadIter<'ignore> {
- pub fn from_read<'a>(read: &'a mut dyn Read) -> BufReadIter<'a> {
+ pub(crate) fn from_read<'a>(read: &'a mut dyn Read) -> BufReadIter<'a> {
BufReadIter {
- input_source: InputSource::Read(BufReader::with_capacity(
+ input_source: InputSource::Read(BufReadOrReader::BufReader(BufReader::with_capacity(
INPUT_STREAM_BUFFER_SIZE,
read,
- )),
+ ))),
buf: &[],
pos_within_buf: 0,
limit_within_buf: 0,
@@ -86,9 +86,9 @@
}
}
- pub fn from_buf_read<'a>(buf_read: &'a mut dyn BufRead) -> BufReadIter<'a> {
+ pub(crate) fn from_buf_read<'a>(buf_read: &'a mut dyn BufRead) -> BufReadIter<'a> {
BufReadIter {
- input_source: InputSource::BufRead(buf_read),
+ input_source: InputSource::Read(BufReadOrReader::BufRead(buf_read)),
buf: &[],
pos_within_buf: 0,
limit_within_buf: 0,
@@ -97,7 +97,7 @@
}
}
- pub fn from_byte_slice<'a>(bytes: &'a [u8]) -> BufReadIter<'a> {
+ pub(crate) fn from_byte_slice<'a>(bytes: &'a [u8]) -> BufReadIter<'a> {
BufReadIter {
input_source: InputSource::Slice(bytes),
buf: bytes,
@@ -109,7 +109,7 @@
}
#[cfg(feature = "bytes")]
- pub fn from_bytes<'a>(bytes: &'a Bytes) -> BufReadIter<'a> {
+ pub(crate) fn from_bytes<'a>(bytes: &'a Bytes) -> BufReadIter<'a> {
BufReadIter {
input_source: InputSource::Bytes(bytes),
buf: &bytes,
@@ -128,7 +128,7 @@
}
#[inline(always)]
- pub fn pos(&self) -> u64 {
+ pub(crate) fn pos(&self) -> u64 {
self.pos_of_buf_start + self.pos_within_buf as u64
}
@@ -144,7 +144,7 @@
self.assertions();
}
- pub fn push_limit(&mut self, limit: u64) -> ProtobufResult<u64> {
+ pub(crate) fn push_limit(&mut self, limit: u64) -> ProtobufResult<u64> {
let new_limit = match self.pos().checked_add(limit) {
Some(new_limit) => new_limit,
None => return Err(ProtobufError::WireError(WireError::Other)),
@@ -162,7 +162,7 @@
}
#[inline]
- pub fn pop_limit(&mut self, limit: u64) {
+ pub(crate) fn pop_limit(&mut self, limit: u64) {
assert!(limit >= self.limit);
self.limit = limit;
@@ -171,7 +171,7 @@
}
#[inline]
- pub fn remaining_in_buf(&self) -> &[u8] {
+ pub(crate) fn remaining_in_buf(&self) -> &[u8] {
if USE_UNSAFE_FOR_SPEED {
unsafe {
&self
@@ -184,12 +184,12 @@
}
#[inline(always)]
- pub fn remaining_in_buf_len(&self) -> usize {
+ pub(crate) fn remaining_in_buf_len(&self) -> usize {
self.limit_within_buf - self.pos_within_buf
}
#[inline(always)]
- pub fn bytes_until_limit(&self) -> u64 {
+ pub(crate) fn bytes_until_limit(&self) -> u64 {
if self.limit == NO_LIMIT {
NO_LIMIT
} else {
@@ -198,7 +198,7 @@
}
#[inline(always)]
- pub fn eof(&mut self) -> ProtobufResult<bool> {
+ pub(crate) fn eof(&mut self) -> ProtobufResult<bool> {
if self.pos_within_buf == self.limit_within_buf {
Ok(self.fill_buf()?.is_empty())
} else {
@@ -207,7 +207,7 @@
}
#[inline(always)]
- pub fn read_byte(&mut self) -> ProtobufResult<u8> {
+ pub(crate) fn read_byte(&mut self) -> ProtobufResult<u8> {
if self.pos_within_buf == self.limit_within_buf {
self.do_fill_buf()?;
if self.remaining_in_buf_len() == 0 {
@@ -239,6 +239,101 @@
Ok(len)
}
+ #[cfg(feature = "bytes")]
+ pub(crate) fn read_exact_bytes(&mut self, len: usize) -> ProtobufResult<Bytes> {
+ if let InputSource::Bytes(bytes) = self.input_source {
+ let end = match self.pos_within_buf.checked_add(len) {
+ Some(end) => end,
+ None => return Err(ProtobufError::WireError(WireError::UnexpectedEof)),
+ };
+
+ if end > self.limit_within_buf {
+ return Err(ProtobufError::WireError(WireError::UnexpectedEof));
+ }
+
+ let r = bytes.slice(self.pos_within_buf..end);
+ self.pos_within_buf += len;
+ Ok(r)
+ } else {
+ if len >= READ_RAW_BYTES_MAX_ALLOC {
+ // We cannot trust `len` because protobuf message could be malformed.
+ // Reading should not result in OOM when allocating a buffer.
+ let mut v = Vec::new();
+ self.read_exact_to_vec(len, &mut v)?;
+ Ok(Bytes::from(v))
+ } else {
+ let mut r = BytesMut::with_capacity(len);
+ unsafe {
+ let buf = Self::uninit_slice_as_mut_slice(&mut r.chunk_mut()[..len]);
+ self.read_exact(buf)?;
+ r.advance_mut(len);
+ }
+ Ok(r.freeze())
+ }
+ }
+ }
+
+ #[cfg(feature = "bytes")]
+ unsafe fn uninit_slice_as_mut_slice(slice: &mut UninitSlice) -> &mut [MaybeUninit<u8>] {
+ use std::slice;
+ slice::from_raw_parts_mut(slice.as_mut_ptr() as *mut MaybeUninit<u8>, slice.len())
+ }
+
+ /// Returns 0 when EOF or limit reached.
+ pub(crate) fn read(&mut self, buf: &mut [u8]) -> ProtobufResult<usize> {
+ self.fill_buf()?;
+
+ let rem = &self.buf[self.pos_within_buf..self.limit_within_buf];
+
+ let len = cmp::min(rem.len(), buf.len());
+ buf[..len].copy_from_slice(&rem[..len]);
+ self.pos_within_buf += len;
+ Ok(len)
+ }
+
+ fn read_exact_slow(&mut self, buf: &mut [MaybeUninit<u8>]) -> ProtobufResult<()> {
+ if self.bytes_until_limit() < buf.len() as u64 {
+ return Err(ProtobufError::WireError(WireError::UnexpectedEof));
+ }
+
+ let consume = self.pos_within_buf;
+ self.pos_of_buf_start += self.pos_within_buf as u64;
+ self.pos_within_buf = 0;
+ self.buf = &[];
+ self.limit_within_buf = 0;
+
+ match self.input_source {
+ InputSource::Read(ref mut buf_read) => {
+ buf_read.consume(consume);
+ buf_read.read_exact_uninit(buf)?;
+ }
+ _ => {
+ return Err(ProtobufError::WireError(WireError::UnexpectedEof));
+ }
+ }
+
+ self.pos_of_buf_start += buf.len() as u64;
+
+ self.assertions();
+
+ Ok(())
+ }
+
+ #[inline]
+ pub(crate) fn read_exact(&mut self, buf: &mut [MaybeUninit<u8>]) -> ProtobufResult<()> {
+ if self.remaining_in_buf_len() >= buf.len() {
+ let buf_len = buf.len();
+ maybe_uninit_write_slice(
+ buf,
+ &self.buf[self.pos_within_buf..self.pos_within_buf + buf_len],
+ );
+ self.pos_within_buf += buf_len;
+ return Ok(());
+ }
+
+ self.read_exact_slow(buf)
+ }
+
/// Read exact number of bytes into `Vec`.
///
/// `Vec` is cleared in the beginning.
@@ -273,7 +368,7 @@
target.reserve_exact(count);
unsafe {
- self.read_exact(&mut target.get_unchecked_mut(..count))?;
+ self.read_exact(&mut vec_spare_capacity_mut(target)[..count])?;
target.set_len(count);
}
}
@@ -283,97 +378,6 @@
Ok(())
}
- #[cfg(feature = "bytes")]
- pub fn read_exact_bytes(&mut self, len: usize) -> ProtobufResult<Bytes> {
- if let InputSource::Bytes(bytes) = self.input_source {
- let end = match self.pos_within_buf.checked_add(len) {
- Some(end) => end,
- None => return Err(ProtobufError::WireError(WireError::UnexpectedEof)),
- };
-
- if end > self.limit_within_buf {
- return Err(ProtobufError::WireError(WireError::UnexpectedEof));
- }
-
- let r = bytes.slice(self.pos_within_buf..end);
- self.pos_within_buf += len;
- Ok(r)
- } else {
- if len >= READ_RAW_BYTES_MAX_ALLOC {
- // We cannot trust `len` because protobuf message could be malformed.
- // Reading should not result in OOM when allocating a buffer.
- let mut v = Vec::new();
- self.read_exact_to_vec(len, &mut v)?;
- Ok(Bytes::from(v))
- } else {
- let mut r = BytesMut::with_capacity(len);
- unsafe {
- let buf = Self::uninit_slice_as_mut_slice(&mut r.chunk_mut()[..len]);
- self.read_exact(buf)?;
- r.advance_mut(len);
- }
- Ok(r.freeze())
- }
- }
- }
-
- #[cfg(feature = "bytes")]
- unsafe fn uninit_slice_as_mut_slice(slice: &mut UninitSlice) -> &mut [u8] {
- use std::slice;
- slice::from_raw_parts_mut(slice.as_mut_ptr(), slice.len())
- }
-
- /// Returns 0 when EOF or limit reached.
- pub fn read(&mut self, buf: &mut [u8]) -> ProtobufResult<usize> {
- self.fill_buf()?;
-
- let rem = &self.buf[self.pos_within_buf..self.limit_within_buf];
-
- let len = cmp::min(rem.len(), buf.len());
- buf[..len].copy_from_slice(&rem[..len]);
- self.pos_within_buf += len;
- Ok(len)
- }
-
- pub fn read_exact(&mut self, buf: &mut [u8]) -> ProtobufResult<()> {
- if self.remaining_in_buf_len() >= buf.len() {
- let buf_len = buf.len();
- buf.copy_from_slice(&self.buf[self.pos_within_buf..self.pos_within_buf + buf_len]);
- self.pos_within_buf += buf_len;
- return Ok(());
- }
-
- if self.bytes_until_limit() < buf.len() as u64 {
- return Err(ProtobufError::WireError(WireError::UnexpectedEof));
- }
-
- let consume = self.pos_within_buf;
- self.pos_of_buf_start += self.pos_within_buf as u64;
- self.pos_within_buf = 0;
- self.buf = &[];
- self.limit_within_buf = 0;
-
- match self.input_source {
- InputSource::Read(ref mut buf_read) => {
- buf_read.consume(consume);
- buf_read.read_exact(buf)?;
- }
- InputSource::BufRead(ref mut buf_read) => {
- buf_read.consume(consume);
- buf_read.read_exact(buf)?;
- }
- _ => {
- return Err(ProtobufError::WireError(WireError::UnexpectedEof));
- }
- }
-
- self.pos_of_buf_start += buf.len() as u64;
-
- self.assertions();
-
- Ok(())
- }
-
fn do_fill_buf(&mut self) -> ProtobufResult<()> {
debug_assert!(self.pos_within_buf == self.limit_within_buf);
@@ -394,10 +398,6 @@
buf_read.consume(consume);
self.buf = unsafe { mem::transmute(buf_read.fill_buf()?) };
}
- InputSource::BufRead(ref mut buf_read) => {
- buf_read.consume(consume);
- self.buf = unsafe { mem::transmute(buf_read.fill_buf()?) };
- }
_ => {
return Ok(());
}
@@ -409,7 +409,7 @@
}
#[inline(always)]
- pub fn fill_buf(&mut self) -> ProtobufResult<&[u8]> {
+ pub(crate) fn fill_buf(&mut self) -> ProtobufResult<&[u8]> {
if self.pos_within_buf == self.limit_within_buf {
self.do_fill_buf()?;
}
@@ -425,7 +425,7 @@
}
#[inline(always)]
- pub fn consume(&mut self, amt: usize) {
+ pub(crate) fn consume(&mut self, amt: usize) {
assert!(amt <= self.limit_within_buf - self.pos_within_buf);
self.pos_within_buf += amt;
}
@@ -433,9 +433,10 @@
#[cfg(all(test, feature = "bytes"))]
mod test_bytes {
- use super::*;
use std::io::Write;
+ use super::*;
+
fn make_long_string(len: usize) -> Vec<u8> {
let mut s = Vec::new();
while s.len() < len {
@@ -467,11 +468,12 @@
#[cfg(test)]
mod test {
- use super::*;
use std::io;
use std::io::BufRead;
use std::io::Read;
+ use super::*;
+
#[test]
fn eof_at_limit() {
struct Read5ThenPanic {
@@ -509,7 +511,12 @@
let _prev_limit = buf_read_iter.push_limit(5);
buf_read_iter.read_byte().expect("read_byte");
buf_read_iter
- .read_exact(&mut [1, 2, 3, 4])
+ .read_exact(&mut [
+ MaybeUninit::uninit(),
+ MaybeUninit::uninit(),
+ MaybeUninit::uninit(),
+ MaybeUninit::uninit(),
+ ])
.expect("read_exact");
assert!(buf_read_iter.eof().expect("eof"));
}
diff --git a/src/buf_read_or_reader.rs b/src/buf_read_or_reader.rs
new file mode 100644
index 0000000..6a47c76
--- /dev/null
+++ b/src/buf_read_or_reader.rs
@@ -0,0 +1,85 @@
+//! `BufRead` pointer or `BufReader` owned.
+
+use std::cmp;
+use std::io;
+use std::io::BufRead;
+use std::io::BufReader;
+use std::io::Read;
+use std::mem::MaybeUninit;
+
+use crate::misc::maybe_uninit_write_slice;
+
+/// Helper type to simplify `BufReadIter` implementation.
+pub(crate) enum BufReadOrReader<'a> {
+ BufReader(BufReader<&'a mut dyn Read>),
+ BufRead(&'a mut dyn BufRead),
+}
+
+impl<'a> Read for BufReadOrReader<'a> {
+ fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
+ match self {
+ BufReadOrReader::BufReader(r) => r.read(buf),
+ BufReadOrReader::BufRead(r) => r.read(buf),
+ }
+ }
+
+ fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, io::Error> {
+ match self {
+ BufReadOrReader::BufReader(r) => r.read_to_end(buf),
+ BufReadOrReader::BufRead(r) => r.read_to_end(buf),
+ }
+ }
+
+ fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), io::Error> {
+ match self {
+ BufReadOrReader::BufReader(r) => r.read_exact(buf),
+ BufReadOrReader::BufRead(r) => r.read_exact(buf),
+ }
+ }
+}
+
+impl<'a> BufReadOrReader<'a> {
+ /// Similar to `read_exact` but reads into `MaybeUninit`.
+ pub(crate) fn read_exact_uninit(
+ &mut self,
+ buf: &mut [MaybeUninit<u8>],
+ ) -> Result<(), io::Error> {
+ let mut pos = 0;
+ while pos != buf.len() {
+ let fill_buf = match self {
+ BufReadOrReader::BufReader(r) => r.fill_buf()?,
+ BufReadOrReader::BufRead(r) => r.fill_buf()?,
+ };
+ if fill_buf.is_empty() {
+ return Err(io::Error::new(
+ io::ErrorKind::UnexpectedEof,
+ "Unexpected end of file",
+ ));
+ }
+ let consume = cmp::min(fill_buf.len(), buf.len() - pos);
+ maybe_uninit_write_slice(&mut buf[pos..pos + consume], &fill_buf[..consume]);
+ match self {
+ BufReadOrReader::BufReader(r) => r.consume(consume),
+ BufReadOrReader::BufRead(r) => r.consume(consume),
+ }
+ pos += consume;
+ }
+ Ok(())
+ }
+}
+
+impl<'a> BufRead for BufReadOrReader<'a> {
+ fn fill_buf(&mut self) -> Result<&[u8], io::Error> {
+ match self {
+ BufReadOrReader::BufReader(r) => r.fill_buf(),
+ BufReadOrReader::BufRead(r) => r.fill_buf(),
+ }
+ }
+
+ fn consume(&mut self, amt: usize) {
+ match self {
+ BufReadOrReader::BufReader(r) => r.consume(amt),
+ BufReadOrReader::BufRead(r) => r.consume(amt),
+ }
+ }
+}
diff --git a/src/coded_input_stream.rs b/src/coded_input_stream.rs
index 52a13a6..a49563c 100644
--- a/src/coded_input_stream.rs
+++ b/src/coded_input_stream.rs
@@ -6,19 +6,21 @@
use std::io::BufRead;
use std::io::Read;
use std::mem;
+use std::mem::MaybeUninit;
use std::slice;
#[cfg(feature = "bytes")]
-use crate::chars::Chars;
-#[cfg(feature = "bytes")]
use bytes::Bytes;
use crate::buf_read_iter::BufReadIter;
+#[cfg(feature = "bytes")]
+use crate::chars::Chars;
use crate::enums::ProtobufEnum;
use crate::error::ProtobufError;
use crate::error::ProtobufResult;
use crate::error::WireError;
use crate::message::Message;
+use crate::misc::maybe_ununit_array_assume_init;
use crate::unknown::UnknownValue;
use crate::wire_format;
use crate::zigzag::decode_zig_zag_32;
@@ -105,12 +107,21 @@
}
/// Read bytes into given `buf`.
+ #[inline]
+ fn read_exact_uninit(&mut self, buf: &mut [MaybeUninit<u8>]) -> ProtobufResult<()> {
+ self.source.read_exact(buf)
+ }
+
+ /// Read bytes into given `buf`.
///
/// Return `0` on EOF.
// TODO: overload with `Read::read`
pub fn read(&mut self, buf: &mut [u8]) -> ProtobufResult<()> {
- self.source.read_exact(buf)?;
- Ok(())
+ // SAFETY: same layout
+ let buf = unsafe {
+ slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut MaybeUninit<u8>, buf.len())
+ };
+ self.read_exact_uninit(buf)
}
/// Read exact number of bytes as `Bytes` object.
@@ -248,24 +259,20 @@
/// Read little-endian 32-bit integer
pub fn read_raw_little_endian32(&mut self) -> ProtobufResult<u32> {
- let mut r = 0u32;
- let bytes: &mut [u8] = unsafe {
- let p: *mut u8 = mem::transmute(&mut r);
- slice::from_raw_parts_mut(p, mem::size_of::<u32>())
- };
- self.read(bytes)?;
- Ok(r.to_le())
+ let mut bytes = [MaybeUninit::uninit(); 4];
+ self.read_exact_uninit(&mut bytes)?;
+ // SAFETY: `read_exact` guarantees that the buffer is filled.
+ let bytes = unsafe { maybe_ununit_array_assume_init(bytes) };
+ Ok(u32::from_le_bytes(bytes))
}
/// Read little-endian 64-bit integer
pub fn read_raw_little_endian64(&mut self) -> ProtobufResult<u64> {
- let mut r = 0u64;
- let bytes: &mut [u8] = unsafe {
- let p: *mut u8 = mem::transmute(&mut r);
- slice::from_raw_parts_mut(p, mem::size_of::<u64>())
- };
- self.read(bytes)?;
- Ok(r.to_le())
+ let mut bytes = [MaybeUninit::uninit(); 8];
+ self.read_exact_uninit(&mut bytes)?;
+ // SAFETY: `read_exact` guarantees that the buffer is filled.
+ let bytes = unsafe { maybe_ununit_array_assume_init(bytes) };
+ Ok(u64::from_le_bytes(bytes))
}
/// Read tag
@@ -596,41 +603,7 @@
/// Read raw bytes into the supplied vector. The vector will be resized as needed and
/// overwritten.
pub fn read_raw_bytes_into(&mut self, count: u32, target: &mut Vec<u8>) -> ProtobufResult<()> {
- if false {
- // Master uses this version, but keep existing version for a while
- // to avoid possible breakages.
- return self.source.read_exact_to_vec(count as usize, target);
- }
-
- let count = count as usize;
-
- // TODO: also do some limits when reading from unlimited source
- if count as u64 > self.source.bytes_until_limit() {
- return Err(ProtobufError::WireError(WireError::TruncatedMessage));
- }
-
- unsafe {
- target.set_len(0);
- }
-
- if count >= READ_RAW_BYTES_MAX_ALLOC {
- // avoid calling `reserve` on buf with very large buffer: could be a malformed message
-
- let mut take = self.by_ref().take(count as u64);
- take.read_to_end(target)?;
-
- if target.len() != count {
- return Err(ProtobufError::WireError(WireError::TruncatedMessage));
- }
- } else {
- target.reserve(count);
- unsafe {
- target.set_len(count);
- }
-
- self.source.read_exact(target)?;
- }
- Ok(())
+ self.source.read_exact_to_vec(count as usize, target)
}
/// Read exact number of bytes
@@ -795,13 +768,12 @@
use std::io::BufRead;
use std::io::Read;
+ use super::CodedInputStream;
+ use super::READ_RAW_BYTES_MAX_ALLOC;
use crate::error::ProtobufError;
use crate::error::ProtobufResult;
use crate::hex::decode_hex;
- use super::CodedInputStream;
- use super::READ_RAW_BYTES_MAX_ALLOC;
-
fn test_read_partial<F>(hex: &str, mut callback: F)
where
F: FnMut(&mut CodedInputStream),
diff --git a/src/coded_output_stream.rs b/src/coded_output_stream.rs
index bbfe228..2bbe0a3 100644
--- a/src/coded_output_stream.rs
+++ b/src/coded_output_stream.rs
@@ -1,17 +1,23 @@
-use crate::misc::remaining_capacity_as_slice_mut;
-use crate::misc::remove_lifetime_mut;
+use std::io;
+use std::io::Write;
+use std::mem;
+use std::mem::MaybeUninit;
+use std::ptr;
+use std::slice;
+
+use crate::misc::maybe_uninit_write;
+use crate::misc::maybe_uninit_write_slice;
+use crate::misc::vec_spare_capacity_mut;
use crate::varint;
use crate::wire_format;
use crate::zigzag::encode_zig_zag_32;
use crate::zigzag::encode_zig_zag_64;
use crate::Message;
use crate::ProtobufEnum;
+use crate::ProtobufError;
use crate::ProtobufResult;
use crate::UnknownFields;
use crate::UnknownValueRef;
-use std::io;
-use std::io::Write;
-use std::mem;
/// Equal to the default buffer size of `BufWriter`, so when
/// `CodedOutputStream` wraps `BufWriter`, it often skips double buffering.
@@ -58,17 +64,27 @@
Ok(v)
}
+/// Output buffer/writer for `CodedOutputStream`.
enum OutputTarget<'a> {
Write(&'a mut dyn Write, Vec<u8>),
Vec(&'a mut Vec<u8>),
+ /// The buffer is passed as `&[u8]` to `CodedOutputStream` constructor
+ /// and immediately converted to `buffer` field of `CodedOutputStream`,
+ /// it is not needed to be stored here.
+ /// Lifetime parameter of `CodedOutputStream` guarantees the buffer is valid
+ /// during the lifetime of `CodedOutputStream`.
Bytes,
}
/// Buffered write with handy utilities
pub struct CodedOutputStream<'a> {
target: OutputTarget<'a>,
- // alias to buf from target
- buffer: &'a mut [u8],
+ // Actual buffer is owned by `OutputTarget`,
+ // and here we alias the buffer so access to the buffer is branchless:
+ // access does not require switch by actual target type: `&[], `Vec`, `Write` etc.
+ // We don't access the actual buffer in `OutputTarget` except when
+ // we initialize `buffer` field here.
+ buffer: *mut [MaybeUninit<u8>],
// within buffer
position: usize,
}
@@ -81,15 +97,16 @@
let buffer_len = OUTPUT_STREAM_BUFFER_SIZE;
let mut buffer_storage = Vec::with_capacity(buffer_len);
- unsafe {
- buffer_storage.set_len(buffer_len);
- }
- let buffer = unsafe { remove_lifetime_mut(&mut buffer_storage as &mut [u8]) };
+ // SAFETY: we are not using the `buffer_storage`
+ // except for initializing the `buffer` field.
+ // See `buffer` field documentation.
+ let buffer = vec_spare_capacity_mut(&mut buffer_storage);
+ let buffer: *mut [MaybeUninit<u8>] = buffer;
CodedOutputStream {
target: OutputTarget::Write(writer, buffer_storage),
- buffer: buffer,
+ buffer,
position: 0,
}
}
@@ -98,9 +115,12 @@
///
/// Attempt to write more than bytes capacity results in error.
pub fn bytes(bytes: &'a mut [u8]) -> CodedOutputStream<'a> {
+ // SAFETY: it is safe to cast from &mut [u8] to &mut [MaybeUninit<u8>].
+ let buffer =
+ ptr::slice_from_raw_parts_mut(bytes.as_mut_ptr() as *mut MaybeUninit<u8>, bytes.len());
CodedOutputStream {
target: OutputTarget::Bytes,
- buffer: bytes,
+ buffer,
position: 0,
}
}
@@ -110,9 +130,10 @@
/// Caller should call `flush` at the end to guarantee vec contains
/// all written data.
pub fn vec(vec: &'a mut Vec<u8>) -> CodedOutputStream<'a> {
+ let buffer: *mut [MaybeUninit<u8>] = &mut [];
CodedOutputStream {
target: OutputTarget::Vec(vec),
- buffer: &mut [],
+ buffer,
position: 0,
}
}
@@ -125,7 +146,7 @@
pub fn check_eof(&self) {
match self.target {
OutputTarget::Bytes => {
- assert_eq!(self.buffer.len() as u64, self.position as u64);
+ assert_eq!(self.buffer().len() as u64, self.position as u64);
}
OutputTarget::Write(..) | OutputTarget::Vec(..) => {
panic!("must not be called with Writer or Vec");
@@ -133,10 +154,25 @@
}
}
+ #[inline(always)]
+ fn buffer(&self) -> &[MaybeUninit<u8>] {
+ // SAFETY: see the `buffer` field documentation about invariants.
+ unsafe { &*(self.buffer as *mut [MaybeUninit<u8>]) }
+ }
+
+ #[inline(always)]
+ fn filled_buffer_impl<'s>(buffer: *mut [MaybeUninit<u8>], position: usize) -> &'s [u8] {
+ // SAFETY: this function is safe assuming `buffer` and `position`
+ // are `self.buffer` and `safe.position`:
+ // * `CodedOutputStream` has invariant that `position <= buffer.len()`.
+ // * `buffer` is filled up to `position`.
+ unsafe { slice::from_raw_parts_mut(buffer as *mut u8, position) }
+ }
+
fn refresh_buffer(&mut self) -> ProtobufResult<()> {
match self.target {
OutputTarget::Write(ref mut write, _) => {
- write.write_all(&self.buffer[0..self.position as usize])?;
+ write.write_all(Self::filled_buffer_impl(self.buffer, self.position))?;
self.position = 0;
}
OutputTarget::Vec(ref mut vec) => unsafe {
@@ -144,11 +180,14 @@
assert!(vec_len + self.position <= vec.capacity());
vec.set_len(vec_len + self.position);
vec.reserve(1);
- self.buffer = remove_lifetime_mut(remaining_capacity_as_slice_mut(vec));
+ self.buffer = vec_spare_capacity_mut(vec);
self.position = 0;
},
OutputTarget::Bytes => {
- panic!("refresh_buffer must not be called on CodedOutputStream create from slice");
+ return Err(ProtobufError::IoError(io::Error::new(
+ io::ErrorKind::Other,
+ "given slice is too small to serialize the message",
+ )));
}
}
Ok(())
@@ -167,20 +206,22 @@
/// Write a byte
pub fn write_raw_byte(&mut self, byte: u8) -> ProtobufResult<()> {
- if self.position as usize == self.buffer.len() {
+ if self.position as usize == self.buffer().len() {
self.refresh_buffer()?;
}
- self.buffer[self.position as usize] = byte;
+ unsafe { maybe_uninit_write(&mut (&mut *self.buffer)[self.position as usize], byte) };
self.position += 1;
Ok(())
}
/// Write bytes
pub fn write_raw_bytes(&mut self, bytes: &[u8]) -> ProtobufResult<()> {
- if bytes.len() <= self.buffer.len() - self.position {
+ if bytes.len() <= self.buffer().len() - self.position {
let bottom = self.position as usize;
let top = bottom + (bytes.len() as usize);
- self.buffer[bottom..top].copy_from_slice(bytes);
+ // SAFETY: see the `buffer` field documentation about invariants.
+ let buffer = unsafe { &mut (&mut *self.buffer)[bottom..top] };
+ maybe_uninit_write_slice(buffer, bytes);
self.position += bytes.len();
return Ok(());
}
@@ -189,8 +230,11 @@
assert!(self.position == 0);
- if self.position + bytes.len() < self.buffer.len() {
- self.buffer[self.position..self.position + bytes.len()].copy_from_slice(bytes);
+ if self.position + bytes.len() < self.buffer().len() {
+ // SAFETY: see the `buffer` field documentation about invariants.
+ let buffer =
+ unsafe { &mut (&mut *self.buffer)[self.position..self.position + bytes.len()] };
+ maybe_uninit_write_slice(buffer, bytes);
self.position += bytes.len();
return Ok(());
}
@@ -204,9 +248,7 @@
}
OutputTarget::Vec(ref mut vec) => {
vec.extend(bytes);
- unsafe {
- self.buffer = remove_lifetime_mut(remaining_capacity_as_slice_mut(vec));
- }
+ self.buffer = vec_spare_capacity_mut(vec)
}
}
Ok(())
@@ -223,30 +265,38 @@
/// Write varint
pub fn write_raw_varint32(&mut self, value: u32) -> ProtobufResult<()> {
- if self.buffer.len() - self.position >= 5 {
+ if self.buffer().len() - self.position >= 5 {
// fast path
- let len = varint::encode_varint32(value, &mut self.buffer[self.position..]);
+ let len = unsafe {
+ varint::encode_varint32(value, &mut (&mut *self.buffer)[self.position..])
+ };
self.position += len;
Ok(())
} else {
// slow path
let buf = &mut [0u8; 5];
- let len = varint::encode_varint32(value, buf);
+ let len = varint::encode_varint32(value, unsafe {
+ slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut MaybeUninit<u8>, buf.len())
+ });
self.write_raw_bytes(&buf[..len])
}
}
/// Write varint
pub fn write_raw_varint64(&mut self, value: u64) -> ProtobufResult<()> {
- if self.buffer.len() - self.position >= 10 {
+ if self.buffer().len() - self.position >= 10 {
// fast path
- let len = varint::encode_varint64(value, &mut self.buffer[self.position..]);
+ let len = unsafe {
+ varint::encode_varint64(value, &mut (&mut *self.buffer)[self.position..])
+ };
self.position += len;
Ok(())
} else {
// slow path
let buf = &mut [0u8; 10];
- let len = varint::encode_varint64(value, buf);
+ let len = varint::encode_varint64(value, unsafe {
+ slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut MaybeUninit<u8>, buf.len())
+ });
self.write_raw_bytes(&buf[..len])
}
}
@@ -532,13 +582,14 @@
#[cfg(test)]
mod test {
+ use std::io::Write;
+ use std::iter;
+
use crate::coded_output_stream::CodedOutputStream;
use crate::hex::decode_hex;
use crate::hex::encode_hex;
use crate::wire_format;
use crate::ProtobufResult;
- use std::io::Write;
- use std::iter;
fn test_write<F>(expected: &str, mut gen: F)
where
diff --git a/src/compiler_plugin.rs b/src/compiler_plugin.rs
index e056071..122eeb3 100644
--- a/src/compiler_plugin.rs
+++ b/src/compiler_plugin.rs
@@ -1,13 +1,14 @@
// TODO: move into separate crate
#![doc(hidden)]
-use crate::descriptor::FileDescriptorProto;
-use crate::plugin::*;
-use crate::Message;
use std::io::stdin;
use std::io::stdout;
use std::str;
+use crate::descriptor::FileDescriptorProto;
+use crate::plugin::*;
+use crate::Message;
+
pub struct GenRequest<'a> {
pub file_descriptors: &'a [FileDescriptorProto],
pub files_to_generate: &'a [String],
diff --git a/src/descriptor.rs b/src/descriptor.rs
index 8f3dd2f..7ca155d 100644
--- a/src/descriptor.rs
+++ b/src/descriptor.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.22.0. Do not edit
+// This file is generated by rust-protobuf 2.26.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
diff --git a/src/descriptorx.rs b/src/descriptorx.rs
index 82baab8..7b046ec 100644
--- a/src/descriptorx.rs
+++ b/src/descriptorx.rs
@@ -8,7 +8,6 @@
/// utilities to work with descriptor
use crate::descriptor::FileDescriptorProto;
use crate::descriptor::OneofDescriptorProto;
-
use crate::rust;
use crate::strx;
diff --git a/src/lazy.rs b/src/lazy.rs
index 5b01502..3575dd0 100644
--- a/src/lazy.rs
+++ b/src/lazy.rs
@@ -56,13 +56,14 @@
#[cfg(test)]
mod test {
- use super::Lazy;
use std::sync::atomic::AtomicIsize;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::sync::Barrier;
use std::thread;
+ use super::Lazy;
+
#[test]
fn many_threads_calling_get() {
const N_THREADS: usize = 32;
diff --git a/src/lazy_v2.rs b/src/lazy_v2.rs
index 4ba10a5..6f9ac1e 100644
--- a/src/lazy_v2.rs
+++ b/src/lazy_v2.rs
@@ -33,13 +33,14 @@
#[cfg(test)]
mod test {
- use super::LazyV2;
use std::sync::atomic::AtomicIsize;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::sync::Barrier;
use std::thread;
+ use super::LazyV2;
+
#[test]
fn many_threads_calling_get() {
const N_THREADS: usize = 32;
diff --git a/src/lib.rs b/src/lib.rs
index 8eee9d3..d88e029 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,7 +1,97 @@
-//! Library to read and write protocol buffers data.
+//! # Library to read and write protocol buffers data
+//!
+//! # Version 2 is stable
+//!
+//! Currently developed branch of rust-protobuf [is 3](https://docs.rs/protobuf/%3E=3.0.0-alpha).
+//! It has the same spirit as version 2, but contains numerous improvements like:
+//! * runtime reflection for mutability, not just for access
+//! * protobuf text format and JSON parsing (which rely on reflection)
+//! * dynamic message support: work with protobuf data without generating code from schema
+//!
+//! Stable version of rust-protobuf will be supported until version 3 released.
+//!
+//! [Tracking issue for version 3](https://github.com/stepancheg/rust-protobuf/issues/518).
+//!
+//! # How to generate rust code
+//!
+//! There are several ways to generate rust code from `.proto` files
+//!
+//! ## Invoke `protoc` programmatically with protoc-rust crate (recommended)
+//!
+//! Have a look at readme in [protoc-rust crate](https://docs.rs/protoc-rust/=2).
+//!
+//! ## Use pure rust protobuf parser and code generator
+//!
+//! Readme should be in
+//! [protobuf-codegen-pure crate](https://docs.rs/protobuf-codegen-pure/=2).
+//!
+//! ## Use protoc-gen-rust plugin
+//!
+//! Readme is [here](https://docs.rs/protobuf-codegen/=2).
+//!
+//! ## Generated code
+//!
+//! Have a look at generated files (for current development version),
+//! used internally in rust-protobuf:
+//!
+//! * [descriptor.rs](https://github.com/stepancheg/rust-protobuf/blob/master/protobuf/src/descriptor.rs)
+//! for [descriptor.proto](https://github.com/stepancheg/rust-protobuf/blob/master/protoc-bin-vendored/include/google/protobuf/descriptor.proto)
+//! (that is part of Google protobuf)
+//!
+//! # Copy on write
+//!
+//! Rust-protobuf can be used with [bytes crate](https://github.com/tokio-rs/bytes).
+//!
+//! To enable `Bytes` you need to:
+//!
+//! 1. Enable `with-bytes` feature in rust-protobuf:
+//!
+//! ```
+//! [dependencies]
+//! protobuf = { version = "~2.0", features = ["with-bytes"] }
+//! ```
+//!
+//! 2. Enable bytes option
+//!
+//! with `Customize` when codegen is invoked programmatically:
+//!
+//! ```ignore
+//! protoc_rust::run(protoc_rust::Args {
+//! ...
+//! customize: Customize {
+//! carllerche_bytes_for_bytes: Some(true),
+//! carllerche_bytes_for_string: Some(true),
+//! ..Default::default()
+//! },
+//! });
+//! ```
+//!
+//! or in `.proto` file:
+//!
+//! ```ignore
+//! import "rustproto.proto";
+//!
+//! option (rustproto.carllerche_bytes_for_bytes_all) = true;
+//! option (rustproto.carllerche_bytes_for_string_all) = true;
+//! ```
+//!
+//! With these options enabled, fields of type `bytes` or `string` are
+//! generated as `Bytes` or `Chars` respectively. When `CodedInputStream` is constructed
+//! from `Bytes` object, fields of these types get subslices of original `Bytes` object,
+//! instead of being allocated on heap.
+//!
+//! # Accompanying crates
+//!
+//! * [`protoc-rust`](https://docs.rs/protoc-rust/=2)
+//! and [`protobuf-codegen-pure`](https://docs.rs/protobuf-codegen-pure/=2)
+//! can be used to rust code from `.proto` crates.
+//! * [`protobuf-codegen`](https://docs.rs/protobuf-codegen/=2) for `protoc-gen-rust` protoc plugin.
+//! * [`protoc`](https://docs.rs/protoc/=2) crate can be used to invoke `protoc` programmatically.
+//! * [`protoc-bin-vendored`](https://docs.rs/protoc-bin-vendored/=2) contains `protoc` command
+//! packed into the crate.
#![deny(missing_docs)]
-#![deny(broken_intra_doc_links)]
+#![deny(rustdoc::broken_intra_doc_links)]
#[cfg(feature = "bytes")]
extern crate bytes;
@@ -90,6 +180,7 @@
mod misc;
mod buf_read_iter;
+mod buf_read_or_reader;
/// This symbol is in generated `version.rs`, include here for IDE
#[cfg(never)]
diff --git a/src/misc.rs b/src/misc.rs
index d923d58..faef34f 100644
--- a/src/misc.rs
+++ b/src/misc.rs
@@ -1,37 +1,52 @@
use std::mem;
+use std::mem::MaybeUninit;
use std::slice;
-/// Slice from `vec[vec.len()..vec.capacity()]`
-pub unsafe fn remaining_capacity_as_slice_mut<A>(vec: &mut Vec<A>) -> &mut [A] {
- slice::from_raw_parts_mut(
- vec.as_mut_slice().as_mut_ptr().offset(vec.len() as isize),
- vec.capacity() - vec.len(),
- )
-}
-
-pub unsafe fn remove_lifetime_mut<A: ?Sized>(a: &mut A) -> &'static mut A {
- mem::transmute(a)
-}
-
-#[cfg(test)]
-mod test {
- use super::*;
-
- #[test]
- fn test_remaining_capacity_as_slice_mut() {
- let mut v = Vec::with_capacity(5);
- v.push(10);
- v.push(11);
- v.push(12);
- unsafe {
- {
- let s = remaining_capacity_as_slice_mut(&mut v);
- assert_eq!(2, s.len());
- s[0] = 13;
- s[1] = 14;
- }
- v.set_len(5);
- }
- assert_eq!(vec![10, 11, 12, 13, 14], v);
+/// `Vec::spare_capacity_mut` is not stable until Rust 1.60.
+pub(crate) fn vec_spare_capacity_mut<A>(vec: &mut Vec<A>) -> &mut [MaybeUninit<A>] {
+ // SAFETY: copy-paste from rust stdlib.
+ unsafe {
+ slice::from_raw_parts_mut(
+ vec.as_mut_ptr().add(vec.len()) as *mut MaybeUninit<A>,
+ vec.capacity() - vec.len(),
+ )
}
}
+
+/// `MaybeUninit::write_slice` is not stable.
+pub(crate) fn maybe_uninit_write_slice<'a, T>(
+ this: &'a mut [MaybeUninit<T>],
+ src: &[T],
+) -> &'a mut [T]
+where
+ T: Copy,
+{
+ // SAFETY: copy-paste from rust stdlib.
+
+ let uninit_src: &[MaybeUninit<T>] = unsafe { mem::transmute(src) };
+
+ this.copy_from_slice(uninit_src);
+
+ unsafe { &mut *(this as *mut [MaybeUninit<T>] as *mut [T]) }
+}
+
+/// `MaybeUninit::array_assume_init` is not stable.
+#[inline]
+pub(crate) unsafe fn maybe_ununit_array_assume_init<T, const N: usize>(
+ array: [MaybeUninit<T>; N],
+) -> [T; N] {
+ // SAFETY:
+ // * The caller guarantees that all elements of the array are initialized
+ // * `MaybeUninit<T>` and T are guaranteed to have the same layout
+ // * `MaybeUninit` does not drop, so there are no double-frees
+ // And thus the conversion is safe
+ (&array as *const _ as *const [T; N]).read()
+}
+
+/// `MaybeUninit::write` is stable since 1.55.
+#[inline]
+pub(crate) fn maybe_uninit_write<T>(uninit: &mut MaybeUninit<T>, val: T) -> &mut T {
+ // SAFETY: copy-paste from rust stdlib.
+ *uninit = MaybeUninit::new(val);
+ unsafe { &mut *uninit.as_mut_ptr() }
+}
diff --git a/src/plugin.rs b/src/plugin.rs
index 77e1666..93f2ca8 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.22.0. Do not edit
+// This file is generated by rust-protobuf 2.26.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
diff --git a/src/reflect/acc/v1.rs b/src/reflect/acc/v1.rs
index d6bd3d3..4c55f8f 100644
--- a/src/reflect/acc/v1.rs
+++ b/src/reflect/acc/v1.rs
@@ -9,21 +9,20 @@
use crate::enums::ProtobufEnum;
use crate::message::message_down_cast;
use crate::message::Message;
-use crate::reflect::EnumValueDescriptor;
-use crate::reflect::ProtobufValue;
-use crate::reflect::ReflectFieldRef;
-use crate::reflect::ReflectValueRef;
-use crate::types::*;
-
use crate::reflect::map::ReflectMap;
use crate::reflect::optional::ReflectOptional;
use crate::reflect::repeated::ReflectRepeated;
use crate::reflect::repeated::ReflectRepeatedEnum;
use crate::reflect::repeated::ReflectRepeatedMessage;
use crate::reflect::rt::FieldAccessor;
+use crate::reflect::EnumValueDescriptor;
+use crate::reflect::ProtobufValue;
+use crate::reflect::ReflectFieldRef;
+use crate::reflect::ReflectValueRef;
use crate::repeated::RepeatedField;
use crate::singular::SingularField;
use crate::singular::SingularPtrField;
+use crate::types::*;
/// this trait should not be used directly, use `FieldDescriptor` instead
pub trait FieldAccessorTrait: Sync + 'static {
diff --git a/src/reflect/enums.rs b/src/reflect/enums.rs
index f1ad901..a25be6f 100644
--- a/src/reflect/enums.rs
+++ b/src/reflect/enums.rs
@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
use crate::descriptor::EnumDescriptorProto;
use crate::descriptor::EnumValueDescriptorProto;
use crate::descriptor::FileDescriptorProto;
@@ -5,7 +7,6 @@
use crate::reflect::find_message_or_enum::find_message_or_enum;
use crate::reflect::find_message_or_enum::MessageOrEnum;
use crate::ProtobufEnum;
-use std::collections::HashMap;
/// Description for enum variant.
///
diff --git a/src/reflect/message.rs b/src/reflect/message.rs
index 53ea2ce..0db9821 100644
--- a/src/reflect/message.rs
+++ b/src/reflect/message.rs
@@ -1,3 +1,6 @@
+use std::collections::HashMap;
+use std::marker;
+
use crate::descriptor::DescriptorProto;
use crate::descriptor::FileDescriptorProto;
use crate::descriptorx::find_message_by_rust_name;
@@ -6,8 +9,6 @@
use crate::reflect::find_message_or_enum::MessageOrEnum;
use crate::reflect::FieldDescriptor;
use crate::Message;
-use std::collections::HashMap;
-use std::marker;
trait MessageFactory: Send + Sync + 'static {
fn new_instance(&self) -> Box<dyn Message>;
diff --git a/src/reflect/mod.rs b/src/reflect/mod.rs
index 392f629..e120e16 100644
--- a/src/reflect/mod.rs
+++ b/src/reflect/mod.rs
@@ -23,8 +23,6 @@
pub use self::enums::EnumDescriptor;
pub use self::enums::EnumValueDescriptor;
-
-pub use self::message::MessageDescriptor;
-
pub use self::field::FieldDescriptor;
pub use self::field::ReflectFieldRef;
+pub use self::message::MessageDescriptor;
diff --git a/src/reflect/optional.rs b/src/reflect/optional.rs
index f81f973..f719a2c 100644
--- a/src/reflect/optional.rs
+++ b/src/reflect/optional.rs
@@ -1,7 +1,6 @@
use std::mem;
use super::value::ProtobufValue;
-
use crate::singular::*;
pub trait ReflectOptional: 'static {
diff --git a/src/reflect/repeated.rs b/src/reflect/repeated.rs
index be232f4..710de3e 100644
--- a/src/reflect/repeated.rs
+++ b/src/reflect/repeated.rs
@@ -2,7 +2,6 @@
use super::value::ProtobufValue;
use super::value::ReflectValueRef;
-
use crate::repeated::RepeatedField;
pub trait ReflectRepeated: 'static {
diff --git a/src/reflect/value.rs b/src/reflect/value.rs
index 16d5266..9598b9f 100644
--- a/src/reflect/value.rs
+++ b/src/reflect/value.rs
@@ -1,11 +1,11 @@
use std::any::Any;
#[cfg(feature = "bytes")]
-use crate::chars::Chars;
-#[cfg(feature = "bytes")]
use bytes::Bytes;
use super::*;
+#[cfg(feature = "bytes")]
+use crate::chars::Chars;
/// Type implemented by all protobuf elementary types
/// (ints, floats, bool, string, bytes, enums, messages).
diff --git a/src/repeated.rs b/src/repeated.rs
index d157f0c..0b749d9 100644
--- a/src/repeated.rs
+++ b/src/repeated.rs
@@ -1,6 +1,3 @@
-#[cfg(feature = "with-serde")]
-use serde;
-
use std::borrow::Borrow;
use std::cmp::Ordering;
use std::default::Default;
@@ -16,6 +13,9 @@
use std::slice;
use std::vec;
+#[cfg(feature = "with-serde")]
+use serde;
+
use crate::clear::Clear;
/// Wrapper around vector to avoid deallocations on clear.
diff --git a/src/rt.rs b/src/rt.rs
index 3bb0280..fca1254 100644
--- a/src/rt.rs
+++ b/src/rt.rs
@@ -6,27 +6,26 @@
use std::hash::Hash;
#[cfg(feature = "bytes")]
-use crate::chars::Chars;
-#[cfg(feature = "bytes")]
use bytes::Bytes;
+#[cfg(feature = "bytes")]
+use crate::chars::Chars;
use crate::coded_input_stream::CodedInputStream;
use crate::coded_output_stream::CodedOutputStream;
use crate::enums::ProtobufEnum;
use crate::error::ProtobufError;
use crate::error::ProtobufResult;
use crate::error::WireError;
+pub use crate::lazy_v2::LazyV2;
use crate::message::*;
use crate::repeated::RepeatedField;
use crate::singular::SingularField;
use crate::singular::SingularPtrField;
use crate::types::*;
-use crate::zigzag::*;
-
-pub use crate::lazy_v2::LazyV2;
use crate::unknown::UnknownFields;
use crate::wire_format;
use crate::wire_format::WireType;
+use crate::zigzag::*;
/// Given `u64` value compute varint encoded length.
pub fn compute_raw_varint64_size(value: u64) -> u32 {
diff --git a/src/rustproto.rs b/src/rustproto.rs
index 83854e4..75df067 100644
--- a/src/rustproto.rs
+++ b/src/rustproto.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.22.0. Do not edit
+// This file is generated by rust-protobuf 2.26.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
@@ -59,6 +59,8 @@
pub const carllerche_bytes_for_bytes_field: crate::ext::ExtFieldOptional<crate::descriptor::FieldOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17011, phantom: ::std::marker::PhantomData };
pub const carllerche_bytes_for_string_field: crate::ext::ExtFieldOptional<crate::descriptor::FieldOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17012, phantom: ::std::marker::PhantomData };
+
+ pub const serde_rename_all: crate::ext::ExtFieldOptional<crate::descriptor::EnumOptions, crate::types::ProtobufTypeString> = crate::ext::ExtFieldOptional { field_number: 17032, phantom: ::std::marker::PhantomData };
}
static file_descriptor_proto_data: &'static [u8] = b"\
@@ -94,92 +96,98 @@
s_for_bytes_field\x18\xf3\x84\x01\x20\x01(\x08\x12\x1d.google.protobuf.F\
ieldOptionsR\x1ccarllercheBytesForBytesField:i\n!carllerche_bytes_for_st\
ring_field\x18\xf4\x84\x01\x20\x01(\x08\x12\x1d.google.protobuf.FieldOpt\
- ionsR\x1dcarllercheBytesForStringFieldJ\xf2\x13\n\x06\x12\x04\0\07\x01\n\
- \x08\n\x01\x0c\x12\x03\0\0\x12\n\t\n\x02\x03\0\x12\x03\x02\0*\nh\n\x01\
- \x02\x12\x03\x07\0\x122^\x20see\x20https://github.com/gogo/protobuf/blob\
- /master/gogoproto/gogo.proto\n\x20for\x20the\x20original\x20idea\n\n\t\n\
- \x01\x07\x12\x04\t\0\x1b\x01\n7\n\x02\x07\0\x12\x03\x0b\x04+\x1a,\x20Whe\
- n\x20true,\x20oneof\x20field\x20is\x20generated\x20public\n\n\n\n\x03\
- \x07\0\x02\x12\x03\t\x07\"\n\n\n\x03\x07\0\x04\x12\x03\x0b\x04\x0c\n\n\n\
- \x03\x07\0\x05\x12\x03\x0b\r\x11\n\n\n\x03\x07\0\x01\x12\x03\x0b\x12\"\n\
- \n\n\x03\x07\0\x03\x12\x03\x0b%*\nI\n\x02\x07\x01\x12\x03\r\x04,\x1a>\
- \x20When\x20true\x20all\x20fields\x20are\x20public,\x20and\x20not\x20acc\
- essors\x20generated\n\n\n\n\x03\x07\x01\x02\x12\x03\t\x07\"\n\n\n\x03\
- \x07\x01\x04\x12\x03\r\x04\x0c\n\n\n\x03\x07\x01\x05\x12\x03\r\r\x11\n\n\
- \n\x03\x07\x01\x01\x12\x03\r\x12#\n\n\n\x03\x07\x01\x03\x12\x03\r&+\nP\n\
- \x02\x07\x02\x12\x03\x0f\x041\x1aE\x20When\x20false,\x20`get_`,\x20`set_\
- `,\x20`mut_`\x20etc.\x20accessors\x20are\x20not\x20generated\n\n\n\n\x03\
- \x07\x02\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x02\x04\x12\x03\x0f\x04\x0c\n\
- \n\n\x03\x07\x02\x05\x12\x03\x0f\r\x11\n\n\n\x03\x07\x02\x01\x12\x03\x0f\
- \x12(\n\n\n\x03\x07\x02\x03\x12\x03\x0f+0\n2\n\x02\x07\x03\x12\x03\x11\
- \x049\x1a'\x20Use\x20`bytes::Bytes`\x20for\x20`bytes`\x20fields\n\n\n\n\
- \x03\x07\x03\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x03\x04\x12\x03\x11\x04\
- \x0c\n\n\n\x03\x07\x03\x05\x12\x03\x11\r\x11\n\n\n\x03\x07\x03\x01\x12\
- \x03\x11\x120\n\n\n\x03\x07\x03\x03\x12\x03\x1138\n3\n\x02\x07\x04\x12\
- \x03\x13\x04:\x1a(\x20Use\x20`bytes::Bytes`\x20for\x20`string`\x20fields\
- \n\n\n\n\x03\x07\x04\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x04\x04\x12\x03\
- \x13\x04\x0c\n\n\n\x03\x07\x04\x05\x12\x03\x13\r\x11\n\n\n\x03\x07\x04\
- \x01\x12\x03\x13\x121\n\n\n\x03\x07\x04\x03\x12\x03\x1349\nJ\n\x02\x07\
- \x05\x12\x03\x15\x04+\x1a?\x20Use\x20`serde_derive`\x20to\x20implement\
- \x20`Serialize`\x20and\x20`Deserialize`\n\n\n\n\x03\x07\x05\x02\x12\x03\
- \t\x07\"\n\n\n\x03\x07\x05\x04\x12\x03\x15\x04\x0c\n\n\n\x03\x07\x05\x05\
- \x12\x03\x15\r\x11\n\n\n\x03\x07\x05\x01\x12\x03\x15\x12\"\n\n\n\x03\x07\
- \x05\x03\x12\x03\x15%*\n3\n\x02\x07\x06\x12\x03\x17\x041\x1a(\x20Guard\
- \x20serde\x20annotations\x20with\x20cfg\x20attr.\n\n\n\n\x03\x07\x06\x02\
- \x12\x03\t\x07\"\n\n\n\x03\x07\x06\x04\x12\x03\x17\x04\x0c\n\n\n\x03\x07\
- \x06\x05\x12\x03\x17\r\x13\n\n\n\x03\x07\x06\x01\x12\x03\x17\x14(\n\n\n\
- \x03\x07\x06\x03\x12\x03\x17+0\nN\n\x02\x07\x07\x12\x03\x1a\x04+\x1aC\
- \x20When\x20true,\x20will\x20only\x20generate\x20codes\x20that\x20works\
- \x20with\x20lite\x20runtime.\n\n\n\n\x03\x07\x07\x02\x12\x03\t\x07\"\n\n\
- \n\x03\x07\x07\x04\x12\x03\x1a\x04\x0c\n\n\n\x03\x07\x07\x05\x12\x03\x1a\
- \r\x11\n\n\n\x03\x07\x07\x01\x12\x03\x1a\x12\"\n\n\n\x03\x07\x07\x03\x12\
- \x03\x1a%*\n\t\n\x01\x07\x12\x04\x1d\0,\x01\n7\n\x02\x07\x08\x12\x03\x1f\
- \x04'\x1a,\x20When\x20true,\x20oneof\x20field\x20is\x20generated\x20publ\
- ic\n\n\n\n\x03\x07\x08\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\x08\x04\x12\
- \x03\x1f\x04\x0c\n\n\n\x03\x07\x08\x05\x12\x03\x1f\r\x11\n\n\n\x03\x07\
- \x08\x01\x12\x03\x1f\x12\x1e\n\n\n\x03\x07\x08\x03\x12\x03\x1f!&\nI\n\
- \x02\x07\t\x12\x03!\x04(\x1a>\x20When\x20true\x20all\x20fields\x20are\
- \x20public,\x20and\x20not\x20accessors\x20generated\n\n\n\n\x03\x07\t\
- \x02\x12\x03\x1d\x07%\n\n\n\x03\x07\t\x04\x12\x03!\x04\x0c\n\n\n\x03\x07\
- \t\x05\x12\x03!\r\x11\n\n\n\x03\x07\t\x01\x12\x03!\x12\x1f\n\n\n\x03\x07\
- \t\x03\x12\x03!\"'\nP\n\x02\x07\n\x12\x03#\x04-\x1aE\x20When\x20false,\
- \x20`get_`,\x20`set_`,\x20`mut_`\x20etc.\x20accessors\x20are\x20not\x20g\
- enerated\n\n\n\n\x03\x07\n\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\n\x04\x12\
- \x03#\x04\x0c\n\n\n\x03\x07\n\x05\x12\x03#\r\x11\n\n\n\x03\x07\n\x01\x12\
- \x03#\x12$\n\n\n\x03\x07\n\x03\x12\x03#',\n2\n\x02\x07\x0b\x12\x03%\x045\
- \x1a'\x20Use\x20`bytes::Bytes`\x20for\x20`bytes`\x20fields\n\n\n\n\x03\
- \x07\x0b\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\x0b\x04\x12\x03%\x04\x0c\n\n\
- \n\x03\x07\x0b\x05\x12\x03%\r\x11\n\n\n\x03\x07\x0b\x01\x12\x03%\x12,\n\
- \n\n\x03\x07\x0b\x03\x12\x03%/4\n3\n\x02\x07\x0c\x12\x03'\x046\x1a(\x20U\
- se\x20`bytes::Bytes`\x20for\x20`string`\x20fields\n\n\n\n\x03\x07\x0c\
- \x02\x12\x03\x1d\x07%\n\n\n\x03\x07\x0c\x04\x12\x03'\x04\x0c\n\n\n\x03\
- \x07\x0c\x05\x12\x03'\r\x11\n\n\n\x03\x07\x0c\x01\x12\x03'\x12-\n\n\n\
- \x03\x07\x0c\x03\x12\x03'05\nJ\n\x02\x07\r\x12\x03)\x04'\x1a?\x20Use\x20\
+ ionsR\x1dcarllercheBytesForStringField:H\n\x10serde_rename_all\x18\x88\
+ \x85\x01\x20\x01(\t\x12\x1c.google.protobuf.EnumOptionsR\x0eserdeRenameA\
+ llJ\xea\x14\n\x06\x12\x04\0\0<\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\t\n\
+ \x02\x03\0\x12\x03\x02\0*\nh\n\x01\x02\x12\x03\x07\0\x122^\x20see\x20htt\
+ ps://github.com/gogo/protobuf/blob/master/gogoproto/gogo.proto\n\x20for\
+ \x20the\x20original\x20idea\n\n\t\n\x01\x07\x12\x04\t\0\x1b\x01\n7\n\x02\
+ \x07\0\x12\x03\x0b\x04+\x1a,\x20When\x20true,\x20oneof\x20field\x20is\
+ \x20generated\x20public\n\n\n\n\x03\x07\0\x02\x12\x03\t\x07\"\n\n\n\x03\
+ \x07\0\x04\x12\x03\x0b\x04\x0c\n\n\n\x03\x07\0\x05\x12\x03\x0b\r\x11\n\n\
+ \n\x03\x07\0\x01\x12\x03\x0b\x12\"\n\n\n\x03\x07\0\x03\x12\x03\x0b%*\nI\
+ \n\x02\x07\x01\x12\x03\r\x04,\x1a>\x20When\x20true\x20all\x20fields\x20a\
+ re\x20public,\x20and\x20not\x20accessors\x20generated\n\n\n\n\x03\x07\
+ \x01\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x01\x04\x12\x03\r\x04\x0c\n\n\n\
+ \x03\x07\x01\x05\x12\x03\r\r\x11\n\n\n\x03\x07\x01\x01\x12\x03\r\x12#\n\
+ \n\n\x03\x07\x01\x03\x12\x03\r&+\nP\n\x02\x07\x02\x12\x03\x0f\x041\x1aE\
+ \x20When\x20false,\x20`get_`,\x20`set_`,\x20`mut_`\x20etc.\x20accessors\
+ \x20are\x20not\x20generated\n\n\n\n\x03\x07\x02\x02\x12\x03\t\x07\"\n\n\
+ \n\x03\x07\x02\x04\x12\x03\x0f\x04\x0c\n\n\n\x03\x07\x02\x05\x12\x03\x0f\
+ \r\x11\n\n\n\x03\x07\x02\x01\x12\x03\x0f\x12(\n\n\n\x03\x07\x02\x03\x12\
+ \x03\x0f+0\n2\n\x02\x07\x03\x12\x03\x11\x049\x1a'\x20Use\x20`bytes::Byte\
+ s`\x20for\x20`bytes`\x20fields\n\n\n\n\x03\x07\x03\x02\x12\x03\t\x07\"\n\
+ \n\n\x03\x07\x03\x04\x12\x03\x11\x04\x0c\n\n\n\x03\x07\x03\x05\x12\x03\
+ \x11\r\x11\n\n\n\x03\x07\x03\x01\x12\x03\x11\x120\n\n\n\x03\x07\x03\x03\
+ \x12\x03\x1138\n3\n\x02\x07\x04\x12\x03\x13\x04:\x1a(\x20Use\x20`bytes::\
+ Bytes`\x20for\x20`string`\x20fields\n\n\n\n\x03\x07\x04\x02\x12\x03\t\
+ \x07\"\n\n\n\x03\x07\x04\x04\x12\x03\x13\x04\x0c\n\n\n\x03\x07\x04\x05\
+ \x12\x03\x13\r\x11\n\n\n\x03\x07\x04\x01\x12\x03\x13\x121\n\n\n\x03\x07\
+ \x04\x03\x12\x03\x1349\nJ\n\x02\x07\x05\x12\x03\x15\x04+\x1a?\x20Use\x20\
`serde_derive`\x20to\x20implement\x20`Serialize`\x20and\x20`Deserialize`\
- \n\n\n\n\x03\x07\r\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\r\x04\x12\x03)\x04\
- \x0c\n\n\n\x03\x07\r\x05\x12\x03)\r\x11\n\n\n\x03\x07\r\x01\x12\x03)\x12\
- \x1e\n\n\n\x03\x07\r\x03\x12\x03)!&\n3\n\x02\x07\x0e\x12\x03+\x04-\x1a(\
- \x20Guard\x20serde\x20annotations\x20with\x20cfg\x20attr.\n\n\n\n\x03\
- \x07\x0e\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\x0e\x04\x12\x03+\x04\x0c\n\n\
- \n\x03\x07\x0e\x05\x12\x03+\r\x13\n\n\n\x03\x07\x0e\x01\x12\x03+\x14$\n\
- \n\n\x03\x07\x0e\x03\x12\x03+',\n\t\n\x01\x07\x12\x04.\07\x01\nI\n\x02\
- \x07\x0f\x12\x030\x04.\x1a>\x20When\x20true\x20all\x20fields\x20are\x20p\
- ublic,\x20and\x20not\x20accessors\x20generated\n\n\n\n\x03\x07\x0f\x02\
- \x12\x03.\x07#\n\n\n\x03\x07\x0f\x04\x12\x030\x04\x0c\n\n\n\x03\x07\x0f\
- \x05\x12\x030\r\x11\n\n\n\x03\x07\x0f\x01\x12\x030\x12%\n\n\n\x03\x07\
- \x0f\x03\x12\x030(-\nP\n\x02\x07\x10\x12\x032\x043\x1aE\x20When\x20false\
- ,\x20`get_`,\x20`set_`,\x20`mut_`\x20etc.\x20accessors\x20are\x20not\x20\
- generated\n\n\n\n\x03\x07\x10\x02\x12\x03.\x07#\n\n\n\x03\x07\x10\x04\
- \x12\x032\x04\x0c\n\n\n\x03\x07\x10\x05\x12\x032\r\x11\n\n\n\x03\x07\x10\
- \x01\x12\x032\x12*\n\n\n\x03\x07\x10\x03\x12\x032-2\n2\n\x02\x07\x11\x12\
- \x034\x04;\x1a'\x20Use\x20`bytes::Bytes`\x20for\x20`bytes`\x20fields\n\n\
- \n\n\x03\x07\x11\x02\x12\x03.\x07#\n\n\n\x03\x07\x11\x04\x12\x034\x04\
- \x0c\n\n\n\x03\x07\x11\x05\x12\x034\r\x11\n\n\n\x03\x07\x11\x01\x12\x034\
- \x122\n\n\n\x03\x07\x11\x03\x12\x0345:\n3\n\x02\x07\x12\x12\x036\x04<\
- \x1a(\x20Use\x20`bytes::Bytes`\x20for\x20`string`\x20fields\n\n\n\n\x03\
- \x07\x12\x02\x12\x03.\x07#\n\n\n\x03\x07\x12\x04\x12\x036\x04\x0c\n\n\n\
- \x03\x07\x12\x05\x12\x036\r\x11\n\n\n\x03\x07\x12\x01\x12\x036\x123\n\n\
- \n\x03\x07\x12\x03\x12\x0366;\
+ \n\n\n\n\x03\x07\x05\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x05\x04\x12\x03\
+ \x15\x04\x0c\n\n\n\x03\x07\x05\x05\x12\x03\x15\r\x11\n\n\n\x03\x07\x05\
+ \x01\x12\x03\x15\x12\"\n\n\n\x03\x07\x05\x03\x12\x03\x15%*\n3\n\x02\x07\
+ \x06\x12\x03\x17\x041\x1a(\x20Guard\x20serde\x20annotations\x20with\x20c\
+ fg\x20attr.\n\n\n\n\x03\x07\x06\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x06\
+ \x04\x12\x03\x17\x04\x0c\n\n\n\x03\x07\x06\x05\x12\x03\x17\r\x13\n\n\n\
+ \x03\x07\x06\x01\x12\x03\x17\x14(\n\n\n\x03\x07\x06\x03\x12\x03\x17+0\nN\
+ \n\x02\x07\x07\x12\x03\x1a\x04+\x1aC\x20When\x20true,\x20will\x20only\
+ \x20generate\x20codes\x20that\x20works\x20with\x20lite\x20runtime.\n\n\n\
+ \n\x03\x07\x07\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x07\x04\x12\x03\x1a\x04\
+ \x0c\n\n\n\x03\x07\x07\x05\x12\x03\x1a\r\x11\n\n\n\x03\x07\x07\x01\x12\
+ \x03\x1a\x12\"\n\n\n\x03\x07\x07\x03\x12\x03\x1a%*\n\t\n\x01\x07\x12\x04\
+ \x1d\0,\x01\n7\n\x02\x07\x08\x12\x03\x1f\x04'\x1a,\x20When\x20true,\x20o\
+ neof\x20field\x20is\x20generated\x20public\n\n\n\n\x03\x07\x08\x02\x12\
+ \x03\x1d\x07%\n\n\n\x03\x07\x08\x04\x12\x03\x1f\x04\x0c\n\n\n\x03\x07\
+ \x08\x05\x12\x03\x1f\r\x11\n\n\n\x03\x07\x08\x01\x12\x03\x1f\x12\x1e\n\n\
+ \n\x03\x07\x08\x03\x12\x03\x1f!&\nI\n\x02\x07\t\x12\x03!\x04(\x1a>\x20Wh\
+ en\x20true\x20all\x20fields\x20are\x20public,\x20and\x20not\x20accessors\
+ \x20generated\n\n\n\n\x03\x07\t\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\t\x04\
+ \x12\x03!\x04\x0c\n\n\n\x03\x07\t\x05\x12\x03!\r\x11\n\n\n\x03\x07\t\x01\
+ \x12\x03!\x12\x1f\n\n\n\x03\x07\t\x03\x12\x03!\"'\nP\n\x02\x07\n\x12\x03\
+ #\x04-\x1aE\x20When\x20false,\x20`get_`,\x20`set_`,\x20`mut_`\x20etc.\
+ \x20accessors\x20are\x20not\x20generated\n\n\n\n\x03\x07\n\x02\x12\x03\
+ \x1d\x07%\n\n\n\x03\x07\n\x04\x12\x03#\x04\x0c\n\n\n\x03\x07\n\x05\x12\
+ \x03#\r\x11\n\n\n\x03\x07\n\x01\x12\x03#\x12$\n\n\n\x03\x07\n\x03\x12\
+ \x03#',\n2\n\x02\x07\x0b\x12\x03%\x045\x1a'\x20Use\x20`bytes::Bytes`\x20\
+ for\x20`bytes`\x20fields\n\n\n\n\x03\x07\x0b\x02\x12\x03\x1d\x07%\n\n\n\
+ \x03\x07\x0b\x04\x12\x03%\x04\x0c\n\n\n\x03\x07\x0b\x05\x12\x03%\r\x11\n\
+ \n\n\x03\x07\x0b\x01\x12\x03%\x12,\n\n\n\x03\x07\x0b\x03\x12\x03%/4\n3\n\
+ \x02\x07\x0c\x12\x03'\x046\x1a(\x20Use\x20`bytes::Bytes`\x20for\x20`stri\
+ ng`\x20fields\n\n\n\n\x03\x07\x0c\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\x0c\
+ \x04\x12\x03'\x04\x0c\n\n\n\x03\x07\x0c\x05\x12\x03'\r\x11\n\n\n\x03\x07\
+ \x0c\x01\x12\x03'\x12-\n\n\n\x03\x07\x0c\x03\x12\x03'05\nJ\n\x02\x07\r\
+ \x12\x03)\x04'\x1a?\x20Use\x20`serde_derive`\x20to\x20implement\x20`Seri\
+ alize`\x20and\x20`Deserialize`\n\n\n\n\x03\x07\r\x02\x12\x03\x1d\x07%\n\
+ \n\n\x03\x07\r\x04\x12\x03)\x04\x0c\n\n\n\x03\x07\r\x05\x12\x03)\r\x11\n\
+ \n\n\x03\x07\r\x01\x12\x03)\x12\x1e\n\n\n\x03\x07\r\x03\x12\x03)!&\n3\n\
+ \x02\x07\x0e\x12\x03+\x04-\x1a(\x20Guard\x20serde\x20annotations\x20with\
+ \x20cfg\x20attr.\n\n\n\n\x03\x07\x0e\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\
+ \x0e\x04\x12\x03+\x04\x0c\n\n\n\x03\x07\x0e\x05\x12\x03+\r\x13\n\n\n\x03\
+ \x07\x0e\x01\x12\x03+\x14$\n\n\n\x03\x07\x0e\x03\x12\x03+',\n\t\n\x01\
+ \x07\x12\x04.\07\x01\nI\n\x02\x07\x0f\x12\x030\x04.\x1a>\x20When\x20true\
+ \x20all\x20fields\x20are\x20public,\x20and\x20not\x20accessors\x20genera\
+ ted\n\n\n\n\x03\x07\x0f\x02\x12\x03.\x07#\n\n\n\x03\x07\x0f\x04\x12\x030\
+ \x04\x0c\n\n\n\x03\x07\x0f\x05\x12\x030\r\x11\n\n\n\x03\x07\x0f\x01\x12\
+ \x030\x12%\n\n\n\x03\x07\x0f\x03\x12\x030(-\nP\n\x02\x07\x10\x12\x032\
+ \x043\x1aE\x20When\x20false,\x20`get_`,\x20`set_`,\x20`mut_`\x20etc.\x20\
+ accessors\x20are\x20not\x20generated\n\n\n\n\x03\x07\x10\x02\x12\x03.\
+ \x07#\n\n\n\x03\x07\x10\x04\x12\x032\x04\x0c\n\n\n\x03\x07\x10\x05\x12\
+ \x032\r\x11\n\n\n\x03\x07\x10\x01\x12\x032\x12*\n\n\n\x03\x07\x10\x03\
+ \x12\x032-2\n2\n\x02\x07\x11\x12\x034\x04;\x1a'\x20Use\x20`bytes::Bytes`\
+ \x20for\x20`bytes`\x20fields\n\n\n\n\x03\x07\x11\x02\x12\x03.\x07#\n\n\n\
+ \x03\x07\x11\x04\x12\x034\x04\x0c\n\n\n\x03\x07\x11\x05\x12\x034\r\x11\n\
+ \n\n\x03\x07\x11\x01\x12\x034\x122\n\n\n\x03\x07\x11\x03\x12\x0345:\n3\n\
+ \x02\x07\x12\x12\x036\x04<\x1a(\x20Use\x20`bytes::Bytes`\x20for\x20`stri\
+ ng`\x20fields\n\n\n\n\x03\x07\x12\x02\x12\x03.\x07#\n\n\n\x03\x07\x12\
+ \x04\x12\x036\x04\x0c\n\n\n\x03\x07\x12\x05\x12\x036\r\x11\n\n\n\x03\x07\
+ \x12\x01\x12\x036\x123\n\n\n\x03\x07\x12\x03\x12\x0366;\n\t\n\x01\x07\
+ \x12\x049\0<\x01\n/\n\x02\x07\x13\x12\x03;\x04-\x1a$\x20use\x20rename_al\
+ l\x20attribute\x20for\x20serde\n\n\n\n\x03\x07\x13\x02\x12\x039\x07\"\n\
+ \n\n\x03\x07\x13\x04\x12\x03;\x04\x0c\n\n\n\x03\x07\x13\x05\x12\x03;\r\
+ \x13\n\n\n\x03\x07\x13\x01\x12\x03;\x14$\n\n\n\x03\x07\x13\x03\x12\x03;'\
+ ,\
";
static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
diff --git a/src/singular.rs b/src/singular.rs
index ef04d2f..1b7e28d 100644
--- a/src/singular.rs
+++ b/src/singular.rs
@@ -1,6 +1,3 @@
-#[cfg(feature = "with-serde")]
-use serde;
-
use std::default::Default;
use std::fmt;
use std::hash::Hash;
@@ -8,6 +5,9 @@
use std::mem;
use std::option;
+#[cfg(feature = "with-serde")]
+use serde;
+
use crate::clear::Clear;
/// Like `Option<T>`, but keeps the actual element on `clear`.
@@ -341,7 +341,9 @@
/// Get contained data, consume self. Return default value for type if this is empty.
#[inline]
pub fn unwrap_or_default(mut self) -> T {
- self.value.clear();
+ if !self.set {
+ self.value.clear();
+ }
self.value
}
@@ -577,4 +579,16 @@
x.set_default();
assert_eq!(0, x.as_ref().unwrap().b);
}
+
+ #[test]
+ fn unwrap_or_default() {
+ assert_eq!(
+ "abc",
+ SingularField::some("abc".to_owned()).unwrap_or_default()
+ );
+ assert_eq!("", SingularField::<String>::none().unwrap_or_default());
+ let mut some = SingularField::some("abc".to_owned());
+ some.clear();
+ assert_eq!("", some.unwrap_or_default());
+ }
}
diff --git a/src/text_format/lexer/str_lit.rs b/src/text_format/lexer/str_lit.rs
index caa98f1..15ffa5b 100644
--- a/src/text_format/lexer/str_lit.rs
+++ b/src/text_format/lexer/str_lit.rs
@@ -1,8 +1,9 @@
+use std::fmt;
+use std::string::FromUtf8Error;
+
use super::lexer_impl::Lexer;
use super::lexer_impl::LexerError;
use crate::text_format::lexer::ParserLanguage;
-use std::fmt;
-use std::string::FromUtf8Error;
#[derive(Debug)]
pub enum StrLitDecodeError {
diff --git a/src/text_format/mod.rs b/src/text_format/mod.rs
index 7af03e4..2fa9a16 100644
--- a/src/text_format/mod.rs
+++ b/src/text_format/mod.rs
@@ -19,13 +19,14 @@
//! protobuf implementations, including `protoc` command which can decode
//! and encode messages using text format.
-use crate::message::Message;
-use crate::reflect::ReflectFieldRef;
-use crate::reflect::ReflectValueRef;
use std;
use std::fmt;
use std::fmt::Write;
+use crate::message::Message;
+use crate::reflect::ReflectFieldRef;
+use crate::reflect::ReflectValueRef;
+
mod print;
// Used by text format parser and by pure-rust codegen parsed
diff --git a/src/types.rs b/src/types.rs
index d9bbb10..20244a1 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -4,10 +4,10 @@
use std::mem;
#[cfg(feature = "bytes")]
-use crate::chars::Chars;
-#[cfg(feature = "bytes")]
use bytes::Bytes;
+#[cfg(feature = "bytes")]
+use crate::chars::Chars;
use crate::coded_input_stream::CodedInputStream;
use crate::coded_output_stream::CodedOutputStream;
use crate::enums::ProtobufEnum;
diff --git a/src/unknown.rs b/src/unknown.rs
index 8e9da12..dd67033 100644
--- a/src/unknown.rs
+++ b/src/unknown.rs
@@ -1,7 +1,3 @@
-use crate::clear::Clear;
-use crate::wire_format;
-use crate::zigzag::encode_zig_zag_32;
-use crate::zigzag::encode_zig_zag_64;
use std::collections::hash_map;
use std::collections::hash_map::DefaultHasher;
use std::collections::HashMap;
@@ -11,6 +7,11 @@
use std::hash::Hasher;
use std::slice;
+use crate::clear::Clear;
+use crate::wire_format;
+use crate::zigzag::encode_zig_zag_32;
+use crate::zigzag::encode_zig_zag_64;
+
/// Unknown value.
///
/// See [`UnknownFields`](crate::UnknownFields) for the explanations.
@@ -311,11 +312,12 @@
#[cfg(test)]
mod test {
- use super::UnknownFields;
use std::collections::hash_map::DefaultHasher;
use std::hash::Hash;
use std::hash::Hasher;
+ use super::UnknownFields;
+
#[test]
fn unknown_fields_hash() {
let mut unknown_fields_1 = UnknownFields::new();
diff --git a/src/varint.rs b/src/varint.rs
index 1f1cb1c..8e542bc 100644
--- a/src/varint.rs
+++ b/src/varint.rs
@@ -1,17 +1,21 @@
+use std::mem::MaybeUninit;
+
+use crate::misc::maybe_uninit_write;
+
/// Encode u64 as varint.
/// Panics if buffer length is less than 10.
#[inline]
-pub fn encode_varint64(mut value: u64, buf: &mut [u8]) -> usize {
+pub fn encode_varint64(mut value: u64, buf: &mut [MaybeUninit<u8>]) -> usize {
assert!(buf.len() >= 10);
unsafe {
let mut i = 0;
while (value & !0x7F) > 0 {
- *buf.get_unchecked_mut(i) = ((value & 0x7F) | 0x80) as u8;
+ maybe_uninit_write(buf.get_unchecked_mut(i), ((value & 0x7F) | 0x80) as u8);
value >>= 7;
i += 1;
}
- *buf.get_unchecked_mut(i) = value as u8;
+ maybe_uninit_write(buf.get_unchecked_mut(i), value as u8);
i + 1
}
}
@@ -19,17 +23,17 @@
/// Encode u32 value as varint.
/// Panics if buffer length is less than 5.
#[inline]
-pub fn encode_varint32(mut value: u32, buf: &mut [u8]) -> usize {
+pub fn encode_varint32(mut value: u32, buf: &mut [MaybeUninit<u8>]) -> usize {
assert!(buf.len() >= 5);
unsafe {
let mut i = 0;
while (value & !0x7F) > 0 {
- *buf.get_unchecked_mut(i) = ((value & 0x7F) | 0x80) as u8;
+ maybe_uninit_write(buf.get_unchecked_mut(i), ((value & 0x7F) | 0x80) as u8);
value >>= 7;
i += 1;
}
- *buf.get_unchecked_mut(i) = value as u8;
+ maybe_uninit_write(buf.get_unchecked_mut(i), value as u8);
i + 1
}
}
diff --git a/src/well_known_types/any.rs b/src/well_known_types/any.rs
index f306202..e46065f 100644
--- a/src/well_known_types/any.rs
+++ b/src/well_known_types/any.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.22.0. Do not edit
+// This file is generated by rust-protobuf 2.26.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
diff --git a/src/well_known_types/api.rs b/src/well_known_types/api.rs
index 34798b4..ef97015 100644
--- a/src/well_known_types/api.rs
+++ b/src/well_known_types/api.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.22.0. Do not edit
+// This file is generated by rust-protobuf 2.26.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
diff --git a/src/well_known_types/duration.rs b/src/well_known_types/duration.rs
index ec82f78..822061a 100644
--- a/src/well_known_types/duration.rs
+++ b/src/well_known_types/duration.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.22.0. Do not edit
+// This file is generated by rust-protobuf 2.26.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
diff --git a/src/well_known_types/empty.rs b/src/well_known_types/empty.rs
index 5c69487..d55e517 100644
--- a/src/well_known_types/empty.rs
+++ b/src/well_known_types/empty.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.22.0. Do not edit
+// This file is generated by rust-protobuf 2.26.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
diff --git a/src/well_known_types/field_mask.rs b/src/well_known_types/field_mask.rs
index 9d1f8f6..e98eb53 100644
--- a/src/well_known_types/field_mask.rs
+++ b/src/well_known_types/field_mask.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.22.0. Do not edit
+// This file is generated by rust-protobuf 2.26.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
diff --git a/src/well_known_types/source_context.rs b/src/well_known_types/source_context.rs
index 55c1ab4..646e87d 100644
--- a/src/well_known_types/source_context.rs
+++ b/src/well_known_types/source_context.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.22.0. Do not edit
+// This file is generated by rust-protobuf 2.26.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
diff --git a/src/well_known_types/struct_pb.rs b/src/well_known_types/struct_pb.rs
index 222d712..5f18a42 100644
--- a/src/well_known_types/struct_pb.rs
+++ b/src/well_known_types/struct_pb.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.22.0. Do not edit
+// This file is generated by rust-protobuf 2.26.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
diff --git a/src/well_known_types/timestamp.rs b/src/well_known_types/timestamp.rs
index d0f7903..25e7acf 100644
--- a/src/well_known_types/timestamp.rs
+++ b/src/well_known_types/timestamp.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.22.0. Do not edit
+// This file is generated by rust-protobuf 2.26.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
diff --git a/src/well_known_types/type_pb.rs b/src/well_known_types/type_pb.rs
index d6c06cc..14bfdb2 100644
--- a/src/well_known_types/type_pb.rs
+++ b/src/well_known_types/type_pb.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.22.0. Do not edit
+// This file is generated by rust-protobuf 2.26.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
diff --git a/src/well_known_types/wrappers.rs b/src/well_known_types/wrappers.rs
index 11edf4c..4e056c7 100644
--- a/src/well_known_types/wrappers.rs
+++ b/src/well_known_types/wrappers.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.22.0. Do not edit
+// This file is generated by rust-protobuf 2.26.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702