protobuf-3.7.2/.cargo_vcs_info.json0000644000000001460000000000100127060ustar { "git": { "sha1": "4cb84f305c05f0376ff51b555a2740c5251c1280" }, "path_in_vcs": "protobuf" }protobuf-3.7.2/Cargo.toml0000644000000023600000000000100107040ustar # THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies. # # If you are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2021" name = "protobuf" version = "3.7.2" authors = ["Stepan Koltsov "] 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" readme = "README.md" license = "MIT" repository = "https://github.com/stepancheg/rust-protobuf/" [package.metadata.docs.rs] all-features = true [lib] bench = false [dependencies.bytes] version = "1.1" optional = true [dependencies.once_cell] version = "1.9.0" [dependencies.protobuf-support] version = "=3.7.2" [dependencies.thiserror] version = "1.0.30" [features] default = [] with-bytes = ["bytes"] [lints.rust.unexpected_cfgs] level = "warn" priority = 0 protobuf-3.7.2/Cargo.toml.orig000064400000000000000000000014121046102023000143620ustar 00000000000000[package] name = "protobuf" version = "3.7.2" authors = ["Stepan Koltsov "] edition = "2021" license = "MIT" homepage = "https://github.com/stepancheg/rust-protobuf/" repository = "https://github.com/stepancheg/rust-protobuf/" documentation = "https://github.com/stepancheg/rust-protobuf/blob/master/README.md" description = """ Rust implementation of Google protocol buffers """ [lib] bench = false [features] with-bytes = ["bytes"] default = [] [dependencies] bytes = { version = "1.1", optional = true } thiserror = "1.0.30" once_cell = "1.9.0" protobuf-support = { path = "../protobuf-support", version = "=3.7.2" } [package.metadata.docs.rs] all-features = true [lints.rust] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(never)'] } protobuf-3.7.2/LICENSE.txt000064400000000000000000000020421046102023000133160ustar 00000000000000Copyright (c) 2019 Stepan Koltsov Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. protobuf-3.7.2/README.md000064400000000000000000000023761046102023000127640ustar 00000000000000 # Library to read and write protocol buffers data ## Features This crate has one feature, which is `with-bytes`. `with-bytes` enables `protobuf` crate support for [`bytes` crate](https://github.com/tokio-rs/bytes): when parsing bytes or strings from `bytes::Bytes`, `protobuf` will be able to reference the input instead of allocating subarrays. Note, codegen also need to be instructed to generate `Bytes` or `Chars` for `bytes` or `string` protobuf types instead of default `Vec` or `String`, just enabling option on this crate is not enough. See `Customize` struct in [`protobuf-codegen` crate](https://docs.rs/protobuf-codegen). ## Accompanying crates * [`protobuf-json-mapping`](https://docs.rs/protobuf-json-mapping) implements JSON parsing and serialization for protobuf messages. * [`protobuf-codegen`](https://docs.rs/protobuf-codegen) can be used to generate rust code from `.proto` crates. * [`protoc-bin-vendored`](https://docs.rs/protoc-bin-vendored) contains `protoc` command packed into the crate. * [`protobuf-parse`](https://docs.rs/protobuf-parse) contains `.proto` file parser. Rarely need to be used directly, but can be used for mechanical processing of `.proto` files. protobuf-3.7.2/build.rs000064400000000000000000000027141046102023000131460ustar 00000000000000use std::env; use std::env::VarError; use std::fs::File; use std::io::Write; use std::path::Path; use std::path::PathBuf; fn cfg_serde() { match env::var("CARGO_FEATURE_WITH_SERDE") { Ok(_) => { println!("cargo:rustc-cfg=serde"); } Err(VarError::NotUnicode(..)) => panic!(), Err(VarError::NotPresent) => {} } } fn out_dir() -> PathBuf { PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR")) } fn version() -> String { env::var("CARGO_PKG_VERSION").expect("CARGO_PKG_VERSION") } fn write_version() { let version = version(); let version_ident = format!( "VERSION_{}", version.replace(".", "_").replace("-", "_").to_uppercase() ); let mut file = File::create(Path::join(&out_dir(), "version.rs")).expect("open"); writeln!(file, "/// protobuf crate version").unwrap(); writeln!(file, "pub const VERSION: &'static str = \"{}\";", version).unwrap(); writeln!(file, "/// This symbol is used by codegen").unwrap(); writeln!(file, "#[doc(hidden)]").unwrap(); writeln!( file, "pub const VERSION_IDENT: &'static str = \"{}\";", version_ident ) .unwrap(); writeln!( file, "/// This symbol can be referenced to assert that proper version of crate is used" ) .unwrap(); writeln!(file, "pub const {}: () = ();", version_ident).unwrap(); file.flush().unwrap(); } fn main() { cfg_serde(); write_version(); } protobuf-3.7.2/regenerate.sh000075500000000000000000000021471046102023000141610ustar 00000000000000#!/bin/sh -ex cd "$(dirname "$0")" die() { echo "$@" >&2 exit 1 } cargo build --manifest-path=../protobuf-codegen/Cargo.toml cargo build --manifest-path=../protoc-bin/Cargo.toml --bin protoc-bin-print-paths eval "$(cargo run --manifest-path=../protoc-bin/Cargo.toml --bin protoc-bin-print-paths)" test -n "$PROTOC" where_am_i=$( cd .. pwd ) rm -rf tmp-generated mkdir tmp-generated case $(uname) in Linux) exe_suffix="" ;; MSYS_NT*) exe_suffix=".exe" ;; esac "$PROTOC" \ --plugin=protoc-gen-rs="$where_am_i/target/debug/protoc-gen-rs$exe_suffix" \ --rs_out tmp-generated \ --rs_opt 'inside_protobuf=true gen_mod_rs=false' \ -I../proto \ ../proto/google/protobuf/*.proto \ ../proto/google/protobuf/compiler/*.proto \ ../proto/rustproto.proto \ ../proto/doctest_pb.proto mv \ tmp-generated/descriptor.rs \ tmp-generated/plugin.rs \ tmp-generated/rustproto.rs \ tmp-generated/doctest_pb.rs \ src/ mv tmp-generated/well_known_types_mod.rs src/well_known_types/mod.rs mv tmp-generated/*.rs src/well_known_types/ # vim: set ts=4 sw=4 et: protobuf-3.7.2/src/byteorder.rs000064400000000000000000000002111046102023000146230ustar 00000000000000/// Expose cfg as constant to be able to typecheck both versions. pub(crate) const LITTLE_ENDIAN: bool = cfg!(target_endian = "little"); protobuf-3.7.2/src/cached_size.rs000064400000000000000000000023541046102023000150770ustar 00000000000000use std::hash::Hash; use std::hash::Hasher; use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; /// Cached size field used in generated code. /// /// It is always equal to itself to simplify generated code. /// (Generated code can use `#[derive(Eq)]`). /// /// This type should rarely be used directly. #[derive(Debug, Default)] pub struct CachedSize { size: AtomicUsize, } impl CachedSize { /// Create a new `CachedSize` object. pub const fn new() -> CachedSize { CachedSize { size: AtomicUsize::new(0), } } /// Get cached size pub fn get(&self) -> u32 { self.size.load(Ordering::Relaxed) as u32 } /// Set cached size pub fn set(&self, size: u32) { self.size.store(size as usize, Ordering::Relaxed) } } impl Clone for CachedSize { fn clone(&self) -> CachedSize { CachedSize { size: AtomicUsize::new(self.size.load(Ordering::Relaxed)), } } } impl PartialEq for CachedSize { fn eq(&self, _other: &CachedSize) -> bool { true } } impl Eq for CachedSize {} impl Hash for CachedSize { fn hash(&self, _state: &mut H) { // ignore cached size in cache computation } } protobuf-3.7.2/src/chars.rs000064400000000000000000000046421046102023000137400ustar 00000000000000#![cfg(feature = "bytes")] use std::borrow::Borrow; use std::fmt; use std::ops::Deref; use std::str; use bytes::Bytes; /// Thin wrapper around `Bytes` which guarantees that bytes are valid UTF-8 string. /// Should be API-compatible to `String`. #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] pub struct Chars(Bytes); impl Chars { /// New empty object. pub const fn new() -> Chars { Chars(Bytes::new()) } /// Clear the buffer. pub fn clear(&mut self) { self.0.clear(); } /// Try convert from `Bytes` pub fn from_bytes(bytes: Bytes) -> Result { str::from_utf8(&bytes)?; Ok(Chars(bytes)) } /// Len in bytes. pub fn len(&self) -> usize { self.0.len() } /// Self-explanatory pub fn is_empty(&self) -> bool { self.0.is_empty() } } impl<'a> From<&'a str> for Chars { fn from(src: &'a str) -> Chars { Chars(Bytes::copy_from_slice(src.as_bytes())) } } impl From for Chars { fn from(src: String) -> Chars { Chars(Bytes::from(src)) } } impl Into for Chars { fn into(self) -> String { // This is safe because `Chars` is guaranteed to store a valid UTF-8 string unsafe { String::from_utf8_unchecked(self.0.as_ref().to_owned()) } } } impl Default for Chars { fn default() -> Self { Chars::new() } } impl Deref for Chars { type Target = str; fn deref(&self) -> &str { // This is safe because `Chars` is guaranteed to store a valid UTF-8 string unsafe { str::from_utf8_unchecked(&self.0) } } } impl Borrow for Chars { fn borrow(&self) -> &str { &*self } } impl fmt::Display for Chars { #[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&**self, f) } } impl fmt::Debug for Chars { #[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Debug::fmt(&**self, f) } } #[cfg(test)] mod test { use super::Chars; #[test] #[cfg_attr(miri, ignore)] // bytes violates SB, see https://github.com/tokio-rs/bytes/issues/522 fn test_display_and_debug() { let s = "test"; let string: String = s.into(); let chars: Chars = s.into(); assert_eq!(format!("{}", string), format!("{}", chars)); assert_eq!(format!("{:?}", string), format!("{:?}", chars)); } } protobuf-3.7.2/src/coded_input_stream/buf_read_iter.rs000064400000000000000000000353341046102023000213040ustar 00000000000000use std::cmp; use std::io::BufRead; use std::io::BufReader; use std::io::Read; use std::mem; use std::mem::MaybeUninit; #[cfg(feature = "bytes")] use bytes::buf::UninitSlice; #[cfg(feature = "bytes")] use bytes::BufMut; #[cfg(feature = "bytes")] use bytes::Bytes; #[cfg(feature = "bytes")] use bytes::BytesMut; use crate::coded_input_stream::buf_read_or_reader::BufReadOrReader; use crate::coded_input_stream::input_buf::InputBuf; use crate::coded_input_stream::input_source::InputSource; use crate::coded_input_stream::READ_RAW_BYTES_MAX_ALLOC; use crate::error::ProtobufError; use crate::error::WireError; // If an input stream is constructed with a `Read`, we create a // `BufReader` with an internal buffer of this size. const INPUT_STREAM_BUFFER_SIZE: usize = 4096; const NO_LIMIT: u64 = u64::MAX; /// Dangerous implementation of `BufRead`. /// /// Unsafe wrapper around BufRead which assumes that `BufRead` buf is /// not moved when `BufRead` is moved. /// /// This assumption is generally incorrect, however, in practice /// `BufReadIter` is created either from `BufRead` reference (which /// cannot be moved, because it is locked by `CodedInputStream`) or from /// `BufReader` which does not move its buffer (we know that from /// inspecting rust standard library). /// /// 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`. #[derive(Debug)] pub(crate) struct BufReadIter<'a> { input_source: InputSource<'a>, buf: InputBuf<'a>, pos_of_buf_start: u64, limit: u64, } impl<'a> Drop for BufReadIter<'a> { fn drop(&mut self) { match self.input_source { InputSource::Read(ref mut buf_read) => buf_read.consume(self.buf.pos_within_buf()), _ => {} } } } impl<'a> BufReadIter<'a> { pub(crate) fn from_read(read: &'a mut dyn Read) -> BufReadIter<'a> { BufReadIter { input_source: InputSource::Read(BufReadOrReader::BufReader(BufReader::with_capacity( INPUT_STREAM_BUFFER_SIZE, read, ))), buf: InputBuf::empty(), pos_of_buf_start: 0, limit: NO_LIMIT, } } pub(crate) fn from_buf_read(buf_read: &'a mut dyn BufRead) -> BufReadIter<'a> { BufReadIter { input_source: InputSource::Read(BufReadOrReader::BufRead(buf_read)), buf: InputBuf::empty(), pos_of_buf_start: 0, limit: NO_LIMIT, } } pub(crate) fn from_byte_slice(bytes: &'a [u8]) -> BufReadIter<'a> { BufReadIter { input_source: InputSource::Slice(bytes), buf: InputBuf::from_bytes(bytes), pos_of_buf_start: 0, limit: NO_LIMIT, } } #[cfg(feature = "bytes")] pub(crate) fn from_bytes(bytes: &'a Bytes) -> BufReadIter<'a> { BufReadIter { input_source: InputSource::Bytes(bytes), buf: InputBuf::from_bytes(&bytes), pos_of_buf_start: 0, limit: NO_LIMIT, } } #[inline] fn assertions(&self) { debug_assert!(self.pos() <= self.limit); self.buf.assertions(); } #[inline(always)] pub(crate) fn pos(&self) -> u64 { self.pos_of_buf_start + self.buf.pos_within_buf() as u64 } /// Recompute `limit_within_buf` after update of `limit` #[inline] fn update_limit_within_buf(&mut self) { assert!(self.limit >= self.pos_of_buf_start); self.buf.update_limit(self.limit - self.pos_of_buf_start); self.assertions(); } pub(crate) fn push_limit(&mut self, limit: u64) -> crate::Result { let new_limit = match self.pos().checked_add(limit) { Some(new_limit) => new_limit, None => return Err(ProtobufError::WireError(WireError::LimitOverflow).into()), }; if new_limit > self.limit { return Err(ProtobufError::WireError(WireError::LimitIncrease).into()); } let prev_limit = mem::replace(&mut self.limit, new_limit); self.update_limit_within_buf(); Ok(prev_limit) } #[inline] pub(crate) fn pop_limit(&mut self, limit: u64) { assert!(limit >= self.limit); self.limit = limit; self.update_limit_within_buf(); } #[inline(always)] pub(crate) fn remaining_in_buf(&self) -> &[u8] { self.buf.remaining_in_buf() } #[inline] pub(crate) fn consume(&mut self, amt: usize) { self.buf.consume(amt); } #[inline(always)] pub(crate) fn remaining_in_buf_len(&self) -> usize { self.remaining_in_buf().len() } #[inline(always)] pub(crate) fn bytes_until_limit(&self) -> u64 { if self.limit == NO_LIMIT { NO_LIMIT } else { self.limit - self.pos() } } #[inline(always)] pub(crate) fn eof(&mut self) -> crate::Result { if self.remaining_in_buf_len() != 0 { Ok(false) } else { Ok(self.fill_buf()?.is_empty()) } } fn read_byte_slow(&mut self) -> crate::Result { self.fill_buf_slow()?; if let Some(b) = self.buf.read_byte() { return Ok(b); } Err(WireError::UnexpectedEof.into()) } #[inline(always)] pub(crate) fn read_byte(&mut self) -> crate::Result { if let Some(b) = self.buf.read_byte() { return Ok(b); } self.read_byte_slow() } #[cfg(feature = "bytes")] pub(crate) fn read_exact_bytes(&mut self, len: usize) -> crate::Result { if let InputSource::Bytes(bytes) = self.input_source { if len > self.remaining_in_buf_len() { return Err(ProtobufError::WireError(WireError::UnexpectedEof).into()); } let end = self.buf.pos_within_buf() + len; let r = bytes.slice(self.buf.pos_within_buf()..end); self.buf.consume(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] { use std::slice; slice::from_raw_parts_mut(slice.as_mut_ptr() as *mut MaybeUninit, slice.len()) } /// Returns 0 when EOF or limit reached. pub(crate) fn read(&mut self, buf: &mut [u8]) -> crate::Result { let rem = self.fill_buf()?; let len = cmp::min(rem.len(), buf.len()); buf[..len].copy_from_slice(&rem[..len]); self.buf.consume(len); Ok(len) } fn consume_buf(&mut self) -> crate::Result<()> { match &mut self.input_source { InputSource::Read(read) => { read.consume(self.buf.pos_within_buf()); self.pos_of_buf_start += self.buf.pos_within_buf() as u64; self.buf = InputBuf::empty(); self.assertions(); Ok(()) } _ => Err(WireError::UnexpectedEof.into()), } } /// Read at most `max` bytes. /// /// Returns 0 when EOF or limit reached. fn read_to_vec(&mut self, vec: &mut Vec, max: usize) -> crate::Result { let rem = self.fill_buf()?; let len = cmp::min(rem.len(), max); vec.extend_from_slice(&rem[..len]); self.buf.consume(len); Ok(len) } fn read_exact_slow(&mut self, buf: &mut [MaybeUninit]) -> crate::Result<()> { if self.bytes_until_limit() < buf.len() as u64 { return Err(ProtobufError::WireError(WireError::UnexpectedEof).into()); } self.consume_buf()?; match &mut self.input_source { InputSource::Read(buf_read) => { buf_read.read_exact_uninit(buf)?; self.pos_of_buf_start += buf.len() as u64; self.assertions(); Ok(()) } _ => unreachable!(), } } #[inline] pub(crate) fn read_exact(&mut self, buf: &mut [MaybeUninit]) -> crate::Result<()> { if self.remaining_in_buf_len() >= buf.len() { self.buf.read_bytes(buf); return Ok(()); } self.read_exact_slow(buf) } /// Read raw bytes into the supplied vector. The vector will be resized as needed and /// overwritten. pub(crate) fn read_exact_to_vec( &mut self, count: usize, target: &mut Vec, ) -> crate::Result<()> { // TODO: also do some limits when reading from unlimited source if count as u64 > self.bytes_until_limit() { return Err(ProtobufError::WireError(WireError::TruncatedMessage).into()); } target.clear(); if count >= READ_RAW_BYTES_MAX_ALLOC && count > target.capacity() { // avoid calling `reserve` on buf with very large buffer: could be a malformed message target.reserve(READ_RAW_BYTES_MAX_ALLOC); while target.len() < count { if count - target.len() <= target.len() { target.reserve_exact(count - target.len()); } else { target.reserve(1); } let max = cmp::min(target.capacity() - target.len(), count - target.len()); let read = self.read_to_vec(target, max)?; if read == 0 { return Err(ProtobufError::WireError(WireError::TruncatedMessage).into()); } } } else { target.reserve_exact(count); unsafe { self.read_exact(&mut target.spare_capacity_mut()[..count])?; target.set_len(count); } } debug_assert_eq!(count, target.len()); Ok(()) } pub(crate) fn skip_bytes(&mut self, count: u32) -> crate::Result<()> { if count as usize <= self.remaining_in_buf_len() { self.buf.consume(count as usize); return Ok(()); } if count as u64 > self.bytes_until_limit() { return Err(WireError::TruncatedMessage.into()); } self.consume_buf()?; match &mut self.input_source { InputSource::Read(read) => { read.skip_bytes(count as usize)?; self.pos_of_buf_start += count as u64; self.assertions(); Ok(()) } _ => unreachable!(), } } fn fill_buf_slow(&mut self) -> crate::Result<()> { self.assertions(); if self.limit == self.pos() { return Ok(()); } match self.input_source { InputSource::Read(..) => {} _ => return Ok(()), } self.consume_buf()?; match self.input_source { InputSource::Read(ref mut buf_read) => { self.buf = unsafe { InputBuf::from_bytes_ignore_lifetime(buf_read.fill_buf()?) }; self.update_limit_within_buf(); Ok(()) } _ => { unreachable!(); } } } #[inline(always)] pub(crate) fn fill_buf(&mut self) -> crate::Result<&[u8]> { let rem = self.buf.remaining_in_buf(); if !rem.is_empty() { return Ok(rem); } if self.limit == self.pos() { return Ok(&[]); } self.fill_buf_slow()?; Ok(self.buf.remaining_in_buf()) } } #[cfg(all(test, feature = "bytes"))] mod test_bytes { use std::io::Write; use super::*; fn make_long_string(len: usize) -> Vec { let mut s = Vec::new(); while s.len() < len { let len = s.len(); write!(&mut s, "{}", len).expect("unexpected"); } s.truncate(len); s } #[test] #[cfg_attr(miri, ignore)] // bytes violates SB, see https://github.com/tokio-rs/bytes/issues/522 fn read_exact_bytes_from_slice() { let bytes = make_long_string(100); let mut bri = BufReadIter::from_byte_slice(&bytes[..]); assert_eq!(&bytes[..90], &bri.read_exact_bytes(90).unwrap()[..]); assert_eq!(bytes[90], bri.read_byte().expect("read_byte")); } #[test] #[cfg_attr(miri, ignore)] // bytes violates SB, see https://github.com/tokio-rs/bytes/issues/522 fn read_exact_bytes_from_bytes() { let bytes = Bytes::from(make_long_string(100)); let mut bri = BufReadIter::from_bytes(&bytes); let read = bri.read_exact_bytes(90).unwrap(); assert_eq!(&bytes[..90], &read[..]); assert_eq!(&bytes[..90].as_ptr(), &read.as_ptr()); assert_eq!(bytes[90], bri.read_byte().expect("read_byte")); } } #[cfg(test)] mod test { use std::io; use super::*; #[test] fn eof_at_limit() { struct Read5ThenPanic { pos: usize, } impl Read for Read5ThenPanic { fn read(&mut self, _buf: &mut [u8]) -> io::Result { unreachable!(); } } impl BufRead for Read5ThenPanic { fn fill_buf(&mut self) -> io::Result<&[u8]> { assert_eq!(0, self.pos); static ZERO_TO_FIVE: &'static [u8] = &[0, 1, 2, 3, 4]; Ok(ZERO_TO_FIVE) } fn consume(&mut self, amt: usize) { if amt == 0 { // drop of BufReadIter return; } assert_eq!(0, self.pos); assert_eq!(5, amt); self.pos += amt; } } let mut read = Read5ThenPanic { pos: 0 }; let mut buf_read_iter = BufReadIter::from_buf_read(&mut read); assert_eq!(0, buf_read_iter.pos()); let _prev_limit = buf_read_iter.push_limit(5); buf_read_iter.read_byte().expect("read_byte"); buf_read_iter .read_exact(&mut [ MaybeUninit::uninit(), MaybeUninit::uninit(), MaybeUninit::uninit(), MaybeUninit::uninit(), ]) .expect("read_exact"); assert!(buf_read_iter.eof().expect("eof")); } } protobuf-3.7.2/src/coded_input_stream/buf_read_or_reader.rs000064400000000000000000000066331046102023000223030ustar 00000000000000//! `BufRead` pointer or `BufReader` owned. use std::cmp; use std::fmt; 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> fmt::Debug for BufReadOrReader<'a> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { BufReadOrReader::BufReader(..) => write!(f, "BufReader(...)"), BufReadOrReader::BufRead(..) => write!(f, "BufRead(...)"), } } } impl<'a> Read for BufReadOrReader<'a> { fn read(&mut self, buf: &mut [u8]) -> Result { match self { BufReadOrReader::BufReader(r) => r.read(buf), BufReadOrReader::BufRead(r) => r.read(buf), } } fn read_to_end(&mut self, buf: &mut Vec) -> Result { 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], ) -> 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(()) } pub(crate) fn skip_bytes(&mut self, count: usize) -> Result<(), io::Error> { let mut rem = count; while rem != 0 { let buf = self.fill_buf()?; if buf.is_empty() { return Err(io::Error::new( io::ErrorKind::UnexpectedEof, "Unexpected end of file", )); } let consume = cmp::min(buf.len(), rem); self.consume(consume); rem -= 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), } } } protobuf-3.7.2/src/coded_input_stream/input_buf.rs000064400000000000000000000043701046102023000205010ustar 00000000000000use std::cmp; use std::mem::MaybeUninit; use crate::misc::maybe_uninit_write_slice; #[derive(Debug)] pub(crate) struct InputBuf<'a> { // Invariants: `0 <= pos_within_buf <= limit_within_buf <= buf.len()`. buf: &'a [u8], pos_within_buf: usize, limit_within_buf: usize, } impl<'a> InputBuf<'a> { #[inline] pub(crate) fn assertions(&self) { debug_assert!(self.pos_within_buf <= self.limit_within_buf); debug_assert!(self.limit_within_buf <= self.buf.len()); } pub(crate) fn empty() -> InputBuf<'a> { InputBuf { buf: &[], pos_within_buf: 0, limit_within_buf: 0, } } pub(crate) fn from_bytes(buf: &'a [u8]) -> InputBuf<'a> { InputBuf { buf, pos_within_buf: 0, limit_within_buf: buf.len(), } } pub(crate) unsafe fn from_bytes_ignore_lifetime(buf: &[u8]) -> InputBuf<'a> { let buf = &*(buf as *const [u8]); Self::from_bytes(buf) } pub(crate) fn update_limit(&mut self, limit: u64) { let limit_within_buf = cmp::min(self.buf.len() as u64, limit); assert!(limit_within_buf >= self.pos_within_buf as u64); self.limit_within_buf = limit_within_buf as usize; } pub(crate) fn pos_within_buf(&self) -> usize { self.pos_within_buf } #[inline(always)] pub(crate) fn remaining_in_buf(&self) -> &'a [u8] { // SAFETY: Invariants. unsafe { self.buf .get_unchecked(self.pos_within_buf..self.limit_within_buf) } } #[inline(always)] pub(crate) fn consume(&mut self, amt: usize) { assert!(amt <= self.remaining_in_buf().len()); self.pos_within_buf += amt; } #[inline(always)] pub(crate) fn read_byte(&mut self) -> Option { let r = self.remaining_in_buf().first().copied(); if let Some(..) = r { self.pos_within_buf += 1; } r } pub(crate) fn read_bytes<'b>(&mut self, dest: &'b mut [MaybeUninit]) -> &'b mut [u8] { // This panics if this has not enough data. let r = maybe_uninit_write_slice(dest, &self.remaining_in_buf()[..dest.len()]); self.pos_within_buf += r.len(); r } } protobuf-3.7.2/src/coded_input_stream/input_source.rs000064400000000000000000000006301046102023000212200ustar 00000000000000#[cfg(feature = "bytes")] use bytes::Bytes; use crate::coded_input_stream::buf_read_or_reader::BufReadOrReader; /// Hold all possible combinations of input source #[derive(Debug)] pub(crate) enum InputSource<'a> { Read(BufReadOrReader<'a>), #[allow(dead_code)] // Keep the field to clarify we logically hold the reference. Slice(&'a [u8]), #[cfg(feature = "bytes")] Bytes(&'a Bytes), } protobuf-3.7.2/src/coded_input_stream/mod.rs000064400000000000000000001005041046102023000172610ustar 00000000000000mod buf_read_iter; mod buf_read_or_reader; mod input_buf; mod input_source; use std::io; use std::io::BufRead; use std::io::Read; use std::mem; use std::mem::MaybeUninit; #[cfg(feature = "bytes")] use ::bytes::Bytes; #[cfg(feature = "bytes")] use crate::chars::Chars; use crate::coded_input_stream::buf_read_iter::BufReadIter; use crate::enums::Enum; use crate::error::ProtobufError; use crate::error::WireError; use crate::misc::maybe_ununit_array_assume_init; use crate::reflect::types::ProtobufTypeBool; use crate::reflect::types::ProtobufTypeDouble; use crate::reflect::types::ProtobufTypeFixed; use crate::reflect::types::ProtobufTypeFixed32; use crate::reflect::types::ProtobufTypeFixed64; use crate::reflect::types::ProtobufTypeFloat; use crate::reflect::types::ProtobufTypeInt32; use crate::reflect::types::ProtobufTypeInt64; use crate::reflect::types::ProtobufTypeSfixed32; use crate::reflect::types::ProtobufTypeSfixed64; use crate::reflect::types::ProtobufTypeSint32; use crate::reflect::types::ProtobufTypeSint64; use crate::reflect::types::ProtobufTypeTrait; use crate::reflect::types::ProtobufTypeUint32; use crate::reflect::types::ProtobufTypeUint64; use crate::reflect::MessageDescriptor; use crate::unknown::UnknownValue; use crate::varint::decode::decode_varint32; use crate::varint::decode::decode_varint64; use crate::varint::MAX_VARINT_ENCODED_LEN; use crate::wire_format; use crate::wire_format::WireType; use crate::zigzag::decode_zig_zag_32; use crate::zigzag::decode_zig_zag_64; use crate::EnumOrUnknown; use crate::Message; use crate::MessageDyn; // Default recursion level limit. 100 is the default value of C++'s implementation. const DEFAULT_RECURSION_LIMIT: u32 = 100; // Max allocated vec when reading length-delimited from unknown input stream pub(crate) const READ_RAW_BYTES_MAX_ALLOC: usize = 10_000_000; /// Buffered read with handy utilities. #[derive(Debug)] pub struct CodedInputStream<'a> { source: BufReadIter<'a>, recursion_level: u32, recursion_limit: u32, } impl<'a> CodedInputStream<'a> { /// Wrap a `Read`. /// /// Note resulting `CodedInputStream` is buffered. /// /// If `Read` is buffered, the resulting stream will be double buffered, /// consider using [`from_buf_read`](Self::from_buf_read) instead. pub fn new(read: &'a mut dyn Read) -> CodedInputStream<'a> { CodedInputStream::from_buf_read_iter(BufReadIter::from_read(read)) } /// Create from `BufRead`. /// /// `CodedInputStream` will utilize `BufRead` buffer. pub fn from_buf_read(buf_read: &'a mut dyn BufRead) -> CodedInputStream<'a> { CodedInputStream::from_buf_read_iter(BufReadIter::from_buf_read(buf_read)) } /// Read from byte slice pub fn from_bytes(bytes: &'a [u8]) -> CodedInputStream<'a> { CodedInputStream::from_buf_read_iter(BufReadIter::from_byte_slice(bytes)) } /// Read from `Bytes`. /// /// `CodedInputStream` operations like /// [`read_tokio_bytes`](crate::CodedInputStream::read_tokio_bytes) /// will return a shared copy of this bytes object. #[cfg(feature = "bytes")] pub fn from_tokio_bytes(bytes: &'a Bytes) -> CodedInputStream<'a> { CodedInputStream::from_buf_read_iter(BufReadIter::from_bytes(bytes)) } fn from_buf_read_iter(source: BufReadIter<'a>) -> CodedInputStream<'a> { CodedInputStream { source, recursion_level: 0, recursion_limit: DEFAULT_RECURSION_LIMIT, } } /// Set the recursion limit. pub fn set_recursion_limit(&mut self, limit: u32) { self.recursion_limit = limit; } #[inline] pub(crate) fn incr_recursion(&mut self) -> crate::Result<()> { if self.recursion_level >= self.recursion_limit { return Err(ProtobufError::WireError(WireError::OverRecursionLimit).into()); } self.recursion_level += 1; Ok(()) } #[inline] pub(crate) fn decr_recursion(&mut self) { self.recursion_level -= 1; } /// How many bytes processed pub fn pos(&self) -> u64 { self.source.pos() } /// How many bytes until current limit pub fn bytes_until_limit(&self) -> u64 { self.source.bytes_until_limit() } /// Read bytes into given `buf`. #[inline] pub fn read_exact(&mut self, buf: &mut [MaybeUninit]) -> crate::Result<()> { self.source.read_exact(buf) } /// Read exact number of bytes as `Bytes` object. /// /// This operation returns a shared view if `CodedInputStream` is /// constructed with `Bytes` parameter. #[cfg(feature = "bytes")] fn read_raw_tokio_bytes(&mut self, count: usize) -> crate::Result { self.source.read_exact_bytes(count) } /// Read one byte #[inline(always)] pub fn read_raw_byte(&mut self) -> crate::Result { self.source.read_byte() } /// Push new limit, return previous limit. pub fn push_limit(&mut self, limit: u64) -> crate::Result { self.source.push_limit(limit) } /// Restore previous limit. pub fn pop_limit(&mut self, old_limit: u64) { self.source.pop_limit(old_limit); } /// Are we at EOF? #[inline(always)] pub fn eof(&mut self) -> crate::Result { self.source.eof() } /// Check we are at EOF. /// /// Return error if we are not at EOF. pub fn check_eof(&mut self) -> crate::Result<()> { let eof = self.eof()?; if !eof { return Err(ProtobufError::WireError(WireError::UnexpectedEof).into()); } Ok(()) } fn read_raw_varint64_slow(&mut self) -> crate::Result { let mut r: u64 = 0; let mut i = 0; loop { if i == MAX_VARINT_ENCODED_LEN { return Err(ProtobufError::WireError(WireError::IncorrectVarint).into()); } let b = self.read_raw_byte()?; if i == 9 && (b & 0x7f) > 1 { return Err(ProtobufError::WireError(WireError::IncorrectVarint).into()); } r = r | (((b & 0x7f) as u64) << (i * 7)); i += 1; if b < 0x80 { return Ok(r); } } } fn read_raw_varint32_slow(&mut self) -> crate::Result { let v = self.read_raw_varint64_slow()?; if v > u32::MAX as u64 { return Err(ProtobufError::WireError(WireError::U32Overflow(v)).into()); } Ok(v as u32) } /// Read varint #[inline] pub fn read_raw_varint64(&mut self) -> crate::Result { let rem = self.source.remaining_in_buf(); match decode_varint64(rem)? { Some((r, c)) => { self.source.consume(c); Ok(r) } None => self.read_raw_varint64_slow(), } } /// Read varint #[inline] pub fn read_raw_varint32(&mut self) -> crate::Result { let rem = self.source.remaining_in_buf(); match decode_varint32(rem)? { Some((r, c)) => { self.source.consume(c); Ok(r) } None => self.read_raw_varint32_slow(), } } #[inline] fn read_raw_varint32_or_eof(&mut self) -> crate::Result> { let rem = self.source.remaining_in_buf(); let v = decode_varint32(rem)?; match v { Some((r, c)) => { self.source.consume(c); Ok(Some(r)) } None => { if self.eof()? { Ok(None) } else { let v = self.read_raw_varint32_slow()?; Ok(Some(v)) } } } } /// Read little-endian 32-bit integer pub fn read_raw_little_endian32(&mut self) -> crate::Result { let mut bytes = [MaybeUninit::uninit(); 4]; self.read_exact(&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) -> crate::Result { let mut bytes = [MaybeUninit::uninit(); 8]; self.read_exact(&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 number as `u32` or None if EOF is reached. #[inline] pub fn read_raw_tag_or_eof(&mut self) -> crate::Result> { self.read_raw_varint32_or_eof() } /// Read tag #[inline] pub(crate) fn read_tag(&mut self) -> crate::Result { let v = self.read_raw_varint32()?; wire_format::Tag::new(v) } /// Read tag, return it is pair (field number, wire type) #[inline] pub(crate) fn read_tag_unpack(&mut self) -> crate::Result<(u32, WireType)> { self.read_tag().map(|t| t.unpack()) } /// Read `double` pub fn read_double(&mut self) -> crate::Result { let bits = self.read_raw_little_endian64()?; Ok(f64::from_bits(bits)) } /// Read `float` pub fn read_float(&mut self) -> crate::Result { let bits = self.read_raw_little_endian32()?; Ok(f32::from_bits(bits)) } /// Read `int64` pub fn read_int64(&mut self) -> crate::Result { self.read_raw_varint64().map(|v| v as i64) } /// Read `int32` pub fn read_int32(&mut self) -> crate::Result { let v = self.read_int64()?; i32::try_from(v).map_err(|_| WireError::I32Overflow(v).into()) } /// Read `uint64` pub fn read_uint64(&mut self) -> crate::Result { self.read_raw_varint64() } /// Read `uint32` pub fn read_uint32(&mut self) -> crate::Result { self.read_raw_varint32() } /// Read `sint64` pub fn read_sint64(&mut self) -> crate::Result { self.read_uint64().map(decode_zig_zag_64) } /// Read `sint32` pub fn read_sint32(&mut self) -> crate::Result { self.read_uint32().map(decode_zig_zag_32) } /// Read `fixed64` pub fn read_fixed64(&mut self) -> crate::Result { self.read_raw_little_endian64() } /// Read `fixed32` pub fn read_fixed32(&mut self) -> crate::Result { self.read_raw_little_endian32() } /// Read `sfixed64` pub fn read_sfixed64(&mut self) -> crate::Result { self.read_raw_little_endian64().map(|v| v as i64) } /// Read `sfixed32` pub fn read_sfixed32(&mut self) -> crate::Result { self.read_raw_little_endian32().map(|v| v as i32) } /// Read `bool` pub fn read_bool(&mut self) -> crate::Result { self.read_raw_varint64().map(|v| v != 0) } pub(crate) fn read_enum_value(&mut self) -> crate::Result { self.read_int32() } /// Read `enum` as `ProtobufEnum` pub fn read_enum(&mut self) -> crate::Result { let i = self.read_enum_value()?; match Enum::from_i32(i) { Some(e) => Ok(e), None => Err(ProtobufError::WireError(WireError::InvalidEnumValue(E::NAME, i)).into()), } } /// Read `enum` as `ProtobufEnumOrUnknown` pub fn read_enum_or_unknown(&mut self) -> crate::Result> { Ok(EnumOrUnknown::from_i32(self.read_int32()?)) } fn read_repeated_packed_fixed_into( &mut self, target: &mut Vec, ) -> crate::Result<()> { let len_bytes = self.read_raw_varint64()?; let reserve = if len_bytes <= READ_RAW_BYTES_MAX_ALLOC as u64 { (len_bytes as usize) / (T::ENCODED_SIZE as usize) } else { // prevent OOM on malformed input // probably should truncate READ_RAW_BYTES_MAX_ALLOC / (T::ENCODED_SIZE as usize) }; target.reserve(reserve); let old_limit = self.push_limit(len_bytes)?; while !self.eof()? { target.push(T::read(self)?); } self.pop_limit(old_limit); Ok(()) } fn read_repeated_packed_into( &mut self, target: &mut Vec, ) -> crate::Result<()> { let len_bytes = self.read_raw_varint64()?; // value is at least 1 bytes, so this is lower bound of element count let reserve = if len_bytes <= READ_RAW_BYTES_MAX_ALLOC as u64 { len_bytes as usize } else { // prevent OOM on malformed input READ_RAW_BYTES_MAX_ALLOC }; target.reserve(reserve); let old_limit = self.push_limit(len_bytes)?; while !self.eof()? { target.push(T::read(self)?); } self.pop_limit(old_limit); Ok(()) } /// Read repeated packed `double` pub fn read_repeated_packed_double_into(&mut self, target: &mut Vec) -> crate::Result<()> { self.read_repeated_packed_fixed_into::(target) } /// Read repeated packed `float` pub fn read_repeated_packed_float_into(&mut self, target: &mut Vec) -> crate::Result<()> { self.read_repeated_packed_fixed_into::(target) } /// Read repeated packed `int64` pub fn read_repeated_packed_int64_into(&mut self, target: &mut Vec) -> crate::Result<()> { self.read_repeated_packed_into::(target) } /// Read repeated packed `int32` pub fn read_repeated_packed_int32_into(&mut self, target: &mut Vec) -> crate::Result<()> { self.read_repeated_packed_into::(target) } /// Read repeated packed `uint64` pub fn read_repeated_packed_uint64_into(&mut self, target: &mut Vec) -> crate::Result<()> { self.read_repeated_packed_into::(target) } /// Read repeated packed `uint32` pub fn read_repeated_packed_uint32_into(&mut self, target: &mut Vec) -> crate::Result<()> { self.read_repeated_packed_into::(target) } /// Read repeated packed `sint64` pub fn read_repeated_packed_sint64_into(&mut self, target: &mut Vec) -> crate::Result<()> { self.read_repeated_packed_into::(target) } /// Read repeated packed `sint32` pub fn read_repeated_packed_sint32_into(&mut self, target: &mut Vec) -> crate::Result<()> { self.read_repeated_packed_into::(target) } /// Read repeated packed `fixed64` pub fn read_repeated_packed_fixed64_into( &mut self, target: &mut Vec, ) -> crate::Result<()> { self.read_repeated_packed_fixed_into::(target) } /// Read repeated packed `fixed32` pub fn read_repeated_packed_fixed32_into( &mut self, target: &mut Vec, ) -> crate::Result<()> { self.read_repeated_packed_fixed_into::(target) } /// Read repeated packed `sfixed64` pub fn read_repeated_packed_sfixed64_into( &mut self, target: &mut Vec, ) -> crate::Result<()> { self.read_repeated_packed_fixed_into::(target) } /// Read repeated packed `sfixed32` pub fn read_repeated_packed_sfixed32_into( &mut self, target: &mut Vec, ) -> crate::Result<()> { self.read_repeated_packed_fixed_into::(target) } /// Read repeated packed `bool` pub fn read_repeated_packed_bool_into(&mut self, target: &mut Vec) -> crate::Result<()> { self.read_repeated_packed_into::(target) } /// Read repeated packed enum values into the vector. pub(crate) fn read_repeated_packed_enum_values_into( &mut self, target: &mut Vec, ) -> crate::Result<()> { self.read_repeated_packed_into::(target) } fn skip_group(&mut self) -> crate::Result<()> { self.incr_recursion()?; let ret = self.skip_group_no_depth_check(); self.decr_recursion(); ret } fn skip_group_no_depth_check(&mut self) -> crate::Result<()> { while !self.eof()? { let wire_type = self.read_tag_unpack()?.1; if wire_type == WireType::EndGroup { break; } self.skip_field(wire_type)?; } Ok(()) } /// Read `UnknownValue` pub fn read_unknown(&mut self, wire_type: WireType) -> crate::Result { match wire_type { WireType::Varint => self.read_raw_varint64().map(|v| UnknownValue::Varint(v)), WireType::Fixed64 => self.read_fixed64().map(|v| UnknownValue::Fixed64(v)), WireType::Fixed32 => self.read_fixed32().map(|v| UnknownValue::Fixed32(v)), WireType::LengthDelimited => { let len = self.read_raw_varint32()?; self.read_raw_bytes(len) .map(|v| UnknownValue::LengthDelimited(v)) } WireType::StartGroup => { self.skip_group()?; // We do not support groups, so just return something. Ok(UnknownValue::LengthDelimited(Vec::new())) } WireType::EndGroup => { Err(ProtobufError::WireError(WireError::UnexpectedWireType(wire_type)).into()) } } } /// Skip field. pub fn skip_field(&mut self, wire_type: WireType) -> crate::Result<()> { match wire_type { WireType::Varint => self.read_raw_varint64().map(|_| ()), WireType::Fixed64 => self.read_fixed64().map(|_| ()), WireType::Fixed32 => self.read_fixed32().map(|_| ()), WireType::LengthDelimited => { let len = self.read_raw_varint32()?; self.skip_raw_bytes(len) } WireType::StartGroup => self.skip_group(), WireType::EndGroup => { Err(ProtobufError::WireError(WireError::UnexpectedWireType(wire_type)).into()) } } } /// 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) -> crate::Result<()> { self.source.read_exact_to_vec(count as usize, target) } /// Read exact number of bytes pub fn read_raw_bytes(&mut self, count: u32) -> crate::Result> { let mut r = Vec::new(); self.read_raw_bytes_into(count, &mut r)?; Ok(r) } /// Skip exact number of bytes pub fn skip_raw_bytes(&mut self, count: u32) -> crate::Result<()> { self.source.skip_bytes(count) } /// Read `bytes` field, length delimited pub fn read_bytes(&mut self) -> crate::Result> { let mut r = Vec::new(); self.read_bytes_into(&mut r)?; Ok(r) } /// Read `bytes` field, length delimited #[cfg(feature = "bytes")] pub fn read_tokio_bytes(&mut self) -> crate::Result { let len = self.read_raw_varint32()?; self.read_raw_tokio_bytes(len as usize) } /// Read `string` field, length delimited #[cfg(feature = "bytes")] pub fn read_tokio_chars(&mut self) -> crate::Result { let bytes = self.read_tokio_bytes()?; Ok(Chars::from_bytes(bytes).map_err(ProtobufError::Utf8)?) } /// Read `bytes` field, length delimited pub fn read_bytes_into(&mut self, target: &mut Vec) -> crate::Result<()> { let len = self.read_raw_varint32()?; self.read_raw_bytes_into(len, target)?; Ok(()) } /// Read `string` field, length delimited pub fn read_string(&mut self) -> crate::Result { let mut r = String::new(); self.read_string_into(&mut r)?; Ok(r) } /// Read `string` field, length delimited pub fn read_string_into(&mut self, target: &mut String) -> crate::Result<()> { target.clear(); // take target's buffer let mut vec = mem::replace(target, String::new()).into_bytes(); self.read_bytes_into(&mut vec)?; let s = match String::from_utf8(vec) { Ok(t) => t, Err(_) => return Err(ProtobufError::WireError(WireError::Utf8Error).into()), }; *target = s; Ok(()) } /// Read message, do not check if message is initialized pub fn merge_message(&mut self, message: &mut M) -> crate::Result<()> { self.incr_recursion()?; let ret = self.merge_message_no_depth_check(message); self.decr_recursion(); ret } fn merge_message_no_depth_check(&mut self, message: &mut M) -> crate::Result<()> { let len = self.read_raw_varint64()?; let old_limit = self.push_limit(len)?; message.merge_from(self)?; self.pop_limit(old_limit); Ok(()) } /// Like `merge_message`, but for dynamic messages. pub fn merge_message_dyn(&mut self, message: &mut dyn MessageDyn) -> crate::Result<()> { let len = self.read_raw_varint64()?; let old_limit = self.push_limit(len)?; message.merge_from_dyn(self)?; self.pop_limit(old_limit); Ok(()) } /// Read message pub fn read_message(&mut self) -> crate::Result { let mut r: M = Message::new(); self.merge_message(&mut r)?; r.check_initialized()?; Ok(r) } /// Read message. pub fn read_message_dyn( &mut self, descriptor: &MessageDescriptor, ) -> crate::Result> { let mut r = descriptor.new_instance(); self.merge_message_dyn(&mut *r)?; r.check_initialized_dyn()?; Ok(r) } } impl<'a> Read for CodedInputStream<'a> { fn read(&mut self, buf: &mut [u8]) -> io::Result { self.source.read(buf).map_err(Into::into) } } impl<'a> BufRead for CodedInputStream<'a> { fn fill_buf(&mut self) -> io::Result<&[u8]> { self.source.fill_buf().map_err(Into::into) } fn consume(&mut self, amt: usize) { self.source.consume(amt) } } #[cfg(test)] mod test { use std::fmt::Debug; use std::io; use std::io::BufRead; use std::io::Read; use super::CodedInputStream; use super::READ_RAW_BYTES_MAX_ALLOC; use crate::error::ProtobufError; use crate::hex::decode_hex; use crate::wire_format::Tag; use crate::wire_format::WireType; use crate::CodedOutputStream; fn test_read_partial(hex: &str, mut callback: F) where F: FnMut(&mut CodedInputStream), { let d = decode_hex(hex); // Test with buffered reader. { let mut reader = io::Cursor::new(&d); let mut is = CodedInputStream::from_buf_read(&mut reader as &mut dyn BufRead); assert_eq!(0, is.pos()); callback(&mut is); } // Test from bytes. { let mut is = CodedInputStream::from_bytes(&d); assert_eq!(0, is.pos()); callback(&mut is); } } fn test_read(hex: &str, mut callback: F) where F: FnMut(&mut CodedInputStream), { let len = decode_hex(hex).len(); test_read_partial(hex, |reader| { callback(reader); assert!(reader.eof().expect("eof")); assert_eq!(len as u64, reader.pos()); }); } fn test_read_v(hex: &str, v: V, mut callback: F) where F: FnMut(&mut CodedInputStream) -> crate::Result, V: PartialEq + Debug, { test_read(hex, |reader| { assert_eq!(v, callback(reader).unwrap()); }); } #[test] fn test_input_stream_read_raw_byte() { test_read("17", |is| { assert_eq!(23, is.read_raw_byte().unwrap()); }); } #[test] fn test_input_stream_read_raw_varint() { test_read_v("07", 7, |reader| reader.read_raw_varint32()); test_read_v("07", 7, |reader| reader.read_raw_varint64()); test_read_v("96 01", 150, |reader| reader.read_raw_varint32()); test_read_v("96 01", 150, |reader| reader.read_raw_varint64()); test_read_v( "ff ff ff ff ff ff ff ff ff 01", 0xffffffffffffffff, |reader| reader.read_raw_varint64(), ); test_read_v("ff ff ff ff 0f", 0xffffffff, |reader| { reader.read_raw_varint32() }); test_read_v("ff ff ff ff 0f", 0xffffffff, |reader| { reader.read_raw_varint64() }); } #[test] fn test_input_stream_read_raw_varint_out_of_range() { test_read_partial("ff ff ff ff ff ff ff ff ff 02", |is| { assert!(is.read_raw_varint64().is_err()); }); test_read_partial("ff ff ff ff ff ff ff ff ff 02", |is| { assert!(is.read_raw_varint32().is_err()); }); } #[test] fn test_input_stream_read_raw_varint_too_long() { // varint cannot have length > 10 test_read_partial("ff ff ff ff ff ff ff ff ff ff 01", |reader| { let error = reader.read_raw_varint64().unwrap_err().0; match *error { ProtobufError::WireError(..) => (), _ => panic!(), } }); test_read_partial("ff ff ff ff ff ff ff ff ff ff 01", |reader| { let error = reader.read_raw_varint32().unwrap_err().0; match *error { ProtobufError::WireError(..) => (), _ => panic!(), } }); } #[test] fn test_input_stream_read_raw_varint_unexpected_eof() { test_read_partial("96 97", |reader| { let error = reader.read_raw_varint32().unwrap_err().0; match *error { ProtobufError::WireError(..) => (), _ => panic!(), } }); } #[test] fn test_input_stream_read_raw_varint_pos() { test_read_partial("95 01 98", |reader| { assert_eq!(149, reader.read_raw_varint32().unwrap()); assert_eq!(2, reader.pos()); }); } #[test] fn test_input_stream_read_int32() { test_read_v("02", 2, |reader| reader.read_int32()); } #[test] fn test_input_stream_read_float() { test_read_v("95 73 13 61", 17e19, |is| is.read_float()); } #[test] fn test_input_stream_read_double() { test_read_v("40 d5 ab 68 b3 07 3d 46", 23e29, |is| is.read_double()); } #[test] fn test_input_stream_skip_raw_bytes() { test_read("", |reader| { reader.skip_raw_bytes(0).unwrap(); }); test_read("aa bb", |reader| { reader.skip_raw_bytes(2).unwrap(); }); test_read("aa bb cc dd ee ff", |reader| { reader.skip_raw_bytes(6).unwrap(); }); } #[test] fn test_input_stream_read_raw_bytes() { test_read("", |reader| { assert_eq!( Vec::from(&b""[..]), reader.read_raw_bytes(0).expect("read_raw_bytes") ); }) } #[test] fn test_input_stream_limits() { test_read("aa bb cc", |is| { let old_limit = is.push_limit(1).unwrap(); assert_eq!(1, is.bytes_until_limit()); let r1 = is.read_raw_bytes(1).unwrap(); assert_eq!(&[0xaa as u8], &r1[..]); is.pop_limit(old_limit); let r2 = is.read_raw_bytes(2).unwrap(); assert_eq!(&[0xbb as u8, 0xcc], &r2[..]); }); } #[test] fn test_input_stream_io_read() { test_read("aa bb cc", |is| { let mut buf = [0; 3]; assert_eq!(Read::read(is, &mut buf).expect("io::Read"), 3); assert_eq!(buf, [0xaa, 0xbb, 0xcc]); }); } #[test] fn test_input_stream_io_bufread() { test_read("aa bb cc", |is| { assert_eq!( BufRead::fill_buf(is).expect("io::BufRead::fill_buf"), &[0xaa, 0xbb, 0xcc] ); BufRead::consume(is, 3); }); } #[test] #[cfg_attr(miri, ignore)] // Miri is too slow for this test. fn test_input_stream_read_raw_bytes_into_huge() { let mut v = Vec::new(); for i in 0..READ_RAW_BYTES_MAX_ALLOC + 1000 { v.push((i % 10) as u8); } let mut slice: &[u8] = v.as_slice(); let mut is = CodedInputStream::new(&mut slice); let mut buf = Vec::new(); is.read_raw_bytes_into(READ_RAW_BYTES_MAX_ALLOC as u32 + 10, &mut buf) .expect("read"); assert_eq!(READ_RAW_BYTES_MAX_ALLOC + 10, buf.len()); buf.clear(); is.read_raw_bytes_into(1000 - 10, &mut buf).expect("read"); assert_eq!(1000 - 10, buf.len()); assert!(is.eof().expect("eof")); } // Copy of this test: https://tinyurl.com/34hfavtz #[test] fn test_skip_group() { // Create an output stream with a group in: // Field 1: string "field 1" // Field 2: group containing: // Field 1: fixed int32 value 100 // Field 2: string "ignore me" // Field 3: nested group containing // Field 1: fixed int64 value 1000 // Field 3: string "field 3" let mut vec = Vec::new(); let mut os = CodedOutputStream::new(&mut vec); os.write_tag(1, WireType::LengthDelimited).unwrap(); os.write_string_no_tag("field 1").unwrap(); // The outer group... os.write_tag(2, WireType::StartGroup).unwrap(); os.write_tag(1, WireType::Fixed32).unwrap(); os.write_fixed32_no_tag(100).unwrap(); os.write_tag(3, WireType::LengthDelimited).unwrap(); os.write_string_no_tag("ignore me").unwrap(); // The nested group... os.write_tag(3, WireType::StartGroup).unwrap(); os.write_tag(1, WireType::Fixed64).unwrap(); os.write_fixed64_no_tag(1000).unwrap(); // Note: Not sure the field number is relevant for end group... os.write_tag(3, WireType::EndGroup).unwrap(); // End the outer group os.write_tag(2, WireType::EndGroup).unwrap(); os.write_tag(3, WireType::LengthDelimited).unwrap(); os.write_string_no_tag("field 3").unwrap(); os.flush().unwrap(); drop(os); let mut input = CodedInputStream::from_bytes(&vec); // Now act like a generated client assert_eq!( Tag::make(1, WireType::LengthDelimited), input.read_tag().unwrap() ); assert_eq!("field 1", &input.read_string().unwrap()); assert_eq!( Tag::make(2, WireType::StartGroup), input.read_tag().unwrap() ); input.skip_field(WireType::StartGroup).unwrap(); assert_eq!( Tag::make(3, WireType::LengthDelimited), input.read_tag().unwrap() ); assert_eq!("field 3", input.read_string().unwrap()); } #[test] fn test_shallow_nested_unknown_groups() { // Test skip_group() succeeds on a start group tag 50 times // followed by end group tag 50 times. We should be able to // successfully skip the outermost group. let mut vec = Vec::new(); let mut os = CodedOutputStream::new(&mut vec); for _ in 0..50 { os.write_tag(1, WireType::StartGroup).unwrap(); } for _ in 0..50 { os.write_tag(1, WireType::EndGroup).unwrap(); } drop(os); let mut input = CodedInputStream::from_bytes(&vec); assert!(input.skip_group().is_ok()); } #[test] fn test_deeply_nested_unknown_groups() { // Create an output stream that has groups nested recursively 1000 // deep, and try to skip the group. // This should fail the default depth limit of 100 which ensures we // don't blow the stack on adversial input. let mut vec = Vec::new(); let mut os = CodedOutputStream::new(&mut vec); for _ in 0..1000 { os.write_tag(1, WireType::StartGroup).unwrap(); } for _ in 0..1000 { os.write_tag(1, WireType::EndGroup).unwrap(); } drop(os); let mut input = CodedInputStream::from_bytes(&vec); assert!(input .skip_group() .unwrap_err() .to_string() .contains("Over recursion limit")); } } protobuf-3.7.2/src/coded_output_stream/buffer.rs000064400000000000000000000065721046102023000201660ustar 00000000000000use std::fmt; use std::fmt::Formatter; use std::mem::MaybeUninit; use std::slice; use crate::misc::maybe_uninit_write_slice; pub(crate) struct OutputBuffer { // 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], /// Position within the buffer. /// Always correct. pos_within_buf: usize, } impl fmt::Debug for OutputBuffer { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { f.debug_struct("OutputBuffer") .field("buffer.len", &self.buffer().len()) .field("pos_within_buf", &self.pos_within_buf) .finish() } } impl OutputBuffer { #[inline] pub(crate) fn new(buffer: *mut [MaybeUninit]) -> OutputBuffer { Self { buffer, pos_within_buf: 0, } } /// Whole buffer: written data + unwritten data. #[inline] pub(crate) fn buffer(&self) -> &[MaybeUninit] { unsafe { &*self.buffer } } #[inline] fn buffer_mut(&mut self) -> &mut [MaybeUninit] { unsafe { &mut *self.buffer } } #[inline] pub(crate) fn pos_within_buf(&self) -> usize { self.pos_within_buf } #[inline] pub(crate) fn filled(&self) -> &[u8] { // SAFETY: This type invariant is data is filled up to `pos_within_buf`. unsafe { slice::from_raw_parts_mut(self.buffer as *mut u8, self.pos_within_buf) } } #[inline] pub(crate) fn unfilled(&mut self) -> &mut [MaybeUninit] { // SAFETY: This type invariant is `pos_within_buf` is smaller than buffer length. let pos_within_buf = self.pos_within_buf; unsafe { self.buffer_mut().get_unchecked_mut(pos_within_buf..) } } #[inline] pub(crate) fn unfilled_len(&self) -> usize { self.buffer().len() - self.pos_within_buf } #[inline] pub(crate) unsafe fn advance(&mut self, n: usize) { debug_assert!(n <= self.unfilled_len()); self.pos_within_buf += n; } #[inline] pub(crate) fn rewind(&mut self) { self.pos_within_buf = 0; } #[inline] pub(crate) fn replace_buffer_keep_pos(&mut self, buffer: *mut [MaybeUninit]) { unsafe { assert!(self.pos_within_buf <= (&*buffer).len()); } self.buffer = buffer; } #[inline] pub(crate) unsafe fn write_byte(&mut self, b: u8) { debug_assert!(self.unfilled_len() >= 1); // SAFETY: caller is responsible for ensuring that byte fits in the buffer. let pos_within_buf = self.pos_within_buf; self.buffer_mut().get_unchecked_mut(pos_within_buf).write(b); self.pos_within_buf += 1; } #[inline] pub(crate) unsafe fn write_bytes(&mut self, bytes: &[u8]) { debug_assert!(self.unfilled_len() >= bytes.len()); let bottom = self.pos_within_buf as usize; let top = bottom + (bytes.len() as usize); // SAFETY: caller is responsible for ensuring that `bytes` fits in the buffer. let buffer = self.buffer_mut().get_unchecked_mut(bottom..top); maybe_uninit_write_slice(buffer, bytes); self.pos_within_buf += bytes.len(); } } protobuf-3.7.2/src/coded_output_stream/mod.rs000064400000000000000000001173731046102023000174760ustar 00000000000000mod buffer; mod output_target; pub(crate) mod with; use std::io; use std::io::Write; use std::mem::MaybeUninit; use std::ptr; use std::slice; use crate::byteorder::LITTLE_ENDIAN; use crate::coded_output_stream::buffer::OutputBuffer; use crate::coded_output_stream::output_target::OutputTarget; use crate::error::ProtobufError; use crate::rt::packed::vec_packed_enum_or_unknown_data_size; use crate::rt::packed::vec_packed_fixed_data_size; use crate::rt::packed::vec_packed_varint_data_size; use crate::rt::packed::vec_packed_varint_zigzag_data_size; use crate::varint::encode::encode_varint32; use crate::varint::encode::encode_varint64; use crate::varint::encode::encoded_varint64_len; use crate::varint::MAX_VARINT_ENCODED_LEN; use crate::wire_format; use crate::wire_format::check_message_size; use crate::wire_format::WireType; use crate::wire_format::MAX_MESSAGE_SIZE; use crate::zigzag::encode_zig_zag_32; use crate::zigzag::encode_zig_zag_64; use crate::Enum; use crate::EnumOrUnknown; use crate::Message; use crate::MessageDyn; use crate::MessageFull; use crate::UnknownFields; use crate::UnknownValueRef; // Equal to the default buffer size of `BufWriter`, so when // `CodedOutputStream` wraps `BufWriter`, it often skips double buffering. const OUTPUT_STREAM_BUFFER_SIZE: usize = 8 * 1024; /// Buffered write with handy utilities #[derive(Debug)] pub struct CodedOutputStream<'a> { target: OutputTarget<'a>, buffer: OutputBuffer, /// Absolute position of the buffer start. pos_of_buffer_start: u64, } impl<'a> CodedOutputStream<'a> { /// Construct from given `Write`. /// /// `CodedOutputStream` is buffered even if `Write` is not pub fn new(writer: &'a mut dyn Write) -> CodedOutputStream<'a> { let buffer_len = OUTPUT_STREAM_BUFFER_SIZE; let mut buffer_storage = Vec::with_capacity(buffer_len); // SAFETY: we are not using the `buffer_storage` // except for initializing the `buffer` field. // See `buffer` field documentation. let buffer = OutputBuffer::new(buffer_storage.spare_capacity_mut()); CodedOutputStream { target: OutputTarget::Write(writer, buffer_storage), buffer, pos_of_buffer_start: 0, } } /// `CodedOutputStream` which writes directly to bytes. /// /// 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]. let buffer = ptr::slice_from_raw_parts_mut(bytes.as_mut_ptr() as *mut MaybeUninit, bytes.len()); let buffer = OutputBuffer::new(buffer); CodedOutputStream { target: OutputTarget::Bytes, buffer, pos_of_buffer_start: 0, } } /// `CodedOutputStream` which writes directly to `Vec`. pub fn vec(vec: &'a mut Vec) -> CodedOutputStream<'a> { let buffer = OutputBuffer::new(vec.spare_capacity_mut()); CodedOutputStream { target: OutputTarget::Vec(vec), buffer, pos_of_buffer_start: 0, } } pub(crate) fn reserve_additional( &mut self, additional: u32, message: &str, ) -> crate::Result<()> { if additional as usize <= self.buffer.unfilled_len() { return Ok(()); } match &mut self.target { OutputTarget::Write(..) => Ok(()), OutputTarget::Vec(v) => { let reserve = (additional as usize) .checked_add(self.buffer.pos_within_buf()) .unwrap(); v.reserve(reserve); // `pos_within_buf` remains unchanged. self.buffer.replace_buffer_keep_pos(v.spare_capacity_mut()); Ok(()) } OutputTarget::Bytes => { Err(ProtobufError::BufferHasNotEnoughCapacity(message.to_owned()).into()) } } } pub(crate) fn reserve_additional_for_length_delimited( &mut self, size: u32, message: &str, ) -> crate::Result<()> { debug_assert!( size <= MAX_MESSAGE_SIZE as u32, "Caller of this function is responsible to guarantee \ that message size does not exceed; size: {}, MAX_MESSAGE_SIZE: {}", size, MAX_MESSAGE_SIZE, ); let reserve = size + encoded_varint64_len(size as u64) as u32; self.reserve_additional(reserve, message) } /// Total number of bytes written to this stream. /// /// This number may be larger than the actual number of bytes written to the underlying stream, /// if the buffer was not flushed. /// /// The number may be inaccurate if there was an error during the write. pub fn total_bytes_written(&self) -> u64 { self.pos_of_buffer_start + self.buffer.pos_within_buf() as u64 } /// Check if EOF is reached. /// /// # Panics /// /// If underlying write has no EOF pub fn check_eof(&self) { match self.target { OutputTarget::Bytes => { assert_eq!( self.buffer.buffer().len() as u64, self.buffer.pos_within_buf() as u64 ); } OutputTarget::Write(..) | OutputTarget::Vec(..) => { panic!("must not be called with Writer or Vec"); } } } fn refresh_buffer(&mut self) -> crate::Result<()> { match self.target { OutputTarget::Write(ref mut write, _) => { write.write_all(self.buffer.filled())?; self.pos_of_buffer_start += self.buffer.pos_within_buf() as u64; self.buffer.rewind(); } OutputTarget::Vec(ref mut vec) => unsafe { let vec_len = vec.len(); assert!(vec_len + self.buffer.pos_within_buf() <= vec.capacity()); vec.set_len(vec_len + self.buffer.pos_within_buf()); vec.reserve(1); self.pos_of_buffer_start += self.buffer.pos_within_buf() as u64; self.buffer = OutputBuffer::new(vec.spare_capacity_mut()); }, OutputTarget::Bytes => { return Err(ProtobufError::IoError(io::Error::new( io::ErrorKind::Other, "given slice is too small to serialize the message", )) .into()); } } Ok(()) } /// Flush to buffer to the underlying buffer. /// Note that `CodedOutputStream` does `flush` in the destructor, /// however, if `flush` in destructor fails, then destructor panics /// and program terminates. So it's advisable to explicitly call flush /// before destructor. pub fn flush(&mut self) -> crate::Result<()> { match &mut self.target { OutputTarget::Bytes => Ok(()), OutputTarget::Vec(vec) => { let vec_len = vec.len(); assert!(vec_len + self.buffer.pos_within_buf() <= vec.capacity()); unsafe { vec.set_len(vec_len + self.buffer.pos_within_buf()); } self.pos_of_buffer_start += self.buffer.pos_within_buf() as u64; self.buffer = OutputBuffer::new(vec.spare_capacity_mut()); Ok(()) } OutputTarget::Write(..) => self.refresh_buffer(), } } /// Write a byte pub fn write_raw_byte(&mut self, byte: u8) -> crate::Result<()> { if self.buffer.unfilled_len() == 0 { self.refresh_buffer()?; } unsafe { self.buffer.write_byte(byte) }; Ok(()) } /// Write bytes pub fn write_raw_bytes(&mut self, bytes: &[u8]) -> crate::Result<()> { if bytes.len() <= self.buffer.unfilled_len() { // SAFETY: we've just checked that there's enough space in the buffer. unsafe { self.buffer.write_bytes(bytes) }; return Ok(()); } self.refresh_buffer()?; assert!(self.buffer.pos_within_buf() == 0); if bytes.len() <= self.buffer.unfilled_len() { // SAFETY: we've just checked that there's enough space in the buffer. unsafe { self.buffer.write_bytes(bytes) }; return Ok(()); } match self.target { OutputTarget::Bytes => { unreachable!(); } OutputTarget::Write(ref mut write, _) => { write.write_all(bytes)?; self.pos_of_buffer_start += bytes.len() as u64; } OutputTarget::Vec(ref mut vec) => { assert!(self.buffer.pos_within_buf() == 0); vec.extend(bytes); self.buffer = OutputBuffer::new(vec.spare_capacity_mut()); self.pos_of_buffer_start += bytes.len() as u64; } } Ok(()) } /// Write a tag pub fn write_tag(&mut self, field_number: u32, wire_type: WireType) -> crate::Result<()> { self.write_raw_varint32(wire_format::Tag::make(field_number, wire_type).value()) } /// Write varint pub fn write_raw_varint32(&mut self, value: u32) -> crate::Result<()> { if self.buffer.unfilled_len() >= 5 { // fast path unsafe { let len = encode_varint32(value, self.buffer.unfilled()); self.buffer.advance(len); }; Ok(()) } else { // slow path let buf = &mut [0u8; 5]; let len = encode_varint32(value, unsafe { slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut MaybeUninit, buf.len()) }); self.write_raw_bytes(&buf[..len]) } } /// Write varint pub fn write_raw_varint64(&mut self, value: u64) -> crate::Result<()> { if self.buffer.unfilled_len() >= MAX_VARINT_ENCODED_LEN { // fast path unsafe { let len = encode_varint64(value, self.buffer.unfilled()); self.buffer.advance(len); }; Ok(()) } else { // slow path let buf = &mut [0u8; MAX_VARINT_ENCODED_LEN]; let len = encode_varint64(value, unsafe { slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut MaybeUninit, buf.len()) }); self.write_raw_bytes(&buf[..len]) } } /// Write 32-bit integer little endian pub fn write_raw_little_endian32(&mut self, value: u32) -> crate::Result<()> { self.write_raw_bytes(&value.to_le_bytes()) } /// Write 64-bit integer little endian pub fn write_raw_little_endian64(&mut self, value: u64) -> crate::Result<()> { self.write_raw_bytes(&value.to_le_bytes()) } /// Write `float` pub fn write_float_no_tag(&mut self, value: f32) -> crate::Result<()> { self.write_raw_little_endian32(value.to_bits()) } /// Write `double` pub fn write_double_no_tag(&mut self, value: f64) -> crate::Result<()> { self.write_raw_little_endian64(value.to_bits()) } /// Write `float` field pub fn write_float(&mut self, field_number: u32, value: f32) -> crate::Result<()> { self.write_tag(field_number, WireType::Fixed32)?; self.write_float_no_tag(value)?; Ok(()) } /// Write `double` field pub fn write_double(&mut self, field_number: u32, value: f64) -> crate::Result<()> { self.write_tag(field_number, WireType::Fixed64)?; self.write_double_no_tag(value)?; Ok(()) } /// Write varint pub fn write_uint64_no_tag(&mut self, value: u64) -> crate::Result<()> { self.write_raw_varint64(value) } /// Write varint pub fn write_uint32_no_tag(&mut self, value: u32) -> crate::Result<()> { self.write_raw_varint32(value) } /// Write varint pub fn write_int64_no_tag(&mut self, value: i64) -> crate::Result<()> { self.write_raw_varint64(value as u64) } /// Write varint pub fn write_int32_no_tag(&mut self, value: i32) -> crate::Result<()> { self.write_raw_varint64(value as u64) } /// Write zigzag varint pub fn write_sint64_no_tag(&mut self, value: i64) -> crate::Result<()> { self.write_uint64_no_tag(encode_zig_zag_64(value)) } /// Write zigzag varint pub fn write_sint32_no_tag(&mut self, value: i32) -> crate::Result<()> { self.write_uint32_no_tag(encode_zig_zag_32(value)) } /// Write `fixed64` pub fn write_fixed64_no_tag(&mut self, value: u64) -> crate::Result<()> { self.write_raw_little_endian64(value) } /// Write `fixed32` pub fn write_fixed32_no_tag(&mut self, value: u32) -> crate::Result<()> { self.write_raw_little_endian32(value) } /// Write `sfixed64` pub fn write_sfixed64_no_tag(&mut self, value: i64) -> crate::Result<()> { self.write_raw_little_endian64(value as u64) } /// Write `sfixed32` pub fn write_sfixed32_no_tag(&mut self, value: i32) -> crate::Result<()> { self.write_raw_little_endian32(value as u32) } /// Write `bool` pub fn write_bool_no_tag(&mut self, value: bool) -> crate::Result<()> { self.write_raw_varint32(if value { 1 } else { 0 }) } /// Write `enum` pub fn write_enum_no_tag(&mut self, value: i32) -> crate::Result<()> { self.write_int32_no_tag(value) } /// Write `enum` pub fn write_enum_obj_no_tag(&mut self, value: E) -> crate::Result<()> where E: Enum, { self.write_enum_no_tag(value.value()) } /// Write `enum` pub fn write_enum_or_unknown_no_tag(&mut self, value: EnumOrUnknown) -> crate::Result<()> where E: Enum, { self.write_enum_no_tag(value.value()) } /// Write unknown value pub fn write_unknown_no_tag(&mut self, unknown: UnknownValueRef) -> crate::Result<()> { match unknown { UnknownValueRef::Fixed64(fixed64) => self.write_raw_little_endian64(fixed64), UnknownValueRef::Fixed32(fixed32) => self.write_raw_little_endian32(fixed32), UnknownValueRef::Varint(varint) => self.write_raw_varint64(varint), UnknownValueRef::LengthDelimited(bytes) => self.write_bytes_no_tag(bytes), } } /// Write `uint64` field pub fn write_uint64(&mut self, field_number: u32, value: u64) -> crate::Result<()> { self.write_tag(field_number, WireType::Varint)?; self.write_uint64_no_tag(value)?; Ok(()) } /// Write `uint32` field pub fn write_uint32(&mut self, field_number: u32, value: u32) -> crate::Result<()> { self.write_tag(field_number, WireType::Varint)?; self.write_uint32_no_tag(value)?; Ok(()) } /// Write `int64` field pub fn write_int64(&mut self, field_number: u32, value: i64) -> crate::Result<()> { self.write_tag(field_number, WireType::Varint)?; self.write_int64_no_tag(value)?; Ok(()) } /// Write `int32` field pub fn write_int32(&mut self, field_number: u32, value: i32) -> crate::Result<()> { self.write_tag(field_number, WireType::Varint)?; self.write_int32_no_tag(value)?; Ok(()) } /// Write `sint64` field pub fn write_sint64(&mut self, field_number: u32, value: i64) -> crate::Result<()> { self.write_tag(field_number, WireType::Varint)?; self.write_sint64_no_tag(value)?; Ok(()) } /// Write `sint32` field pub fn write_sint32(&mut self, field_number: u32, value: i32) -> crate::Result<()> { self.write_tag(field_number, WireType::Varint)?; self.write_sint32_no_tag(value)?; Ok(()) } /// Write `fixed64` field pub fn write_fixed64(&mut self, field_number: u32, value: u64) -> crate::Result<()> { self.write_tag(field_number, WireType::Fixed64)?; self.write_fixed64_no_tag(value)?; Ok(()) } /// Write `fixed32` field pub fn write_fixed32(&mut self, field_number: u32, value: u32) -> crate::Result<()> { self.write_tag(field_number, WireType::Fixed32)?; self.write_fixed32_no_tag(value)?; Ok(()) } /// Write `sfixed64` field pub fn write_sfixed64(&mut self, field_number: u32, value: i64) -> crate::Result<()> { self.write_tag(field_number, WireType::Fixed64)?; self.write_sfixed64_no_tag(value)?; Ok(()) } /// Write `sfixed32` field pub fn write_sfixed32(&mut self, field_number: u32, value: i32) -> crate::Result<()> { self.write_tag(field_number, WireType::Fixed32)?; self.write_sfixed32_no_tag(value)?; Ok(()) } /// Write `bool` field pub fn write_bool(&mut self, field_number: u32, value: bool) -> crate::Result<()> { self.write_tag(field_number, WireType::Varint)?; self.write_bool_no_tag(value)?; Ok(()) } /// Write `enum` field pub fn write_enum(&mut self, field_number: u32, value: i32) -> crate::Result<()> { self.write_tag(field_number, WireType::Varint)?; self.write_enum_no_tag(value)?; Ok(()) } /// Write `enum` field pub fn write_enum_obj(&mut self, field_number: u32, value: E) -> crate::Result<()> where E: Enum, { self.write_enum(field_number, value.value()) } /// Write `enum` field pub fn write_enum_or_unknown( &mut self, field_number: u32, value: EnumOrUnknown, ) -> crate::Result<()> where E: Enum, { self.write_enum(field_number, value.value()) } /// Write unknown field pub fn write_unknown( &mut self, field_number: u32, value: UnknownValueRef, ) -> crate::Result<()> { self.write_tag(field_number, value.wire_type())?; self.write_unknown_no_tag(value)?; Ok(()) } /// Write unknown fields pub fn write_unknown_fields(&mut self, fields: &UnknownFields) -> crate::Result<()> { for (number, value) in fields { self.write_unknown(number, value)?; } Ok(()) } /// Write unknown fields sorting them by name // TODO: make unknown fields deterministic and remove this. pub(crate) fn write_unknown_fields_sorted( &mut self, fields: &UnknownFields, ) -> crate::Result<()> { let mut fields: Vec<_> = fields.iter().collect(); fields.sort_by_key(|(n, _)| *n); for (number, value) in fields { self.write_unknown(number, value)?; } Ok(()) } /// Write bytes pub fn write_bytes_no_tag(&mut self, bytes: &[u8]) -> crate::Result<()> { self.write_raw_varint32(bytes.len() as u32)?; self.write_raw_bytes(bytes)?; Ok(()) } /// Write string pub fn write_string_no_tag(&mut self, s: &str) -> crate::Result<()> { self.write_bytes_no_tag(s.as_bytes()) } /// Write message pub fn write_message_no_tag(&mut self, msg: &M) -> crate::Result<()> { msg.write_length_delimited_to(self) } /// Write dynamic message pub fn write_message_no_tag_dyn(&mut self, msg: &dyn MessageDyn) -> crate::Result<()> { let size = msg.compute_size_dyn(); let size = check_message_size(size)?; self.write_raw_varint32(size)?; msg.write_to_dyn(self)?; Ok(()) } /// Write `bytes` field pub fn write_bytes(&mut self, field_number: u32, bytes: &[u8]) -> crate::Result<()> { self.write_tag(field_number, WireType::LengthDelimited)?; self.write_bytes_no_tag(bytes)?; Ok(()) } /// Write `string` field pub fn write_string(&mut self, field_number: u32, s: &str) -> crate::Result<()> { self.write_tag(field_number, WireType::LengthDelimited)?; self.write_string_no_tag(s)?; Ok(()) } /// Write repeated packed float values. pub fn write_repeated_packed_float_no_tag(&mut self, values: &[f32]) -> crate::Result<()> { if LITTLE_ENDIAN { // SAFETY: it is safe to transmute floats to bytes. let bytes = unsafe { slice::from_raw_parts(values.as_ptr() as *const u8, values.len() * 4) }; self.write_raw_bytes(bytes) } else { for v in values { self.write_float_no_tag(*v)?; } Ok(()) } } /// Write field header and data for repeated packed float. pub fn write_repeated_packed_float( &mut self, field_number: u32, values: &[f32], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_fixed_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_float_no_tag(values)?; Ok(()) } /// Write repeated packed double values. pub fn write_repeated_packed_double_no_tag(&mut self, values: &[f64]) -> crate::Result<()> { if LITTLE_ENDIAN { // SAFETY: it is safe to transmute doubles to bytes. let bytes = unsafe { slice::from_raw_parts(values.as_ptr() as *const u8, values.len() * 8) }; self.write_raw_bytes(bytes) } else { for v in values { self.write_double_no_tag(*v)?; } Ok(()) } } /// Write field header and data for repeated packed double. pub fn write_repeated_packed_double( &mut self, field_number: u32, values: &[f64], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_fixed_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_double_no_tag(values)?; Ok(()) } /// Write repeated packed fixed32 values. pub fn write_repeated_packed_fixed32_no_tag(&mut self, values: &[u32]) -> crate::Result<()> { if LITTLE_ENDIAN { // SAFETY: it is safe to transmute integer to bytes. let bytes = unsafe { slice::from_raw_parts(values.as_ptr() as *const u8, values.len() * 4) }; self.write_raw_bytes(bytes)?; } else { for v in values { self.write_fixed32_no_tag(*v)?; } } Ok(()) } /// Write field header and data for repeated packed fixed32. pub fn write_repeated_packed_fixed32( &mut self, field_number: u32, values: &[u32], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_fixed_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_fixed32_no_tag(values)?; Ok(()) } /// Write repeated packed fixed64 values. pub fn write_repeated_packed_fixed64_no_tag(&mut self, values: &[u64]) -> crate::Result<()> { if LITTLE_ENDIAN { // SAFETY: it is safe to transmute integer to bytes. let bytes = unsafe { slice::from_raw_parts(values.as_ptr() as *const u8, values.len() * 8) }; self.write_raw_bytes(bytes)?; } else { for v in values { self.write_fixed64_no_tag(*v)?; } } Ok(()) } /// Write field header and data for repeated packed fixed64. pub fn write_repeated_packed_fixed64( &mut self, field_number: u32, values: &[u64], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_fixed_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_fixed64_no_tag(values)?; Ok(()) } /// Write repeated packed sfixed32 values. pub fn write_repeated_packed_sfixed32_no_tag(&mut self, values: &[i32]) -> crate::Result<()> { if LITTLE_ENDIAN { // SAFETY: it is safe to transmute integer to bytes. let bytes = unsafe { slice::from_raw_parts(values.as_ptr() as *const u8, values.len() * 4) }; self.write_raw_bytes(bytes)?; } else { for v in values { self.write_sfixed32_no_tag(*v)?; } } Ok(()) } /// Write field header and data for repeated packed sfixed32. pub fn write_repeated_packed_sfixed32( &mut self, field_number: u32, values: &[i32], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_fixed_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_sfixed32_no_tag(values)?; Ok(()) } /// Write repeated packed sfixed64 values. pub fn write_repeated_packed_sfixed64_no_tag(&mut self, values: &[i64]) -> crate::Result<()> { if LITTLE_ENDIAN { // SAFETY: it is safe to transmute integer to bytes. let bytes = unsafe { slice::from_raw_parts(values.as_ptr() as *const u8, values.len() * 8) }; self.write_raw_bytes(bytes)?; } else { for v in values { self.write_sfixed64_no_tag(*v)?; } } Ok(()) } /// Write field header and data for repeated packed sfixed64. pub fn write_repeated_packed_sfixed64( &mut self, field_number: u32, values: &[i64], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_fixed_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_sfixed64_no_tag(values)?; Ok(()) } /// Write repeated packed int32 values. pub fn write_repeated_packed_int32_no_tag(&mut self, values: &[i32]) -> crate::Result<()> { for v in values { self.write_int32_no_tag(*v)?; } Ok(()) } /// Write field header and data for repeated packed int32. pub fn write_repeated_packed_int32( &mut self, field_number: u32, values: &[i32], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_varint_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_int32_no_tag(values)?; Ok(()) } /// Write repeated packed int64 values. pub fn write_repeated_packed_int64_no_tag(&mut self, values: &[i64]) -> crate::Result<()> { for v in values { self.write_int64_no_tag(*v)?; } Ok(()) } /// Write field header and data for repeated packed int64. pub fn write_repeated_packed_int64( &mut self, field_number: u32, values: &[i64], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_varint_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_int64_no_tag(values)?; Ok(()) } /// Write repeated packed uint32 values. pub fn write_repeated_packed_uint32_no_tag(&mut self, values: &[u32]) -> crate::Result<()> { for v in values { self.write_uint32_no_tag(*v)?; } Ok(()) } /// Write field header and data for repeated packed uint32. pub fn write_repeated_packed_uint32( &mut self, field_number: u32, values: &[u32], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_varint_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_uint32_no_tag(values)?; Ok(()) } /// Write repeated packed uint64 values. pub fn write_repeated_packed_uint64_no_tag(&mut self, values: &[u64]) -> crate::Result<()> { for v in values { self.write_uint64_no_tag(*v)?; } Ok(()) } /// Write field header and data for repeated packed uint64. pub fn write_repeated_packed_uint64( &mut self, field_number: u32, values: &[u64], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_varint_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_uint64_no_tag(values)?; Ok(()) } /// Write repeated packed sint32 values. pub fn write_repeated_packed_sint32_no_tag(&mut self, values: &[i32]) -> crate::Result<()> { for v in values { self.write_sint32_no_tag(*v)?; } Ok(()) } /// Write field header and data for repeated packed sint32. pub fn write_repeated_packed_sint32( &mut self, field_number: u32, values: &[i32], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_varint_zigzag_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_sint32_no_tag(values)?; Ok(()) } /// Write repeated packed sint64 values. pub fn write_repeated_packed_sint64_no_tag(&mut self, values: &[i64]) -> crate::Result<()> { for v in values { self.write_sint64_no_tag(*v)?; } Ok(()) } /// Write field header and data for repeated packed sint64. pub fn write_repeated_packed_sint64( &mut self, field_number: u32, values: &[i64], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_varint_zigzag_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_sint64_no_tag(values)?; Ok(()) } /// Write repeated packed bool values. pub fn write_repeated_packed_bool_no_tag(&mut self, values: &[bool]) -> crate::Result<()> { for v in values { self.write_bool_no_tag(*v)?; } Ok(()) } /// Write field header and data for repeated packed bool. pub fn write_repeated_packed_bool( &mut self, field_number: u32, values: &[bool], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_fixed_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_bool_no_tag(values)?; Ok(()) } /// Write repeated packed enum values. #[inline] pub fn write_repeated_packed_enum_or_unknown_no_tag( &mut self, values: &[EnumOrUnknown], ) -> crate::Result<()> { self.write_repeated_packed_int32_no_tag(EnumOrUnknown::cast_to_values(values)) } /// Write field header and data for repeated packed enum. pub fn write_repeated_packed_enum_or_unknown( &mut self, field_number: u32, values: &[EnumOrUnknown], ) -> crate::Result<()> { if values.is_empty() { return Ok(()); } self.write_tag(field_number, WireType::LengthDelimited)?; let data_size = vec_packed_enum_or_unknown_data_size(values); self.write_raw_varint32(data_size as u32)?; self.write_repeated_packed_enum_or_unknown_no_tag(values)?; Ok(()) } /// Write `message` field pub fn write_message( &mut self, field_number: u32, msg: &M, ) -> crate::Result<()> { self.write_tag(field_number, WireType::LengthDelimited)?; self.write_message_no_tag(msg)?; Ok(()) } /// Write dynamic `message` field pub fn write_message_dyn( &mut self, field_number: u32, msg: &dyn MessageDyn, ) -> crate::Result<()> { self.write_tag(field_number, WireType::LengthDelimited)?; self.write_message_no_tag_dyn(msg)?; Ok(()) } } impl<'a> Write for CodedOutputStream<'a> { fn write(&mut self, buf: &[u8]) -> io::Result { self.write_raw_bytes(buf)?; Ok(buf.len()) } fn flush(&mut self) -> io::Result<()> { CodedOutputStream::flush(self).map_err(Into::into) } } impl<'a> Drop for CodedOutputStream<'a> { fn drop(&mut self) { // User must call `flush` to guarantee that the data is written. // Rust should have a lint to enforce `flush` call before drop. let _ignore = CodedOutputStream::flush(self); } } #[cfg(test)] mod test { use std::iter; use super::*; use crate::hex::decode_hex; use crate::hex::encode_hex; fn test_write(expected: &str, mut gen: F) where F: FnMut(&mut CodedOutputStream) -> crate::Result<()>, { let expected_bytes = decode_hex(expected); // write to Write { let mut v = Vec::new(); { let mut os = CodedOutputStream::new(&mut v as &mut dyn Write); gen(&mut os).unwrap(); os.flush().unwrap(); } assert_eq!(encode_hex(&expected_bytes), encode_hex(&v)); } // write to &[u8] { let mut r = Vec::with_capacity(expected_bytes.len()); r.resize(expected_bytes.len(), 0); { let mut os = CodedOutputStream::bytes(&mut r); gen(&mut os).unwrap(); os.check_eof(); } assert_eq!(encode_hex(&expected_bytes), encode_hex(&r)); } // write to Vec { let mut r = Vec::new(); r.extend(&[11, 22, 33, 44, 55, 66, 77]); { let mut os = CodedOutputStream::vec(&mut r); gen(&mut os).unwrap(); os.flush().unwrap(); } r.drain(..7); assert_eq!(encode_hex(&expected_bytes), encode_hex(&r)); } } #[test] fn test_output_stream_write_raw_byte() { test_write("a1", |os| os.write_raw_byte(0xa1)); } #[test] fn test_output_stream_write_tag() { test_write("08", |os| os.write_tag(1, WireType::Varint)); } #[test] #[cfg_attr(miri, ignore)] // Miri is too slow for this test. fn test_output_stream_write_raw_bytes() { test_write("00 ab", |os| os.write_raw_bytes(&[0x00, 0xab])); let expected = iter::repeat("01 02 03 04") .take(2048) .collect::>() .join(" "); test_write(&expected, |os| { for _ in 0..2048 { os.write_raw_bytes(&[0x01, 0x02, 0x03, 0x04])?; } Ok(()) }); } #[test] fn test_output_stream_write_raw_varint32() { test_write("96 01", |os| os.write_raw_varint32(150)); test_write("ff ff ff ff 0f", |os| os.write_raw_varint32(0xffffffff)); } #[test] fn test_output_stream_write_raw_varint64() { test_write("96 01", |os| os.write_raw_varint64(150)); test_write("ff ff ff ff ff ff ff ff ff 01", |os| { os.write_raw_varint64(0xffffffffffffffff) }); } #[test] fn test_output_stream_write_int32_no_tag() { test_write("ff ff ff ff ff ff ff ff ff 01", |os| { os.write_int32_no_tag(-1) }); } #[test] fn test_output_stream_write_int64_no_tag() { test_write("ff ff ff ff ff ff ff ff ff 01", |os| { os.write_int64_no_tag(-1) }); } #[test] fn test_output_stream_write_raw_little_endian32() { test_write("f1 e2 d3 c4", |os| os.write_raw_little_endian32(0xc4d3e2f1)); } #[test] fn test_output_stream_write_float_no_tag() { test_write("95 73 13 61", |os| os.write_float_no_tag(17e19)); } #[test] fn test_output_stream_write_double_no_tag() { test_write("40 d5 ab 68 b3 07 3d 46", |os| { os.write_double_no_tag(23e29) }); } #[test] fn test_output_stream_write_raw_little_endian64() { test_write("f1 e2 d3 c4 b5 a6 07 f8", |os| { os.write_raw_little_endian64(0xf807a6b5c4d3e2f1) }); } #[test] fn test_output_stream_io_write() { let expected = [0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77]; // write to Write { let mut v = Vec::new(); { let mut os = CodedOutputStream::new(&mut v as &mut dyn Write); Write::write(&mut os, &expected).expect("io::Write::write"); Write::flush(&mut os).expect("io::Write::flush"); } assert_eq!(expected, *v); } // write to &[u8] { let mut v = Vec::with_capacity(expected.len()); v.resize(expected.len(), 0); { let mut os = CodedOutputStream::bytes(&mut v); Write::write(&mut os, &expected).expect("io::Write::write"); Write::flush(&mut os).expect("io::Write::flush"); os.check_eof(); } assert_eq!(expected, *v); } // write to Vec { let mut v = Vec::new(); { let mut os = CodedOutputStream::vec(&mut v); Write::write(&mut os, &expected).expect("io::Write::write"); Write::flush(&mut os).expect("io::Write::flush"); } assert_eq!(expected, *v); } } #[test] fn flush_for_vec_does_not_allocate_more() { let mut v = Vec::with_capacity(10); { let mut os = CodedOutputStream::vec(&mut v); for i in 0..10 { os.write_raw_byte(i as u8).unwrap(); } os.flush().unwrap(); } assert_eq!(10, v.len()); // Previously, this allocated more data in buf. assert_eq!(10, v.capacity()); } #[test] fn total_bytes_written_to_bytes() { let mut buf = vec![0; 10]; let mut stream = CodedOutputStream::bytes(&mut buf); assert_eq!(0, stream.total_bytes_written()); stream.write_raw_bytes(&[11, 22]).unwrap(); assert_eq!(2, stream.total_bytes_written()); stream.write_raw_bytes(&[33, 44, 55]).unwrap(); assert_eq!(5, stream.total_bytes_written()); } #[test] fn total_bytes_written_to_vec() { let mut buf = Vec::new(); let mut stream = CodedOutputStream::vec(&mut buf); for i in 0..100 { stream.write_raw_bytes(&[0, 1, 2]).unwrap(); assert_eq!((i + 1) * 3, stream.total_bytes_written()); } } #[test] #[cfg_attr(miri, ignore)] // Miri is too slow for this test. fn total_bytes_written_updated_when_writing_lots_of_bytes() { let data = "ff".repeat(10000); let bytes = decode_hex(&data); test_write(&data, |os| { os.write_raw_bytes(&bytes)?; assert_eq!(os.total_bytes_written(), 10000); Ok(()) }); } } protobuf-3.7.2/src/coded_output_stream/output_target.rs000064400000000000000000000022201046102023000216050ustar 00000000000000use std::fmt; use std::io::Write; /// Output buffer/writer for `CodedOutputStream`. pub(crate) enum OutputTarget<'a> { Write(&'a mut dyn Write, Vec), Vec(&'a mut Vec), /// 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, } impl<'a> fmt::Debug for OutputTarget<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { OutputTarget::Write(_w, vec) => f .debug_struct("Write") .field("buf_len", &vec.len()) .field("buf_cap", &vec.capacity()) .finish_non_exhaustive(), OutputTarget::Vec(vec) => f .debug_struct("Vec") .field("len", &vec.len()) .field("cap", &vec.capacity()) .finish_non_exhaustive(), OutputTarget::Bytes => f.debug_tuple("Bytes").finish(), } } } protobuf-3.7.2/src/coded_output_stream/with.rs000064400000000000000000000016211046102023000176560ustar 00000000000000use std::io::Write; use crate::CodedOutputStream; pub(crate) trait WithCodedOutputStream { fn with_coded_output_stream(self, cb: F) -> crate::Result where F: FnOnce(&mut CodedOutputStream) -> crate::Result; } impl<'a> WithCodedOutputStream for &'a mut (dyn Write + 'a) { fn with_coded_output_stream(self, cb: F) -> crate::Result where F: FnOnce(&mut CodedOutputStream) -> crate::Result, { let mut os = CodedOutputStream::new(self); let r = cb(&mut os)?; os.flush()?; Ok(r) } } impl<'a> WithCodedOutputStream for &'a mut Vec { fn with_coded_output_stream(mut self, cb: F) -> crate::Result where F: FnOnce(&mut CodedOutputStream) -> crate::Result, { let mut os = CodedOutputStream::vec(&mut self); let r = cb(&mut os)?; os.flush()?; Ok(r) } } protobuf-3.7.2/src/descriptor.rs000064400000000000000000014620251046102023000150220ustar 00000000000000// This file is generated by rust-protobuf 4.0.0-alpha.0. Do not edit // .proto file is parsed by protoc --rs_out=... // @generated // https://github.com/rust-lang/rust-clippy/issues/702 #![allow(unknown_lints)] #![allow(clippy::all)] #![allow(unused_attributes)] #![cfg_attr(rustfmt, rustfmt::skip)] #![allow(dead_code)] #![allow(missing_docs)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(non_upper_case_globals)] #![allow(trivial_casts)] #![allow(unused_results)] #![allow(unused_mut)] //! Generated file from `google/protobuf/descriptor.proto` /// The protocol compiler can output a FileDescriptorSet containing the .proto /// files it parses. // @@protoc_insertion_point(message:google.protobuf.FileDescriptorSet) #[derive(PartialEq,Clone,Default,Debug)] pub struct FileDescriptorSet { // message fields // @@protoc_insertion_point(field:google.protobuf.FileDescriptorSet.file) pub file: ::std::vec::Vec, // special fields // @@protoc_insertion_point(special_field:google.protobuf.FileDescriptorSet.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a FileDescriptorSet { fn default() -> &'a FileDescriptorSet { ::default_instance() } } impl FileDescriptorSet { pub fn new() -> FileDescriptorSet { ::std::default::Default::default() } fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(1); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "file", |m: &FileDescriptorSet| { &m.file }, |m: &mut FileDescriptorSet| { &mut m.file }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "FileDescriptorSet", fields, oneofs, ) } } impl crate::Message for FileDescriptorSet { const NAME: &'static str = "FileDescriptorSet"; fn is_initialized(&self) -> bool { for v in &self.file { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.file.push(is.read_message()?); }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; for value in &self.file { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { for v in &self.file { crate::rt::write_message_field_with_cached_size(1, v, os)?; }; os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> FileDescriptorSet { FileDescriptorSet::new() } fn clear(&mut self) { self.file.clear(); self.special_fields.clear(); } fn default_instance() -> &'static FileDescriptorSet { static instance: FileDescriptorSet = FileDescriptorSet { file: ::std::vec::Vec::new(), special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for FileDescriptorSet { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("FileDescriptorSet").unwrap()).clone() } } impl ::std::fmt::Display for FileDescriptorSet { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for FileDescriptorSet { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } /// Describes a complete .proto file. // @@protoc_insertion_point(message:google.protobuf.FileDescriptorProto) #[derive(PartialEq,Clone,Default,Debug)] pub struct FileDescriptorProto { // message fields // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.name) pub name: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.package) pub package: ::std::option::Option<::std::string::String>, /// Names of files imported by this file. // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.dependency) pub dependency: ::std::vec::Vec<::std::string::String>, /// Indexes of the public imported files in the dependency list above. // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.public_dependency) pub public_dependency: ::std::vec::Vec, /// Indexes of the weak imported files in the dependency list. /// For Google-internal migration only. Do not use. // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.weak_dependency) pub weak_dependency: ::std::vec::Vec, /// All top-level definitions in this file. // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.message_type) pub message_type: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.enum_type) pub enum_type: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.service) pub service: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.extension) pub extension: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.options) pub options: crate::MessageField, /// This field contains optional information about the original source code. /// You may safely remove this entire field without harming runtime /// functionality of the descriptors -- the information is needed only by /// development tools. // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.source_code_info) pub source_code_info: crate::MessageField, /// The syntax of the proto file. /// The supported values are "proto2" and "proto3". // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.syntax) pub syntax: ::std::option::Option<::std::string::String>, // special fields // @@protoc_insertion_point(special_field:google.protobuf.FileDescriptorProto.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a FileDescriptorProto { fn default() -> &'a FileDescriptorProto { ::default_instance() } } impl FileDescriptorProto { pub fn new() -> FileDescriptorProto { ::std::default::Default::default() } // optional string name = 1; pub fn name(&self) -> &str { match self.name.as_ref() { Some(v) => v, None => "", } } pub fn clear_name(&mut self) { self.name = ::std::option::Option::None; } pub fn has_name(&self) -> bool { self.name.is_some() } // Param is passed by value, moved pub fn set_name(&mut self, v: ::std::string::String) { self.name = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_name(&mut self) -> &mut ::std::string::String { if self.name.is_none() { self.name = ::std::option::Option::Some(::std::string::String::new()); } self.name.as_mut().unwrap() } // Take field pub fn take_name(&mut self) -> ::std::string::String { self.name.take().unwrap_or_else(|| ::std::string::String::new()) } // optional string package = 2; pub fn package(&self) -> &str { match self.package.as_ref() { Some(v) => v, None => "", } } pub fn clear_package(&mut self) { self.package = ::std::option::Option::None; } pub fn has_package(&self) -> bool { self.package.is_some() } // Param is passed by value, moved pub fn set_package(&mut self, v: ::std::string::String) { self.package = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_package(&mut self) -> &mut ::std::string::String { if self.package.is_none() { self.package = ::std::option::Option::Some(::std::string::String::new()); } self.package.as_mut().unwrap() } // Take field pub fn take_package(&mut self) -> ::std::string::String { self.package.take().unwrap_or_else(|| ::std::string::String::new()) } // optional string syntax = 12; pub fn syntax(&self) -> &str { match self.syntax.as_ref() { Some(v) => v, None => "", } } pub fn clear_syntax(&mut self) { self.syntax = ::std::option::Option::None; } pub fn has_syntax(&self) -> bool { self.syntax.is_some() } // Param is passed by value, moved pub fn set_syntax(&mut self, v: ::std::string::String) { self.syntax = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_syntax(&mut self) -> &mut ::std::string::String { if self.syntax.is_none() { self.syntax = ::std::option::Option::Some(::std::string::String::new()); } self.syntax.as_mut().unwrap() } // Take field pub fn take_syntax(&mut self) -> ::std::string::String { self.syntax.take().unwrap_or_else(|| ::std::string::String::new()) } fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(12); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "name", |m: &FileDescriptorProto| { &m.name }, |m: &mut FileDescriptorProto| { &mut m.name }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "package", |m: &FileDescriptorProto| { &m.package }, |m: &mut FileDescriptorProto| { &mut m.package }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "dependency", |m: &FileDescriptorProto| { &m.dependency }, |m: &mut FileDescriptorProto| { &mut m.dependency }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "public_dependency", |m: &FileDescriptorProto| { &m.public_dependency }, |m: &mut FileDescriptorProto| { &mut m.public_dependency }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "weak_dependency", |m: &FileDescriptorProto| { &m.weak_dependency }, |m: &mut FileDescriptorProto| { &mut m.weak_dependency }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "message_type", |m: &FileDescriptorProto| { &m.message_type }, |m: &mut FileDescriptorProto| { &mut m.message_type }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "enum_type", |m: &FileDescriptorProto| { &m.enum_type }, |m: &mut FileDescriptorProto| { &mut m.enum_type }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "service", |m: &FileDescriptorProto| { &m.service }, |m: &mut FileDescriptorProto| { &mut m.service }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "extension", |m: &FileDescriptorProto| { &m.extension }, |m: &mut FileDescriptorProto| { &mut m.extension }, )); fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, FileOptions>( "options", |m: &FileDescriptorProto| { &m.options }, |m: &mut FileDescriptorProto| { &mut m.options }, )); fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, SourceCodeInfo>( "source_code_info", |m: &FileDescriptorProto| { &m.source_code_info }, |m: &mut FileDescriptorProto| { &mut m.source_code_info }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "syntax", |m: &FileDescriptorProto| { &m.syntax }, |m: &mut FileDescriptorProto| { &mut m.syntax }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "FileDescriptorProto", fields, oneofs, ) } } impl crate::Message for FileDescriptorProto { const NAME: &'static str = "FileDescriptorProto"; fn is_initialized(&self) -> bool { for v in &self.message_type { if !v.is_initialized() { return false; } }; for v in &self.enum_type { if !v.is_initialized() { return false; } }; for v in &self.service { if !v.is_initialized() { return false; } }; for v in &self.extension { if !v.is_initialized() { return false; } }; for v in &self.options { if !v.is_initialized() { return false; } }; for v in &self.source_code_info { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.name = ::std::option::Option::Some(is.read_string()?); }, 18 => { self.package = ::std::option::Option::Some(is.read_string()?); }, 26 => { self.dependency.push(is.read_string()?); }, 82 => { is.read_repeated_packed_int32_into(&mut self.public_dependency)?; }, 80 => { self.public_dependency.push(is.read_int32()?); }, 90 => { is.read_repeated_packed_int32_into(&mut self.weak_dependency)?; }, 88 => { self.weak_dependency.push(is.read_int32()?); }, 34 => { self.message_type.push(is.read_message()?); }, 42 => { self.enum_type.push(is.read_message()?); }, 50 => { self.service.push(is.read_message()?); }, 58 => { self.extension.push(is.read_message()?); }, 66 => { crate::rt::read_singular_message_into_field(is, &mut self.options)?; }, 74 => { crate::rt::read_singular_message_into_field(is, &mut self.source_code_info)?; }, 98 => { self.syntax = ::std::option::Option::Some(is.read_string()?); }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.name.as_ref() { my_size += crate::rt::string_size(1, &v); } if let Some(v) = self.package.as_ref() { my_size += crate::rt::string_size(2, &v); } for value in &self.dependency { my_size += crate::rt::string_size(3, &value); }; for value in &self.public_dependency { my_size += crate::rt::int32_size(10, *value); }; for value in &self.weak_dependency { my_size += crate::rt::int32_size(11, *value); }; for value in &self.message_type { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.enum_type { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.service { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.extension { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; if let Some(v) = self.options.as_ref() { let len = v.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.source_code_info.as_ref() { let len = v.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.syntax.as_ref() { my_size += crate::rt::string_size(12, &v); } my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { if let Some(v) = self.name.as_ref() { os.write_string(1, v)?; } if let Some(v) = self.package.as_ref() { os.write_string(2, v)?; } for v in &self.dependency { os.write_string(3, &v)?; }; for v in &self.public_dependency { os.write_int32(10, *v)?; }; for v in &self.weak_dependency { os.write_int32(11, *v)?; }; for v in &self.message_type { crate::rt::write_message_field_with_cached_size(4, v, os)?; }; for v in &self.enum_type { crate::rt::write_message_field_with_cached_size(5, v, os)?; }; for v in &self.service { crate::rt::write_message_field_with_cached_size(6, v, os)?; }; for v in &self.extension { crate::rt::write_message_field_with_cached_size(7, v, os)?; }; if let Some(v) = self.options.as_ref() { crate::rt::write_message_field_with_cached_size(8, v, os)?; } if let Some(v) = self.source_code_info.as_ref() { crate::rt::write_message_field_with_cached_size(9, v, os)?; } if let Some(v) = self.syntax.as_ref() { os.write_string(12, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> FileDescriptorProto { FileDescriptorProto::new() } fn clear(&mut self) { self.name = ::std::option::Option::None; self.package = ::std::option::Option::None; self.dependency.clear(); self.public_dependency.clear(); self.weak_dependency.clear(); self.message_type.clear(); self.enum_type.clear(); self.service.clear(); self.extension.clear(); self.options.clear(); self.source_code_info.clear(); self.syntax = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static FileDescriptorProto { static instance: FileDescriptorProto = FileDescriptorProto { name: ::std::option::Option::None, package: ::std::option::Option::None, dependency: ::std::vec::Vec::new(), public_dependency: ::std::vec::Vec::new(), weak_dependency: ::std::vec::Vec::new(), message_type: ::std::vec::Vec::new(), enum_type: ::std::vec::Vec::new(), service: ::std::vec::Vec::new(), extension: ::std::vec::Vec::new(), options: crate::MessageField::none(), source_code_info: crate::MessageField::none(), syntax: ::std::option::Option::None, special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for FileDescriptorProto { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("FileDescriptorProto").unwrap()).clone() } } impl ::std::fmt::Display for FileDescriptorProto { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for FileDescriptorProto { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } /// Describes a message type. // @@protoc_insertion_point(message:google.protobuf.DescriptorProto) #[derive(PartialEq,Clone,Default,Debug)] pub struct DescriptorProto { // message fields // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.name) pub name: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.field) pub field: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.extension) pub extension: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.nested_type) pub nested_type: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.enum_type) pub enum_type: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.extension_range) pub extension_range: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.oneof_decl) pub oneof_decl: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.options) pub options: crate::MessageField, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.reserved_range) pub reserved_range: ::std::vec::Vec, /// Reserved field names, which may not be used by fields in the same message. /// A given name may only be reserved once. // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.reserved_name) pub reserved_name: ::std::vec::Vec<::std::string::String>, // special fields // @@protoc_insertion_point(special_field:google.protobuf.DescriptorProto.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a DescriptorProto { fn default() -> &'a DescriptorProto { ::default_instance() } } impl DescriptorProto { pub fn new() -> DescriptorProto { ::std::default::Default::default() } // optional string name = 1; pub fn name(&self) -> &str { match self.name.as_ref() { Some(v) => v, None => "", } } pub fn clear_name(&mut self) { self.name = ::std::option::Option::None; } pub fn has_name(&self) -> bool { self.name.is_some() } // Param is passed by value, moved pub fn set_name(&mut self, v: ::std::string::String) { self.name = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_name(&mut self) -> &mut ::std::string::String { if self.name.is_none() { self.name = ::std::option::Option::Some(::std::string::String::new()); } self.name.as_mut().unwrap() } // Take field pub fn take_name(&mut self) -> ::std::string::String { self.name.take().unwrap_or_else(|| ::std::string::String::new()) } fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(10); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "name", |m: &DescriptorProto| { &m.name }, |m: &mut DescriptorProto| { &mut m.name }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "field", |m: &DescriptorProto| { &m.field }, |m: &mut DescriptorProto| { &mut m.field }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "extension", |m: &DescriptorProto| { &m.extension }, |m: &mut DescriptorProto| { &mut m.extension }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "nested_type", |m: &DescriptorProto| { &m.nested_type }, |m: &mut DescriptorProto| { &mut m.nested_type }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "enum_type", |m: &DescriptorProto| { &m.enum_type }, |m: &mut DescriptorProto| { &mut m.enum_type }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "extension_range", |m: &DescriptorProto| { &m.extension_range }, |m: &mut DescriptorProto| { &mut m.extension_range }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "oneof_decl", |m: &DescriptorProto| { &m.oneof_decl }, |m: &mut DescriptorProto| { &mut m.oneof_decl }, )); fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, MessageOptions>( "options", |m: &DescriptorProto| { &m.options }, |m: &mut DescriptorProto| { &mut m.options }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "reserved_range", |m: &DescriptorProto| { &m.reserved_range }, |m: &mut DescriptorProto| { &mut m.reserved_range }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "reserved_name", |m: &DescriptorProto| { &m.reserved_name }, |m: &mut DescriptorProto| { &mut m.reserved_name }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "DescriptorProto", fields, oneofs, ) } } impl crate::Message for DescriptorProto { const NAME: &'static str = "DescriptorProto"; fn is_initialized(&self) -> bool { for v in &self.field { if !v.is_initialized() { return false; } }; for v in &self.extension { if !v.is_initialized() { return false; } }; for v in &self.nested_type { if !v.is_initialized() { return false; } }; for v in &self.enum_type { if !v.is_initialized() { return false; } }; for v in &self.extension_range { if !v.is_initialized() { return false; } }; for v in &self.oneof_decl { if !v.is_initialized() { return false; } }; for v in &self.options { if !v.is_initialized() { return false; } }; for v in &self.reserved_range { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.name = ::std::option::Option::Some(is.read_string()?); }, 18 => { self.field.push(is.read_message()?); }, 50 => { self.extension.push(is.read_message()?); }, 26 => { self.nested_type.push(is.read_message()?); }, 34 => { self.enum_type.push(is.read_message()?); }, 42 => { self.extension_range.push(is.read_message()?); }, 66 => { self.oneof_decl.push(is.read_message()?); }, 58 => { crate::rt::read_singular_message_into_field(is, &mut self.options)?; }, 74 => { self.reserved_range.push(is.read_message()?); }, 82 => { self.reserved_name.push(is.read_string()?); }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.name.as_ref() { my_size += crate::rt::string_size(1, &v); } for value in &self.field { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.extension { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.nested_type { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.enum_type { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.extension_range { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.oneof_decl { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; if let Some(v) = self.options.as_ref() { let len = v.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; } for value in &self.reserved_range { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.reserved_name { my_size += crate::rt::string_size(10, &value); }; my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { if let Some(v) = self.name.as_ref() { os.write_string(1, v)?; } for v in &self.field { crate::rt::write_message_field_with_cached_size(2, v, os)?; }; for v in &self.extension { crate::rt::write_message_field_with_cached_size(6, v, os)?; }; for v in &self.nested_type { crate::rt::write_message_field_with_cached_size(3, v, os)?; }; for v in &self.enum_type { crate::rt::write_message_field_with_cached_size(4, v, os)?; }; for v in &self.extension_range { crate::rt::write_message_field_with_cached_size(5, v, os)?; }; for v in &self.oneof_decl { crate::rt::write_message_field_with_cached_size(8, v, os)?; }; if let Some(v) = self.options.as_ref() { crate::rt::write_message_field_with_cached_size(7, v, os)?; } for v in &self.reserved_range { crate::rt::write_message_field_with_cached_size(9, v, os)?; }; for v in &self.reserved_name { os.write_string(10, &v)?; }; os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> DescriptorProto { DescriptorProto::new() } fn clear(&mut self) { self.name = ::std::option::Option::None; self.field.clear(); self.extension.clear(); self.nested_type.clear(); self.enum_type.clear(); self.extension_range.clear(); self.oneof_decl.clear(); self.options.clear(); self.reserved_range.clear(); self.reserved_name.clear(); self.special_fields.clear(); } fn default_instance() -> &'static DescriptorProto { static instance: DescriptorProto = DescriptorProto { name: ::std::option::Option::None, field: ::std::vec::Vec::new(), extension: ::std::vec::Vec::new(), nested_type: ::std::vec::Vec::new(), enum_type: ::std::vec::Vec::new(), extension_range: ::std::vec::Vec::new(), oneof_decl: ::std::vec::Vec::new(), options: crate::MessageField::none(), reserved_range: ::std::vec::Vec::new(), reserved_name: ::std::vec::Vec::new(), special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for DescriptorProto { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("DescriptorProto").unwrap()).clone() } } impl ::std::fmt::Display for DescriptorProto { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for DescriptorProto { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } /// Nested message and enums of message `DescriptorProto` pub mod descriptor_proto { // @@protoc_insertion_point(message:google.protobuf.DescriptorProto.ExtensionRange) #[derive(PartialEq,Clone,Default,Debug)] pub struct ExtensionRange { // message fields // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ExtensionRange.start) pub start: ::std::option::Option, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ExtensionRange.end) pub end: ::std::option::Option, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ExtensionRange.options) pub options: crate::MessageField, // special fields // @@protoc_insertion_point(special_field:google.protobuf.DescriptorProto.ExtensionRange.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a ExtensionRange { fn default() -> &'a ExtensionRange { ::default_instance() } } impl ExtensionRange { pub fn new() -> ExtensionRange { ::std::default::Default::default() } // optional int32 start = 1; pub fn start(&self) -> i32 { self.start.unwrap_or(0) } pub fn clear_start(&mut self) { self.start = ::std::option::Option::None; } pub fn has_start(&self) -> bool { self.start.is_some() } // Param is passed by value, moved pub fn set_start(&mut self, v: i32) { self.start = ::std::option::Option::Some(v); } // optional int32 end = 2; pub fn end(&self) -> i32 { self.end.unwrap_or(0) } pub fn clear_end(&mut self) { self.end = ::std::option::Option::None; } pub fn has_end(&self) -> bool { self.end.is_some() } // Param is passed by value, moved pub fn set_end(&mut self, v: i32) { self.end = ::std::option::Option::Some(v); } pub(in super) fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(3); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "start", |m: &ExtensionRange| { &m.start }, |m: &mut ExtensionRange| { &mut m.start }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "end", |m: &ExtensionRange| { &m.end }, |m: &mut ExtensionRange| { &mut m.end }, )); fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, super::ExtensionRangeOptions>( "options", |m: &ExtensionRange| { &m.options }, |m: &mut ExtensionRange| { &mut m.options }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "DescriptorProto.ExtensionRange", fields, oneofs, ) } } impl crate::Message for ExtensionRange { const NAME: &'static str = "ExtensionRange"; fn is_initialized(&self) -> bool { for v in &self.options { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 8 => { self.start = ::std::option::Option::Some(is.read_int32()?); }, 16 => { self.end = ::std::option::Option::Some(is.read_int32()?); }, 26 => { crate::rt::read_singular_message_into_field(is, &mut self.options)?; }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.start { my_size += crate::rt::int32_size(1, v); } if let Some(v) = self.end { my_size += crate::rt::int32_size(2, v); } if let Some(v) = self.options.as_ref() { let len = v.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; } my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { if let Some(v) = self.start { os.write_int32(1, v)?; } if let Some(v) = self.end { os.write_int32(2, v)?; } if let Some(v) = self.options.as_ref() { crate::rt::write_message_field_with_cached_size(3, v, os)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> ExtensionRange { ExtensionRange::new() } fn clear(&mut self) { self.start = ::std::option::Option::None; self.end = ::std::option::Option::None; self.options.clear(); self.special_fields.clear(); } fn default_instance() -> &'static ExtensionRange { static instance: ExtensionRange = ExtensionRange { start: ::std::option::Option::None, end: ::std::option::Option::None, options: crate::MessageField::none(), special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for ExtensionRange { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| super::file_descriptor().message_by_package_relative_name("DescriptorProto.ExtensionRange").unwrap()).clone() } } impl ::std::fmt::Display for ExtensionRange { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for ExtensionRange { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } /// Range of reserved tag numbers. Reserved tag numbers may not be used by /// fields or extension ranges in the same message. Reserved ranges may /// not overlap. // @@protoc_insertion_point(message:google.protobuf.DescriptorProto.ReservedRange) #[derive(PartialEq,Clone,Default,Debug)] pub struct ReservedRange { // message fields // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ReservedRange.start) pub start: ::std::option::Option, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ReservedRange.end) pub end: ::std::option::Option, // special fields // @@protoc_insertion_point(special_field:google.protobuf.DescriptorProto.ReservedRange.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a ReservedRange { fn default() -> &'a ReservedRange { ::default_instance() } } impl ReservedRange { pub fn new() -> ReservedRange { ::std::default::Default::default() } // optional int32 start = 1; pub fn start(&self) -> i32 { self.start.unwrap_or(0) } pub fn clear_start(&mut self) { self.start = ::std::option::Option::None; } pub fn has_start(&self) -> bool { self.start.is_some() } // Param is passed by value, moved pub fn set_start(&mut self, v: i32) { self.start = ::std::option::Option::Some(v); } // optional int32 end = 2; pub fn end(&self) -> i32 { self.end.unwrap_or(0) } pub fn clear_end(&mut self) { self.end = ::std::option::Option::None; } pub fn has_end(&self) -> bool { self.end.is_some() } // Param is passed by value, moved pub fn set_end(&mut self, v: i32) { self.end = ::std::option::Option::Some(v); } pub(in super) fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(2); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "start", |m: &ReservedRange| { &m.start }, |m: &mut ReservedRange| { &mut m.start }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "end", |m: &ReservedRange| { &m.end }, |m: &mut ReservedRange| { &mut m.end }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "DescriptorProto.ReservedRange", fields, oneofs, ) } } impl crate::Message for ReservedRange { const NAME: &'static str = "ReservedRange"; fn is_initialized(&self) -> bool { true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 8 => { self.start = ::std::option::Option::Some(is.read_int32()?); }, 16 => { self.end = ::std::option::Option::Some(is.read_int32()?); }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.start { my_size += crate::rt::int32_size(1, v); } if let Some(v) = self.end { my_size += crate::rt::int32_size(2, v); } my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { if let Some(v) = self.start { os.write_int32(1, v)?; } if let Some(v) = self.end { os.write_int32(2, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> ReservedRange { ReservedRange::new() } fn clear(&mut self) { self.start = ::std::option::Option::None; self.end = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static ReservedRange { static instance: ReservedRange = ReservedRange { start: ::std::option::Option::None, end: ::std::option::Option::None, special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for ReservedRange { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| super::file_descriptor().message_by_package_relative_name("DescriptorProto.ReservedRange").unwrap()).clone() } } impl ::std::fmt::Display for ReservedRange { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for ReservedRange { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } } // @@protoc_insertion_point(message:google.protobuf.ExtensionRangeOptions) #[derive(PartialEq,Clone,Default,Debug)] pub struct ExtensionRangeOptions { // message fields /// The parser stores options it doesn't recognize here. See above. // @@protoc_insertion_point(field:google.protobuf.ExtensionRangeOptions.uninterpreted_option) pub uninterpreted_option: ::std::vec::Vec, // special fields // @@protoc_insertion_point(special_field:google.protobuf.ExtensionRangeOptions.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a ExtensionRangeOptions { fn default() -> &'a ExtensionRangeOptions { ::default_instance() } } impl ExtensionRangeOptions { pub fn new() -> ExtensionRangeOptions { ::std::default::Default::default() } fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(1); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "uninterpreted_option", |m: &ExtensionRangeOptions| { &m.uninterpreted_option }, |m: &mut ExtensionRangeOptions| { &mut m.uninterpreted_option }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "ExtensionRangeOptions", fields, oneofs, ) } } impl crate::Message for ExtensionRangeOptions { const NAME: &'static str = "ExtensionRangeOptions"; fn is_initialized(&self) -> bool { for v in &self.uninterpreted_option { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 7994 => { self.uninterpreted_option.push(is.read_message()?); }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; for value in &self.uninterpreted_option { let len = value.compute_size(); my_size += 2 + crate::rt::compute_raw_varint64_size(len) + len; }; my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { for v in &self.uninterpreted_option { crate::rt::write_message_field_with_cached_size(999, v, os)?; }; os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> ExtensionRangeOptions { ExtensionRangeOptions::new() } fn clear(&mut self) { self.uninterpreted_option.clear(); self.special_fields.clear(); } fn default_instance() -> &'static ExtensionRangeOptions { static instance: ExtensionRangeOptions = ExtensionRangeOptions { uninterpreted_option: ::std::vec::Vec::new(), special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for ExtensionRangeOptions { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("ExtensionRangeOptions").unwrap()).clone() } } impl ::std::fmt::Display for ExtensionRangeOptions { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for ExtensionRangeOptions { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } /// Describes a field within a message. // @@protoc_insertion_point(message:google.protobuf.FieldDescriptorProto) #[derive(PartialEq,Clone,Default,Debug)] pub struct FieldDescriptorProto { // message fields // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.name) pub name: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.number) pub number: ::std::option::Option, // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.label) pub label: ::std::option::Option>, /// If type_name is set, this need not be set. If both this and type_name /// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.type) pub type_: ::std::option::Option>, /// For message and enum types, this is the name of the type. If the name /// starts with a '.', it is fully-qualified. Otherwise, C++-like scoping /// rules are used to find the type (i.e. first the nested types within this /// message are searched, then within the parent, on up to the root /// namespace). // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.type_name) pub type_name: ::std::option::Option<::std::string::String>, /// For extensions, this is the name of the type being extended. It is /// resolved in the same manner as type_name. // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.extendee) pub extendee: ::std::option::Option<::std::string::String>, /// For numeric types, contains the original text representation of the value. /// For booleans, "true" or "false". /// For strings, contains the default text contents (not escaped in any way). /// For bytes, contains the C escaped value. All bytes >= 128 are escaped. /// TODO(kenton): Base-64 encode? // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.default_value) pub default_value: ::std::option::Option<::std::string::String>, /// If set, gives the index of a oneof in the containing type's oneof_decl /// list. This field is a member of that oneof. // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.oneof_index) pub oneof_index: ::std::option::Option, /// JSON name of this field. The value is set by protocol compiler. If the /// user has set a "json_name" option on this field, that option's value /// will be used. Otherwise, it's deduced from the field's name by converting /// it to camelCase. // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.json_name) pub json_name: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.options) pub options: crate::MessageField, /// If true, this is a proto3 "optional". When a proto3 field is optional, it /// tracks presence regardless of field type. /// /// When proto3_optional is true, this field must be belong to a oneof to /// signal to old proto3 clients that presence is tracked for this field. This /// oneof is known as a "synthetic" oneof, and this field must be its sole /// member (each proto3 optional field gets its own synthetic oneof). Synthetic /// oneofs exist in the descriptor only, and do not generate any API. Synthetic /// oneofs must be ordered after all "real" oneofs. /// /// For message fields, proto3_optional doesn't create any semantic change, /// since non-repeated message fields always track presence. However it still /// indicates the semantic detail of whether the user wrote "optional" or not. /// This can be useful for round-tripping the .proto file. For consistency we /// give message fields a synthetic oneof also, even though it is not required /// to track presence. This is especially important because the parser can't /// tell if a field is a message or an enum, so it must always create a /// synthetic oneof. /// /// Proto2 optional fields do not set this flag, because they already indicate /// optional with `LABEL_OPTIONAL`. // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.proto3_optional) pub proto3_optional: ::std::option::Option, // special fields // @@protoc_insertion_point(special_field:google.protobuf.FieldDescriptorProto.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a FieldDescriptorProto { fn default() -> &'a FieldDescriptorProto { ::default_instance() } } impl FieldDescriptorProto { pub fn new() -> FieldDescriptorProto { ::std::default::Default::default() } // optional string name = 1; pub fn name(&self) -> &str { match self.name.as_ref() { Some(v) => v, None => "", } } pub fn clear_name(&mut self) { self.name = ::std::option::Option::None; } pub fn has_name(&self) -> bool { self.name.is_some() } // Param is passed by value, moved pub fn set_name(&mut self, v: ::std::string::String) { self.name = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_name(&mut self) -> &mut ::std::string::String { if self.name.is_none() { self.name = ::std::option::Option::Some(::std::string::String::new()); } self.name.as_mut().unwrap() } // Take field pub fn take_name(&mut self) -> ::std::string::String { self.name.take().unwrap_or_else(|| ::std::string::String::new()) } // optional int32 number = 3; pub fn number(&self) -> i32 { self.number.unwrap_or(0) } pub fn clear_number(&mut self) { self.number = ::std::option::Option::None; } pub fn has_number(&self) -> bool { self.number.is_some() } // Param is passed by value, moved pub fn set_number(&mut self, v: i32) { self.number = ::std::option::Option::Some(v); } // optional .google.protobuf.FieldDescriptorProto.Label label = 4; pub fn label(&self) -> field_descriptor_proto::Label { match self.label { Some(e) => e.enum_value_or(field_descriptor_proto::Label::LABEL_OPTIONAL), None => field_descriptor_proto::Label::LABEL_OPTIONAL, } } pub fn clear_label(&mut self) { self.label = ::std::option::Option::None; } pub fn has_label(&self) -> bool { self.label.is_some() } // Param is passed by value, moved pub fn set_label(&mut self, v: field_descriptor_proto::Label) { self.label = ::std::option::Option::Some(crate::EnumOrUnknown::new(v)); } // optional .google.protobuf.FieldDescriptorProto.Type type = 5; pub fn type_(&self) -> field_descriptor_proto::Type { match self.type_ { Some(e) => e.enum_value_or(field_descriptor_proto::Type::TYPE_DOUBLE), None => field_descriptor_proto::Type::TYPE_DOUBLE, } } pub fn clear_type_(&mut self) { self.type_ = ::std::option::Option::None; } pub fn has_type(&self) -> bool { self.type_.is_some() } // Param is passed by value, moved pub fn set_type(&mut self, v: field_descriptor_proto::Type) { self.type_ = ::std::option::Option::Some(crate::EnumOrUnknown::new(v)); } // optional string type_name = 6; pub fn type_name(&self) -> &str { match self.type_name.as_ref() { Some(v) => v, None => "", } } pub fn clear_type_name(&mut self) { self.type_name = ::std::option::Option::None; } pub fn has_type_name(&self) -> bool { self.type_name.is_some() } // Param is passed by value, moved pub fn set_type_name(&mut self, v: ::std::string::String) { self.type_name = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_type_name(&mut self) -> &mut ::std::string::String { if self.type_name.is_none() { self.type_name = ::std::option::Option::Some(::std::string::String::new()); } self.type_name.as_mut().unwrap() } // Take field pub fn take_type_name(&mut self) -> ::std::string::String { self.type_name.take().unwrap_or_else(|| ::std::string::String::new()) } // optional string extendee = 2; pub fn extendee(&self) -> &str { match self.extendee.as_ref() { Some(v) => v, None => "", } } pub fn clear_extendee(&mut self) { self.extendee = ::std::option::Option::None; } pub fn has_extendee(&self) -> bool { self.extendee.is_some() } // Param is passed by value, moved pub fn set_extendee(&mut self, v: ::std::string::String) { self.extendee = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_extendee(&mut self) -> &mut ::std::string::String { if self.extendee.is_none() { self.extendee = ::std::option::Option::Some(::std::string::String::new()); } self.extendee.as_mut().unwrap() } // Take field pub fn take_extendee(&mut self) -> ::std::string::String { self.extendee.take().unwrap_or_else(|| ::std::string::String::new()) } // optional string default_value = 7; pub fn default_value(&self) -> &str { match self.default_value.as_ref() { Some(v) => v, None => "", } } pub fn clear_default_value(&mut self) { self.default_value = ::std::option::Option::None; } pub fn has_default_value(&self) -> bool { self.default_value.is_some() } // Param is passed by value, moved pub fn set_default_value(&mut self, v: ::std::string::String) { self.default_value = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_default_value(&mut self) -> &mut ::std::string::String { if self.default_value.is_none() { self.default_value = ::std::option::Option::Some(::std::string::String::new()); } self.default_value.as_mut().unwrap() } // Take field pub fn take_default_value(&mut self) -> ::std::string::String { self.default_value.take().unwrap_or_else(|| ::std::string::String::new()) } // optional int32 oneof_index = 9; pub fn oneof_index(&self) -> i32 { self.oneof_index.unwrap_or(0) } pub fn clear_oneof_index(&mut self) { self.oneof_index = ::std::option::Option::None; } pub fn has_oneof_index(&self) -> bool { self.oneof_index.is_some() } // Param is passed by value, moved pub fn set_oneof_index(&mut self, v: i32) { self.oneof_index = ::std::option::Option::Some(v); } // optional string json_name = 10; pub fn json_name(&self) -> &str { match self.json_name.as_ref() { Some(v) => v, None => "", } } pub fn clear_json_name(&mut self) { self.json_name = ::std::option::Option::None; } pub fn has_json_name(&self) -> bool { self.json_name.is_some() } // Param is passed by value, moved pub fn set_json_name(&mut self, v: ::std::string::String) { self.json_name = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_json_name(&mut self) -> &mut ::std::string::String { if self.json_name.is_none() { self.json_name = ::std::option::Option::Some(::std::string::String::new()); } self.json_name.as_mut().unwrap() } // Take field pub fn take_json_name(&mut self) -> ::std::string::String { self.json_name.take().unwrap_or_else(|| ::std::string::String::new()) } // optional bool proto3_optional = 17; pub fn proto3_optional(&self) -> bool { self.proto3_optional.unwrap_or(false) } pub fn clear_proto3_optional(&mut self) { self.proto3_optional = ::std::option::Option::None; } pub fn has_proto3_optional(&self) -> bool { self.proto3_optional.is_some() } // Param is passed by value, moved pub fn set_proto3_optional(&mut self, v: bool) { self.proto3_optional = ::std::option::Option::Some(v); } fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(11); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "name", |m: &FieldDescriptorProto| { &m.name }, |m: &mut FieldDescriptorProto| { &mut m.name }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "number", |m: &FieldDescriptorProto| { &m.number }, |m: &mut FieldDescriptorProto| { &mut m.number }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "label", |m: &FieldDescriptorProto| { &m.label }, |m: &mut FieldDescriptorProto| { &mut m.label }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "type", |m: &FieldDescriptorProto| { &m.type_ }, |m: &mut FieldDescriptorProto| { &mut m.type_ }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "type_name", |m: &FieldDescriptorProto| { &m.type_name }, |m: &mut FieldDescriptorProto| { &mut m.type_name }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "extendee", |m: &FieldDescriptorProto| { &m.extendee }, |m: &mut FieldDescriptorProto| { &mut m.extendee }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "default_value", |m: &FieldDescriptorProto| { &m.default_value }, |m: &mut FieldDescriptorProto| { &mut m.default_value }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "oneof_index", |m: &FieldDescriptorProto| { &m.oneof_index }, |m: &mut FieldDescriptorProto| { &mut m.oneof_index }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "json_name", |m: &FieldDescriptorProto| { &m.json_name }, |m: &mut FieldDescriptorProto| { &mut m.json_name }, )); fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, FieldOptions>( "options", |m: &FieldDescriptorProto| { &m.options }, |m: &mut FieldDescriptorProto| { &mut m.options }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "proto3_optional", |m: &FieldDescriptorProto| { &m.proto3_optional }, |m: &mut FieldDescriptorProto| { &mut m.proto3_optional }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "FieldDescriptorProto", fields, oneofs, ) } } impl crate::Message for FieldDescriptorProto { const NAME: &'static str = "FieldDescriptorProto"; fn is_initialized(&self) -> bool { for v in &self.options { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.name = ::std::option::Option::Some(is.read_string()?); }, 24 => { self.number = ::std::option::Option::Some(is.read_int32()?); }, 32 => { self.label = ::std::option::Option::Some(is.read_enum_or_unknown()?); }, 40 => { self.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?); }, 50 => { self.type_name = ::std::option::Option::Some(is.read_string()?); }, 18 => { self.extendee = ::std::option::Option::Some(is.read_string()?); }, 58 => { self.default_value = ::std::option::Option::Some(is.read_string()?); }, 72 => { self.oneof_index = ::std::option::Option::Some(is.read_int32()?); }, 82 => { self.json_name = ::std::option::Option::Some(is.read_string()?); }, 66 => { crate::rt::read_singular_message_into_field(is, &mut self.options)?; }, 136 => { self.proto3_optional = ::std::option::Option::Some(is.read_bool()?); }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.name.as_ref() { my_size += crate::rt::string_size(1, &v); } if let Some(v) = self.number { my_size += crate::rt::int32_size(3, v); } if let Some(v) = self.label { my_size += crate::rt::int32_size(4, v.value()); } if let Some(v) = self.type_ { my_size += crate::rt::int32_size(5, v.value()); } if let Some(v) = self.type_name.as_ref() { my_size += crate::rt::string_size(6, &v); } if let Some(v) = self.extendee.as_ref() { my_size += crate::rt::string_size(2, &v); } if let Some(v) = self.default_value.as_ref() { my_size += crate::rt::string_size(7, &v); } if let Some(v) = self.oneof_index { my_size += crate::rt::int32_size(9, v); } if let Some(v) = self.json_name.as_ref() { my_size += crate::rt::string_size(10, &v); } if let Some(v) = self.options.as_ref() { let len = v.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.proto3_optional { my_size += 2 + 1; } my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { if let Some(v) = self.name.as_ref() { os.write_string(1, v)?; } if let Some(v) = self.number { os.write_int32(3, v)?; } if let Some(v) = self.label { os.write_enum(4, crate::EnumOrUnknown::value(&v))?; } if let Some(v) = self.type_ { os.write_enum(5, crate::EnumOrUnknown::value(&v))?; } if let Some(v) = self.type_name.as_ref() { os.write_string(6, v)?; } if let Some(v) = self.extendee.as_ref() { os.write_string(2, v)?; } if let Some(v) = self.default_value.as_ref() { os.write_string(7, v)?; } if let Some(v) = self.oneof_index { os.write_int32(9, v)?; } if let Some(v) = self.json_name.as_ref() { os.write_string(10, v)?; } if let Some(v) = self.options.as_ref() { crate::rt::write_message_field_with_cached_size(8, v, os)?; } if let Some(v) = self.proto3_optional { os.write_bool(17, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> FieldDescriptorProto { FieldDescriptorProto::new() } fn clear(&mut self) { self.name = ::std::option::Option::None; self.number = ::std::option::Option::None; self.label = ::std::option::Option::None; self.type_ = ::std::option::Option::None; self.type_name = ::std::option::Option::None; self.extendee = ::std::option::Option::None; self.default_value = ::std::option::Option::None; self.oneof_index = ::std::option::Option::None; self.json_name = ::std::option::Option::None; self.options.clear(); self.proto3_optional = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static FieldDescriptorProto { static instance: FieldDescriptorProto = FieldDescriptorProto { name: ::std::option::Option::None, number: ::std::option::Option::None, label: ::std::option::Option::None, type_: ::std::option::Option::None, type_name: ::std::option::Option::None, extendee: ::std::option::Option::None, default_value: ::std::option::Option::None, oneof_index: ::std::option::Option::None, json_name: ::std::option::Option::None, options: crate::MessageField::none(), proto3_optional: ::std::option::Option::None, special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for FieldDescriptorProto { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("FieldDescriptorProto").unwrap()).clone() } } impl ::std::fmt::Display for FieldDescriptorProto { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for FieldDescriptorProto { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } /// Nested message and enums of message `FieldDescriptorProto` pub mod field_descriptor_proto { #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] // @@protoc_insertion_point(enum:google.protobuf.FieldDescriptorProto.Type) pub enum Type { // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_DOUBLE) TYPE_DOUBLE = 1, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_FLOAT) TYPE_FLOAT = 2, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_INT64) TYPE_INT64 = 3, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_UINT64) TYPE_UINT64 = 4, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_INT32) TYPE_INT32 = 5, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_FIXED64) TYPE_FIXED64 = 6, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_FIXED32) TYPE_FIXED32 = 7, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_BOOL) TYPE_BOOL = 8, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_STRING) TYPE_STRING = 9, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_GROUP) TYPE_GROUP = 10, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_MESSAGE) TYPE_MESSAGE = 11, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_BYTES) TYPE_BYTES = 12, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_UINT32) TYPE_UINT32 = 13, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_ENUM) TYPE_ENUM = 14, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SFIXED32) TYPE_SFIXED32 = 15, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SFIXED64) TYPE_SFIXED64 = 16, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SINT32) TYPE_SINT32 = 17, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SINT64) TYPE_SINT64 = 18, } impl crate::Enum for Type { const NAME: &'static str = "Type"; fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option { match value { 1 => ::std::option::Option::Some(Type::TYPE_DOUBLE), 2 => ::std::option::Option::Some(Type::TYPE_FLOAT), 3 => ::std::option::Option::Some(Type::TYPE_INT64), 4 => ::std::option::Option::Some(Type::TYPE_UINT64), 5 => ::std::option::Option::Some(Type::TYPE_INT32), 6 => ::std::option::Option::Some(Type::TYPE_FIXED64), 7 => ::std::option::Option::Some(Type::TYPE_FIXED32), 8 => ::std::option::Option::Some(Type::TYPE_BOOL), 9 => ::std::option::Option::Some(Type::TYPE_STRING), 10 => ::std::option::Option::Some(Type::TYPE_GROUP), 11 => ::std::option::Option::Some(Type::TYPE_MESSAGE), 12 => ::std::option::Option::Some(Type::TYPE_BYTES), 13 => ::std::option::Option::Some(Type::TYPE_UINT32), 14 => ::std::option::Option::Some(Type::TYPE_ENUM), 15 => ::std::option::Option::Some(Type::TYPE_SFIXED32), 16 => ::std::option::Option::Some(Type::TYPE_SFIXED64), 17 => ::std::option::Option::Some(Type::TYPE_SINT32), 18 => ::std::option::Option::Some(Type::TYPE_SINT64), _ => ::std::option::Option::None } } fn from_str(str: &str) -> ::std::option::Option { match str { "TYPE_DOUBLE" => ::std::option::Option::Some(Type::TYPE_DOUBLE), "TYPE_FLOAT" => ::std::option::Option::Some(Type::TYPE_FLOAT), "TYPE_INT64" => ::std::option::Option::Some(Type::TYPE_INT64), "TYPE_UINT64" => ::std::option::Option::Some(Type::TYPE_UINT64), "TYPE_INT32" => ::std::option::Option::Some(Type::TYPE_INT32), "TYPE_FIXED64" => ::std::option::Option::Some(Type::TYPE_FIXED64), "TYPE_FIXED32" => ::std::option::Option::Some(Type::TYPE_FIXED32), "TYPE_BOOL" => ::std::option::Option::Some(Type::TYPE_BOOL), "TYPE_STRING" => ::std::option::Option::Some(Type::TYPE_STRING), "TYPE_GROUP" => ::std::option::Option::Some(Type::TYPE_GROUP), "TYPE_MESSAGE" => ::std::option::Option::Some(Type::TYPE_MESSAGE), "TYPE_BYTES" => ::std::option::Option::Some(Type::TYPE_BYTES), "TYPE_UINT32" => ::std::option::Option::Some(Type::TYPE_UINT32), "TYPE_ENUM" => ::std::option::Option::Some(Type::TYPE_ENUM), "TYPE_SFIXED32" => ::std::option::Option::Some(Type::TYPE_SFIXED32), "TYPE_SFIXED64" => ::std::option::Option::Some(Type::TYPE_SFIXED64), "TYPE_SINT32" => ::std::option::Option::Some(Type::TYPE_SINT32), "TYPE_SINT64" => ::std::option::Option::Some(Type::TYPE_SINT64), _ => ::std::option::Option::None } } const VALUES: &'static [Type] = &[ Type::TYPE_DOUBLE, Type::TYPE_FLOAT, Type::TYPE_INT64, Type::TYPE_UINT64, Type::TYPE_INT32, Type::TYPE_FIXED64, Type::TYPE_FIXED32, Type::TYPE_BOOL, Type::TYPE_STRING, Type::TYPE_GROUP, Type::TYPE_MESSAGE, Type::TYPE_BYTES, Type::TYPE_UINT32, Type::TYPE_ENUM, Type::TYPE_SFIXED32, Type::TYPE_SFIXED64, Type::TYPE_SINT32, Type::TYPE_SINT64, ]; } impl crate::EnumFull for Type { fn enum_descriptor() -> crate::reflect::EnumDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("FieldDescriptorProto.Type").unwrap()).clone() } fn descriptor(&self) -> crate::reflect::EnumValueDescriptor { let index = match self { Type::TYPE_DOUBLE => 0, Type::TYPE_FLOAT => 1, Type::TYPE_INT64 => 2, Type::TYPE_UINT64 => 3, Type::TYPE_INT32 => 4, Type::TYPE_FIXED64 => 5, Type::TYPE_FIXED32 => 6, Type::TYPE_BOOL => 7, Type::TYPE_STRING => 8, Type::TYPE_GROUP => 9, Type::TYPE_MESSAGE => 10, Type::TYPE_BYTES => 11, Type::TYPE_UINT32 => 12, Type::TYPE_ENUM => 13, Type::TYPE_SFIXED32 => 14, Type::TYPE_SFIXED64 => 15, Type::TYPE_SINT32 => 16, Type::TYPE_SINT64 => 17, }; Self::enum_descriptor().value_by_index(index) } } // Note, `Default` is implemented although default value is not 0 impl ::std::default::Default for Type { fn default() -> Self { Type::TYPE_DOUBLE } } impl Type { pub(in super) fn generated_enum_descriptor_data() -> crate::reflect::GeneratedEnumDescriptorData { crate::reflect::GeneratedEnumDescriptorData::new::("FieldDescriptorProto.Type") } } #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] // @@protoc_insertion_point(enum:google.protobuf.FieldDescriptorProto.Label) pub enum Label { // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Label.LABEL_OPTIONAL) LABEL_OPTIONAL = 1, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Label.LABEL_REQUIRED) LABEL_REQUIRED = 2, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Label.LABEL_REPEATED) LABEL_REPEATED = 3, } impl crate::Enum for Label { const NAME: &'static str = "Label"; fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option