diff options
65 files changed, 29137 insertions, 0 deletions
diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json new file mode 100644 index 0000000..d6337d5 --- /dev/null +++ b/.cargo_vcs_info.json @@ -0,0 +1,5 @@ +{ + "git": { + "sha1": "09cb48471825c36fc5c8205f197eefbf664a10f7" + } +} diff --git a/Android.bp b/Android.bp new file mode 100644 index 0000000..e5bd1fa --- /dev/null +++ b/Android.bp @@ -0,0 +1,17 @@ +// This file is generated by cargo2android.py --run --dependencies --features=bytes. + +rust_library_host_rlib { + name: "libprotobuf", + crate_name: "protobuf", + srcs: ["src/lib.rs"], + edition: "2015", + features: [ + "bytes", + ], + rlibs: [ + "libbytes", + ], +} + +// dependent_library ["feature_list"] +// bytes-0.5.4 "default,std" diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..99a7f79 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,42 @@ +# 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 believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + +[package] +name = "protobuf" +version = "2.14.0" +authors = ["Stepan Koltsov <stepan.koltsov@gmail.com>"] +description = "Rust implementation of Google protocol buffers\n" +homepage = "https://github.com/stepancheg/rust-protobuf/" +documentation = "https://github.com/stepancheg/rust-protobuf/blob/master/README.md" +license = "MIT" +repository = "https://github.com/stepancheg/rust-protobuf/" +[package.metadata.docs.rs] +all-features = true + +[lib] +doctest = false +bench = false +[dependencies.bytes] +version = "0.5" +optional = true + +[dependencies.serde] +version = "1.0" +optional = true + +[dependencies.serde_derive] +version = "1.0" +optional = true + +[features] +with-bytes = ["bytes"] +with-serde = ["serde", "serde_derive"] diff --git a/Cargo.toml.orig b/Cargo.toml.orig new file mode 100644 index 0000000..8f3b2b8 --- /dev/null +++ b/Cargo.toml.orig @@ -0,0 +1,28 @@ +[package] + +name = "protobuf" +version = "2.14.0" +authors = ["Stepan Koltsov <stepan.koltsov@gmail.com>"] +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] +doctest = false +bench = false + +[features] +with-bytes = ["bytes"] +with-serde = ["serde", "serde_derive"] + +[dependencies] +bytes = { version = "0.5", optional = true } +serde = { version = "1.0", optional = true } +serde_derive = { version = "1.0", optional = true } + +[package.metadata.docs.rs] +all-features = true @@ -0,0 +1 @@ +LICENSE.txt
\ No newline at end of file diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..acce639 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,19 @@ +Copyright (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.
\ No newline at end of file diff --git a/METADATA b/METADATA new file mode 100644 index 0000000..50ef5ab --- /dev/null +++ b/METADATA @@ -0,0 +1,19 @@ +name: "protobuf" +description: "Rust implementation of Google protocol buffers" +third_party { + url { + type: HOMEPAGE + value: "https://crates.io/crates/protobuf" + } + url { + type: GIT + value: "https://github.com/stepancheg/rust-protobuf" + } + version: "2.14.0" + license_type: NOTICE + last_upgrade_date { + year: 2020 + month: 6 + day: 3 + } +} diff --git a/MODULE_LICENSE_BSD_LIKE b/MODULE_LICENSE_BSD_LIKE new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/MODULE_LICENSE_BSD_LIKE @@ -0,0 +1 @@ +LICENSE
\ No newline at end of file @@ -0,0 +1 @@ +include platform/prebuilts/rust:/OWNERS diff --git a/README.md b/README.md new file mode 100644 index 0000000..c16838b --- /dev/null +++ b/README.md @@ -0,0 +1,6 @@ +## How to develop rust-protobuf itself + +`cargo test --all` to build everything. + +If code generator is changed, code needs to be regenerated, see +`regenerate.sh`. diff --git a/benches/coded_input_stream.rs b/benches/coded_input_stream.rs new file mode 100644 index 0000000..ad78115 --- /dev/null +++ b/benches/coded_input_stream.rs @@ -0,0 +1,104 @@ +// `cargo test --benches` and `#[feature(test)]` work only in nightly +#![cfg(rustc_nightly)] +#![feature(test)] + +extern crate protobuf; +extern crate test; + +use std::io; +use std::io::Read; + +use protobuf::stream::CodedInputStream; + +use self::test::Bencher; + +fn make_bytes(len: usize) -> Vec<u8> { + let mut r = Vec::with_capacity(len); + for i in 0..len { + r.push((i % 10) as u8); + } + test::black_box(r) +} + +#[bench] +fn read_byte(b: &mut Bencher) { + let v = make_bytes(1_000); + b.iter(|| { + let mut is = CodedInputStream::from_bytes(test::black_box(&v)); + while !is.eof().expect("eof") { + test::black_box(is.read_raw_byte().expect("read")); + } + }); +} + +#[bench] +fn read_byte_no_eof(b: &mut Bencher) { + let v = make_bytes(1_000); + b.iter(|| { + let mut is = CodedInputStream::from_bytes(test::black_box(&v)); + for _ in 0..v.len() { + test::black_box(is.read_raw_byte().expect("read")); + } + assert!(is.eof().expect("eof")); + }); +} + +#[bench] +fn read_byte_from_vec(b: &mut Bencher) { + let v = make_bytes(1_000); + b.iter(|| { + let mut v = io::Cursor::new(test::black_box(&v)); + loop { + let mut buf = [0]; + let count = v.read(&mut buf).expect("read"); + if count == 0 { + break; + } + test::black_box(buf); + } + }); +} + +#[bench] +fn read_varint_12(b: &mut Bencher) { + let mut v = Vec::new(); + { + let mut v = protobuf::CodedOutputStream::vec(&mut v); + for i in 0..1000 { + // one or two byte varints + v.write_raw_varint32((i * 7919) % (1 << 14)).expect("write"); + } + v.flush().expect("flush"); + } + b.iter(|| { + let mut is = CodedInputStream::from_bytes(test::black_box(&v)); + let mut count = 0; + while !is.eof().expect("eof") { + test::black_box(is.read_raw_varint32().expect("read")); + count += 1; + } + assert_eq!(1000, count); + }) +} + +#[bench] +fn read_varint_1(b: &mut Bencher) { + let mut v = Vec::new(); + { + let mut v = protobuf::CodedOutputStream::vec(&mut v); + for i in 0..1000 { + // one or two byte varints + v.write_raw_varint32((i * 7919) % (1 << 7)).expect("write"); + } + v.flush().expect("flush"); + } + b.iter(|| { + let mut is = CodedInputStream::from_bytes(test::black_box(&v)); + let mut count = 0; + while !is.eof().expect("eof") { + test::black_box(is.read_raw_varint32().expect("read")); + count += 1; + } + assert_eq!(1000, count); + }) +} diff --git a/benches/coded_output_stream.rs b/benches/coded_output_stream.rs new file mode 100644 index 0000000..438e980 --- /dev/null +++ b/benches/coded_output_stream.rs @@ -0,0 +1,50 @@ +// `cargo test --benches` and `#[feature(test)]` work only in nightly +#![cfg(rustc_nightly)] +#![feature(test)] + +extern crate protobuf; +extern crate test; + +use protobuf::stream; + +use self::test::Bencher; + +#[inline] +fn buffer_write_byte(os: &mut stream::CodedOutputStream) { + for i in 0..10 { + os.write_raw_byte(test::black_box(i as u8)).unwrap(); + } + os.flush().unwrap(); +} + +#[inline] +fn buffer_write_bytes(os: &mut stream::CodedOutputStream) { + for _ in 0..10 { + os.write_raw_bytes(test::black_box(b"1234567890")).unwrap(); + } + os.flush().unwrap(); +} + +#[bench] +fn bench_buffer(b: &mut Bencher) { + b.iter(|| { + let mut v = Vec::new(); + { + let mut os = stream::CodedOutputStream::new(&mut v); + buffer_write_byte(&mut os); + } + v + }); +} + +#[bench] +fn bench_buffer_bytes(b: &mut Bencher) { + b.iter(|| { + let mut v = Vec::new(); + { + let mut os = stream::CodedOutputStream::new(&mut v); + buffer_write_bytes(&mut os); + } + v + }); +} diff --git a/build.rs b/build.rs new file mode 100644 index 0000000..b0b1010 --- /dev/null +++ b/build.rs @@ -0,0 +1,76 @@ +use std::env; +use std::fs::File; +use std::io::{Read, Write}; +use std::path::{Path, PathBuf}; +use std::process; + +// % rustc +stable --version +// rustc 1.26.0 (a77568041 2018-05-07) +// % rustc +beta --version +// rustc 1.27.0-beta.1 (03fb2f447 2018-05-09) +// % rustc +nightly --version +// rustc 1.27.0-nightly (acd3871ba 2018-05-10) +fn version_is_nightly(version: &str) -> bool { + version.contains("nightly") +} + +fn main() { + let rustc = env::var("RUSTC").expect("RUSTC unset"); + + let mut child = process::Command::new(rustc) + .args(&["--version"]) + .stdin(process::Stdio::null()) + .stdout(process::Stdio::piped()) + .spawn() + .expect("spawn rustc"); + + let mut rustc_version = String::new(); + + child + .stdout + .as_mut() + .expect("stdout") + .read_to_string(&mut rustc_version) + .expect("read_to_string"); + assert!(child.wait().expect("wait").success()); + + if version_is_nightly(&rustc_version) { + println!("cargo:rustc-cfg=rustc_nightly"); + } + + write_version(); +} + +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(); +} diff --git a/out/version.rs b/out/version.rs new file mode 100644 index 0000000..664b318 --- /dev/null +++ b/out/version.rs @@ -0,0 +1,7 @@ +/// protobuf crate version +pub const VERSION: &'static str = "2.14.0"; +/// This symbol is used by codegen +#[doc(hidden)] +pub const VERSION_IDENT: &'static str = "VERSION_2_14_0"; +/// This symbol can be referenced to assert that proper version of crate is used +pub const VERSION_2_14_0: () = (); diff --git a/regenerate.sh b/regenerate.sh new file mode 100755 index 0000000..a1e0dd9 --- /dev/null +++ b/regenerate.sh @@ -0,0 +1,66 @@ +#!/bin/sh -ex + +cd $(dirname $0) + +die() { + echo "$@" >&2 + exit 1 +} + +protoc_ver=$(protoc --version) +case "$protoc_ver" in + "libprotoc 3"*) ;; + *) + die "you need to use protobuf 3 to regenerate .rs from .proto" + ;; +esac + +cargo build --manifest-path=../protobuf-codegen/Cargo.toml + +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-rust="$where_am_i/target/debug/protoc-gen-rust$exe_suffix" \ + --rust_out tmp-generated \ + --rust_opt 'serde_derive=true inside_protobuf=true' \ + -I../proto \ + ../proto/google/protobuf/*.proto \ + ../proto/google/protobuf/compiler/* \ + ../proto/rustproto.proto + +mv tmp-generated/descriptor.rs tmp-generated/plugin.rs tmp-generated/rustproto.rs src/ +mv tmp-generated/*.rs src/well_known_types/ +( + cd src/well_known_types + exec > mod.rs + echo "// This file is generated. Do not edit" + echo '//! Generated code for "well known types"' + echo "//!" + echo "//! [This document](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf) describes these types." + + mod_list() { + ls | grep -v mod.rs | sed -e 's,\.rs$,,' + } + + echo + mod_list | sed -e 's,^,mod ,; s,$,;,' + + echo + mod_list | while read mod; do + echo "pub use self::$mod::*;" + done +) + +# vim: set ts=4 sw=4 et: diff --git a/src/any.rs b/src/any.rs new file mode 100644 index 0000000..31ddd82 --- /dev/null +++ b/src/any.rs @@ -0,0 +1,114 @@ +use crate::parse_from_bytes; +use crate::reflect::MessageDescriptor; +use crate::well_known_types::Any; +use crate::Message; +use crate::ProtobufResult; + +impl Any { + fn type_url(type_url_prefix: &str, descriptor: &MessageDescriptor) -> String { + format!("{}/{}", type_url_prefix, descriptor.full_name()) + } + + fn get_type_name_from_type_url(type_url: &str) -> Option<&str> { + match type_url.rfind('/') { + Some(i) => Some(&type_url[i + 1..]), + None => None, + } + } + + /// Pack any message into `well_known_types::Any` value. + /// + /// # Examples + /// + /// ``` + /// # use protobuf::Message; + /// # use protobuf::ProtobufResult; + /// use protobuf::well_known_types::Any; + /// + /// # fn the_test<MyMessage: Message>(message: &MyMessage) -> ProtobufResult<()> { + /// let message: &MyMessage = message; + /// let any = Any::pack(message)?; + /// assert!(any.is::<MyMessage>()); + /// # Ok(()) + /// # } + /// ``` + pub fn pack<M: Message>(message: &M) -> ProtobufResult<Any> { + Any::pack_dyn(message) + } + + /// Pack any message into `well_known_types::Any` value. + /// + /// # Examples + /// + /// ``` + /// use protobuf::Message; + /// # use protobuf::ProtobufResult; + /// use protobuf::well_known_types::Any; + /// + /// # fn the_test(message: &dyn Message) -> ProtobufResult<()> { + /// let message: &dyn Message = message; + /// let any = Any::pack_dyn(message)?; + /// assert!(any.is_dyn(message.descriptor())); + /// # Ok(()) + /// # } + /// ``` + pub fn pack_dyn(message: &dyn Message) -> ProtobufResult<Any> { + Any::pack_with_type_url_prefix(message, "type.googleapis.com") + } + + fn pack_with_type_url_prefix( + message: &dyn Message, + type_url_prefix: &str, + ) -> ProtobufResult<Any> { + Ok(Any { + type_url: Any::type_url(type_url_prefix, message.descriptor()), + value: message.write_to_bytes()?, + ..Default::default() + }) + } + + /// Check if `Any` contains a message of given type. + pub fn is<M: Message>(&self) -> bool { + self.is_dyn(M::descriptor_static()) + } + + /// Check if `Any` contains a message of given type. + pub fn is_dyn(&self, descriptor: &MessageDescriptor) -> bool { + match Any::get_type_name_from_type_url(&self.type_url) { + Some(type_name) => type_name == descriptor.full_name(), + None => false, + } + } + + /// Extract a message from this `Any`. + /// + /// # Returns + /// + /// * `Ok(None)` when message type mismatch + /// * `Err` when parse failed + pub fn unpack<M: Message>(&self) -> ProtobufResult<Option<M>> { + if !self.is::<M>() { + return Ok(None); + } + Ok(Some(parse_from_bytes(&self.value)?)) + } + + /// Extract a message from this `Any`. + /// + /// # Returns + /// + /// * `Ok(None)` when message type mismatch + /// * `Err` when parse failed + pub fn unpack_dyn( + &self, + descriptor: &MessageDescriptor, + ) -> ProtobufResult<Option<Box<dyn Message>>> { + if !self.is_dyn(descriptor) { + return Ok(None); + } + let mut message = descriptor.new_instance(); + message.merge_from_bytes(&self.value)?; + message.check_initialized()?; + Ok(Some(message)) + } +} diff --git a/src/buf_read_iter.rs b/src/buf_read_iter.rs new file mode 100644 index 0000000..318185d --- /dev/null +++ b/src/buf_read_iter.rs @@ -0,0 +1,516 @@ +use std::cmp; +use std::io::BufRead; +use std::io::BufReader; +use std::io::Read; +use std::mem; +use std::u64; + +#[cfg(feature = "bytes")] +use bytes::BufMut; +#[cfg(feature = "bytes")] +use bytes::Bytes; +#[cfg(feature = "bytes")] +use bytes::BytesMut; + +use error::WireError; +use stream::READ_RAW_BYTES_MAX_ALLOC; +use ProtobufError; +use ProtobufResult; + +use std::mem::MaybeUninit; + +// 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 USE_UNSAFE_FOR_SPEED: bool = true; + +const NO_LIMIT: u64 = u64::MAX; + +/// Hold all possible combinations of input source +enum InputSource<'a> { + BufRead(&'a mut BufRead), + Read(BufReader<&'a mut Read>), + Slice(&'a [u8]), + #[cfg(feature = "bytes")] + Bytes(&'a Bytes), +} + +/// 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`. +pub struct BufReadIter<'a> { + input_source: InputSource<'a>, + buf: &'a [u8], + pos_within_buf: usize, + limit_within_buf: usize, + pos_of_buf_start: u64, + limit: u64, +} + +impl<'a> Drop for BufReadIter<'a> { + fn drop(&mut self) { + match self.input_source { + InputSource::BufRead(ref mut buf_read) => buf_read.consume(self.pos_within_buf), + InputSource::Read(_) => { + // Nothing to flush, because we own BufReader + } + _ => {} + } + } +} + +impl<'ignore> BufReadIter<'ignore> { + pub fn from_read<'a>(read: &'a mut dyn Read) -> BufReadIter<'a> { + BufReadIter { + input_source: InputSource::Read(BufReader::with_capacity( + INPUT_STREAM_BUFFER_SIZE, + read, + )), + buf: &[], + pos_within_buf: 0, + limit_within_buf: 0, + pos_of_buf_start: 0, + limit: NO_LIMIT, + } + } + + pub fn from_buf_read<'a>(buf_read: &'a mut dyn BufRead) -> BufReadIter<'a> { + BufReadIter { + input_source: InputSource::BufRead(buf_read), + buf: &[], + pos_within_buf: 0, + limit_within_buf: 0, + pos_of_buf_start: 0, + limit: NO_LIMIT, + } + } + + pub fn from_byte_slice<'a>(bytes: &'a [u8]) -> BufReadIter<'a> { + BufReadIter { + input_source: InputSource::Slice(bytes), + buf: bytes, + pos_within_buf: 0, + limit_within_buf: bytes.len(), + pos_of_buf_start: 0, + limit: NO_LIMIT, + } + } + + #[cfg(feature = "bytes")] + pub fn from_bytes<'a>(bytes: &'a Bytes) -> BufReadIter<'a> { + BufReadIter { + input_source: InputSource::Bytes(bytes), + buf: &bytes, + pos_within_buf: 0, + limit_within_buf: bytes.len(), + pos_of_buf_start: 0, + limit: NO_LIMIT, + } + } + + #[inline] + fn assertions(&self) { + debug_assert!(self.pos_within_buf <= self.limit_within_buf); + debug_assert!(self.limit_within_buf <= self.buf.len()); + debug_assert!(self.pos_of_buf_start + self.pos_within_buf as u64 <= self.limit); + } + + #[inline(always)] + pub fn pos(&self) -> u64 { + self.pos_of_buf_start + self.pos_within_buf as u64 + } + + /// Recompute `limit_within_buf` after update of `limit` + #[inline] + fn update_limit_within_buf(&mut self) { + if self.pos_of_buf_start + (self.buf.len() as u64) <= self.limit { + self.limit_within_buf = self.buf.len(); + } else { + self.limit_within_buf = (self.limit - self.pos_of_buf_start) as usize; + } + + self.assertions(); + } + + pub fn push_limit(&mut self, limit: u64) -> ProtobufResult<u64> { + let new_limit = match self.pos().checked_add(limit) { + Some(new_limit) => new_limit, + None => return Err(ProtobufError::WireError(WireError::Other)), + }; + + if new_limit > self.limit { + return Err(ProtobufError::WireError(WireError::Other)); + } + + let prev_limit = mem::replace(&mut self.limit, new_limit); + + self.update_limit_within_buf(); + + Ok(prev_limit) + } + + #[inline] + pub fn pop_limit(&mut self, limit: u64) { + assert!(limit >= self.limit); + + self.limit = limit; + + self.update_limit_within_buf(); + } + + #[inline] + pub fn remaining_in_buf(&self) -> &[u8] { + if USE_UNSAFE_FOR_SPEED { + unsafe { + &self + .buf + .get_unchecked(self.pos_within_buf..self.limit_within_buf) + } + } else { + &self.buf[self.pos_within_buf..self.limit_within_buf] + } + } + + #[inline(always)] + pub fn remaining_in_buf_len(&self) -> usize { + self.limit_within_buf - self.pos_within_buf + } + + #[inline(always)] + pub fn bytes_until_limit(&self) -> u64 { + if self.limit == NO_LIMIT { + NO_LIMIT + } else { + self.limit - (self.pos_of_buf_start + self.pos_within_buf as u64) + } + } + + #[inline(always)] + pub fn eof(&mut self) -> ProtobufResult<bool> { + if self.pos_within_buf == self.limit_within_buf { + Ok(self.fill_buf()?.is_empty()) + } else { + Ok(false) + } + } + + #[inline(always)] + pub fn read_byte(&mut self) -> ProtobufResult<u8> { + if self.pos_within_buf == self.limit_within_buf { + self.do_fill_buf()?; + if self.remaining_in_buf_len() == 0 { + return Err(ProtobufError::WireError(WireError::UnexpectedEof)); + } + } + + let r = if USE_UNSAFE_FOR_SPEED { + unsafe { *self.buf.get_unchecked(self.pos_within_buf) } + } else { + self.buf[self.pos_within_buf] + }; + self.pos_within_buf += 1; + Ok(r) + } + + /// Read at most `max` bytes, append to `Vec`. + /// + /// Returns 0 when EOF or limit reached. + fn read_to_vec(&mut self, vec: &mut Vec<u8>, max: usize) -> ProtobufResult<usize> { + let len = { + let rem = self.fill_buf()?; + + let len = cmp::min(rem.len(), max); + vec.extend_from_slice(&rem[..len]); + len + }; + self.pos_within_buf += len; + Ok(len) + } + + /// Read exact number of bytes into `Vec`. + /// + /// `Vec` is cleared in the beginning. + pub fn read_exact_to_vec(&mut self, count: usize, target: &mut Vec<u8>) -> ProtobufResult<()> { + // TODO: also do some limits when reading from unlimited source + if count as u64 > self.bytes_until_limit() { + return Err(ProtobufError::WireError(WireError::TruncatedMessage)); + } + + 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 { + let need_to_read = count - target.len(); + if need_to_read <= target.len() { + target.reserve_exact(need_to_read); + } else { + target.reserve(1); + } + + let max = cmp::min(target.capacity() - target.len(), need_to_read); + let read = self.read_to_vec(target, max)?; + if read == 0 { + return Err(ProtobufError::WireError(WireError::TruncatedMessage)); + } + } + } else { + target.reserve_exact(count); + + unsafe { + self.read_exact(&mut target.get_unchecked_mut(..count))?; + target.set_len(count); + } + } + + debug_assert_eq!(count, target.len()); + + Ok(()) + } + + #[cfg(feature = "bytes")] + pub fn read_exact_bytes(&mut self, len: usize) -> ProtobufResult<Bytes> { + if let InputSource::Bytes(bytes) = self.input_source { + let end = match self.pos_within_buf.checked_add(len) { + Some(end) => end, + None => return Err(ProtobufError::WireError(WireError::UnexpectedEof)), + }; + + if end > self.limit_within_buf { + return Err(ProtobufError::WireError(WireError::UnexpectedEof)); + } + + let r = bytes.slice(self.pos_within_buf..end); + self.pos_within_buf += len; + Ok(r) + } else { + if len >= READ_RAW_BYTES_MAX_ALLOC { + // We cannot trust `len` because protobuf message could be malformed. + // Reading should not result in OOM when allocating a buffer. + let mut v = Vec::new(); + self.read_exact_to_vec(len, &mut v)?; + Ok(Bytes::from(v)) + } else { + let mut r = BytesMut::with_capacity(len); + unsafe { + let buf = Self::slice_get_mut(&mut r.bytes_mut()[..len]); + self.read_exact(buf)?; + r.advance_mut(len); + } + Ok(r.freeze()) + } + } + } + + /// Copy-paste of `MaybeUninit::slice_get_mut` + #[allow(dead_code)] // only used when bytes feature is on + unsafe fn slice_get_mut<T>(slice: &mut [MaybeUninit<T>]) -> &mut [T] { + &mut *(slice as *mut [MaybeUninit<T>] as *mut [T]) + } + + /// Returns 0 when EOF or limit reached. + pub fn read(&mut self, buf: &mut [u8]) -> ProtobufResult<usize> { + self.fill_buf()?; + + let rem = &self.buf[self.pos_within_buf..self.limit_within_buf]; + + let len = cmp::min(rem.len(), buf.len()); + &mut buf[..len].copy_from_slice(&rem[..len]); + self.pos_within_buf += len; + Ok(len) + } + + pub fn read_exact(&mut self, buf: &mut [u8]) -> ProtobufResult<()> { + if self.remaining_in_buf_len() >= buf.len() { + let buf_len = buf.len(); + buf.copy_from_slice(&self.buf[self.pos_within_buf..self.pos_within_buf + buf_len]); + self.pos_within_buf += buf_len; + return Ok(()); + } + + if self.bytes_until_limit() < buf.len() as u64 { + return Err(ProtobufError::WireError(WireError::UnexpectedEof)); + } + + let consume = self.pos_within_buf; + self.pos_of_buf_start += self.pos_within_buf as u64; + self.pos_within_buf = 0; + self.buf = &[]; + self.limit_within_buf = 0; + + match self.input_source { + InputSource::Read(ref mut buf_read) => { + buf_read.consume(consume); + buf_read.read_exact(buf)?; + } + InputSource::BufRead(ref mut buf_read) => { + buf_read.consume(consume); + buf_read.read_exact(buf)?; + } + _ => { + return Err(ProtobufError::WireError(WireError::UnexpectedEof)); + } + } + + self.pos_of_buf_start += buf.len() as u64; + + self.assertions(); + + Ok(()) + } + + fn do_fill_buf(&mut self) -> ProtobufResult<()> { + debug_assert!(self.pos_within_buf == self.limit_within_buf); + + // Limit is reached, do not fill buf, because otherwise + // synchronous read from `CodedInputStream` may block. + if self.limit == self.pos() { + return Ok(()); + } + + let consume = self.buf.len(); + self.pos_of_buf_start += self.buf.len() as u64; + self.buf = &[]; + self.pos_within_buf = 0; + self.limit_within_buf = 0; + + match self.input_source { + InputSource::Read(ref mut buf_read) => { + buf_read.consume(consume); + self.buf = unsafe { mem::transmute(buf_read.fill_buf()?) }; + } + InputSource::BufRead(ref mut buf_read) => { + buf_read.consume(consume); + self.buf = unsafe { mem::transmute(buf_read.fill_buf()?) }; + } + _ => { + return Ok(()); + } + } + + self.update_limit_within_buf(); + + Ok(()) + } + + #[inline(always)] + pub fn fill_buf(&mut self) -> ProtobufResult<&[u8]> { + if self.pos_within_buf == self.limit_within_buf { + self.do_fill_buf()?; + } + + Ok(if USE_UNSAFE_FOR_SPEED { + unsafe { + self.buf + .get_unchecked(self.pos_within_buf..self.limit_within_buf) + } + } else { + &self.buf[self.pos_within_buf..self.limit_within_buf] + }) + } + + #[inline(always)] + pub fn consume(&mut self, amt: usize) { + assert!(amt <= self.limit_within_buf - self.pos_within_buf); + self.pos_within_buf += amt; + } +} + +#[cfg(all(test, feature = "bytes"))] +mod test_bytes { + use super::*; + use std::io::Write; + + fn make_long_string(len: usize) -> Vec<u8> { + let mut s = Vec::new(); + while s.len() < len { + let len = s.len(); + write!(&mut s, "{}", len).expect("unexpected"); + } + s.truncate(len); + s + } + + #[test] + 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] + 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 super::*; + use std::io; + use std::io::BufRead; + use std::io::Read; + + #[test] + fn eof_at_limit() { + struct Read5ThenPanic { + pos: usize, + } + + impl Read for Read5ThenPanic { + fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> { + 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 [1, 2, 3, 4]) + .expect("read_exact"); + assert!(buf_read_iter.eof().expect("eof")); + } +} diff --git a/src/cached_size.rs b/src/cached_size.rs new file mode 100644 index 0000000..350ddac --- /dev/null +++ b/src/cached_size.rs @@ -0,0 +1,38 @@ +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)]`). +#[derive(Debug, Default)] +pub struct CachedSize { + size: AtomicUsize, +} + +impl CachedSize { + /// 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<CachedSize> for CachedSize { + fn eq(&self, _other: &CachedSize) -> bool { + true + } +} + +impl Eq for CachedSize {} diff --git a/src/chars.rs b/src/chars.rs new file mode 100644 index 0000000..bb5a025 --- /dev/null +++ b/src/chars.rs @@ -0,0 +1,96 @@ +use std::fmt; +use std::ops::Deref; +use std::str; + +use bytes::Bytes; + +use clear::Clear; + +/// Thin wrapper around `Bytes` which guarantees that bytes are valid UTF-8 string. +#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct Chars(Bytes); + +impl Chars { + /// New empty object. + pub fn new() -> Chars { + Chars(Bytes::new()) + } + + /// Try convert from `Bytes` + pub fn from_bytes(bytes: Bytes) -> Result<Chars, str::Utf8Error> { + 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<String> for Chars { + fn from(src: String) -> Chars { + Chars(Bytes::from(src)) + } +} + +impl Default for Chars { + fn default() -> Self { + Chars::new() + } +} + +impl Deref for Chars { + type Target = str; + + fn deref(&self) -> &str { + unsafe { str::from_utf8_unchecked(&self.0) } + } +} + +impl Clear for Chars { + fn clear(&mut self) { + self.0.clear(); + } +} + +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] + 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)); + } +} diff --git a/src/clear.rs b/src/clear.rs new file mode 100644 index 0000000..712c492 --- /dev/null +++ b/src/clear.rs @@ -0,0 +1,33 @@ +#[cfg(feature = "bytes")] +use bytes::Bytes; + +/// anything that can be cleared +pub trait Clear { + /// Clear this make, make it equivalent to newly created object. + fn clear(&mut self); +} + +impl<T> Clear for Option<T> { + fn clear(&mut self) { + self.take(); + } +} + +impl Clear for String { + fn clear(&mut self) { + String::clear(self); + } +} + +impl<T> Clear for Vec<T> { + fn clear(&mut self) { + Vec::clear(self); + } +} + +#[cfg(feature = "bytes")] +impl Clear for Bytes { + fn clear(&mut self) { + Bytes::clear(self); + } +} diff --git a/src/compiler_plugin.rs b/src/compiler_plugin.rs new file mode 100644 index 0000000..2a3b1d0 --- /dev/null +++ b/src/compiler_plugin.rs @@ -0,0 +1,53 @@ +// TODO: move into separate crate +#![doc(hidden)] + +use plugin::*; +use protobuf::descriptor::FileDescriptorProto; +use protobuf::parse_from_reader; +use protobuf::Message; +use std::io::stdin; +use std::io::stdout; +use std::str; + +pub struct GenRequest<'a> { + pub file_descriptors: &'a [FileDescriptorProto], + pub files_to_generate: &'a [String], + pub parameter: &'a str, +} + +pub struct GenResult { + pub name: String, + pub content: Vec<u8>, +} + +pub fn plugin_main<F>(gen: F) +where + F: Fn(&[FileDescriptorProto], &[String]) -> Vec<GenResult>, +{ + plugin_main_2(|r| gen(r.file_descriptors, r.files_to_generate)) +} + +pub fn plugin_main_2<F>(gen: F) +where + F: Fn(&GenRequest) -> Vec<GenResult>, +{ + let req = parse_from_reader::<CodeGeneratorRequest>(&mut stdin()).unwrap(); + let result = gen(&GenRequest { + file_descriptors: &req.get_proto_file(), + files_to_generate: &req.get_file_to_generate(), + parameter: req.get_parameter(), + }); + let mut resp = CodeGeneratorResponse::new(); + resp.set_file( + result + .iter() + .map(|file| { + let mut r = CodeGeneratorResponse_File::new(); + r.set_name(file.name.to_string()); + r.set_content(str::from_utf8(file.content.as_ref()).unwrap().to_string()); + r + }) + .collect(), + ); + resp.write_to_writer(&mut stdout()).unwrap(); +} diff --git a/src/core.rs b/src/core.rs new file mode 100644 index 0000000..c577d44 --- /dev/null +++ b/src/core.rs @@ -0,0 +1,268 @@ +use std::any::Any; +use std::any::TypeId; +use std::fmt; +use std::io::Read; +use std::io::Write; + +#[cfg(feature = "bytes")] +use bytes::Bytes; + +use clear::Clear; +use error::ProtobufError; +use error::ProtobufResult; +use reflect::MessageDescriptor; +use stream::with_coded_output_stream_to_bytes; +use stream::CodedInputStream; +use stream::CodedOutputStream; +use stream::WithCodedInputStream; +use stream::WithCodedOutputStream; +use unknown::UnknownFields; + +/// Trait implemented for all generated structs for protobuf messages. +/// +/// Also, generated messages implement `Clone + Default + PartialEq` +pub trait Message: fmt::Debug + Clear + Any + Send + Sync { + /// Message descriptor for this message, used for reflection. + fn descriptor(&self) -> &'static MessageDescriptor; + + /// True iff all required fields are initialized. + /// Always returns `true` for protobuf 3. + fn is_initialized(&self) -> bool; + + /// Update this message object with fields read from given stream. + fn merge_from(&mut self, is: &mut CodedInputStream) -> ProtobufResult<()>; + + /// Write message to the stream. + /// + /// Sizes of this messages and nested messages must be cached + /// by calling `compute_size` prior to this call. + fn write_to_with_cached_sizes(&self, os: &mut CodedOutputStream) -> ProtobufResult<()>; + + /// Compute and cache size of this message and all nested messages + fn compute_size(&self) -> u32; + + /// Get size previously computed by `compute_size`. + fn get_cached_size(&self) -> u32; + + /// Write the message to the stream. + /// + /// Results in error if message is not fully initialized. + fn write_to(&self, os: &mut CodedOutputStream) -> ProtobufResult<()> { + self.check_initialized()?; + + // cache sizes + self.compute_size(); + // TODO: reserve additional + self.write_to_with_cached_sizes(os)?; + + Ok(()) + } + + /// Write the message to the stream prepending the message with message length + /// encoded as varint. + fn write_length_delimited_to(&self, os: &mut CodedOutputStream) -> ProtobufResult<()> { + let size = self.compute_size(); + os.write_raw_varint32(size)?; + self.write_to_with_cached_sizes(os)?; + + // TODO: assert we've written same number of bytes as computed + + Ok(()) + } + + /// Write the message to the vec, prepend the message with message length + /// encoded as varint. + fn write_length_delimited_to_vec(&self, vec: &mut Vec<u8>) -> ProtobufResult<()> { + let mut os = CodedOutputStream::vec(vec); + self.write_length_delimited_to(&mut os)?; + os.flush()?; + Ok(()) + } + + /// Update this message object with fields read from given stream. + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ProtobufResult<()> { + let mut is = CodedInputStream::from_bytes(bytes); + self.merge_from(&mut is) + } + + /// Check if all required fields of this object are initialized. + fn check_initialized(&self) -> ProtobufResult<()> { + if !self.is_initialized() { + Err(ProtobufError::message_not_initialized( + self.descriptor().name(), + )) + } else { + Ok(()) + } + } + + /// Write the message to the writer. + fn write_to_writer(&self, w: &mut Write) -> ProtobufResult<()> { + w.with_coded_output_stream(|os| self.write_to(os)) + } + + /// Write the message to bytes vec. + fn write_to_vec(&self, v: &mut Vec<u8>) -> ProtobufResult<()> { + v.with_coded_output_stream(|os| self.write_to(os)) + } + + /// Write the message to bytes vec. + fn write_to_bytes(&self) -> ProtobufResult<Vec<u8>> { + self.check_initialized()?; + + let size = self.compute_size() as usize; + let mut v = Vec::with_capacity(size); + // skip zerofill + unsafe { + v.set_len(size); + } + { + let mut os = CodedOutputStream::bytes(&mut v); + self.write_to_with_cached_sizes(&mut os)?; + os.check_eof(); + } + Ok(v) + } + + /// Write the message to the writer, prepend the message with message length + /// encoded as varint. + fn write_length_delimited_to_writer(&self, w: &mut Write) -> ProtobufResult<()> { + w.with_coded_output_stream(|os| self.write_length_delimited_to(os)) + } + + /// Write the message to the bytes vec, prepend the message with message length + /// encoded as varint. + fn write_length_delimited_to_bytes(&self) -> ProtobufResult<Vec<u8>> { + with_coded_output_stream_to_bytes(|os| self.write_length_delimited_to(os)) + } + + /// Get a reference to unknown fields. + fn get_unknown_fields<'s>(&'s self) -> &'s UnknownFields; + /// Get a mutable reference to unknown fields. + fn mut_unknown_fields<'s>(&'s mut self) -> &'s mut UnknownFields; + + /// Get type id for downcasting. + fn type_id(&self) -> TypeId { + TypeId::of::<Self>() + } + + /// View self as `Any`. + fn as_any(&self) -> &Any; + + /// View self as mutable `Any`. + fn as_any_mut(&mut self) -> &mut Any { + panic!() + } + + /// Convert boxed self to boxed `Any`. + fn into_any(self: Box<Self>) -> Box<Any> { + panic!() + } + + // Rust does not allow implementation of trait for trait: + // impl<M : Message> fmt::Debug for M { + // ... + // } + + /// Create an empty message object. + /// + /// + /// ``` + /// # use protobuf::Message; + /// # fn foo<MyMessage: Message>() { + /// let m = MyMessage::new(); + /// # } + /// ``` + fn new() -> Self + where + Self: Sized; + + /// Get message descriptor for message type. + /// + /// ``` + /// # use protobuf::Message; + /// # fn foo<MyMessage: Message>() { + /// let descriptor = MyMessage::descriptor_static(); + /// assert_eq!("MyMessage", descriptor.name()); + /// # } + /// ``` + fn descriptor_static() -> &'static MessageDescriptor + where + Self: Sized, + { + panic!( + "descriptor_static is not implemented for message, \ + LITE_RUNTIME must be used" + ); + } + + /// Return a pointer to default immutable message with static lifetime. + /// + /// ``` + /// # use protobuf::Message; + /// # fn foo<MyMessage: Message>() { + /// let m: &MyMessage = MyMessage::default_instance(); + /// # } + /// ``` + fn default_instance() -> &'static Self + where + Self: Sized; +} + +pub fn message_down_cast<'a, M: Message + 'a>(m: &'a Message) -> &'a M { + m.as_any().downcast_ref::<M>().unwrap() +} + +/// Parse message from stream. +pub fn parse_from<M: Message>(is: &mut CodedInputStream) -> ProtobufResult<M> { + let mut r: M = Message::new(); + r.merge_from(is)?; + r.check_initialized()?; + Ok(r) +} + +/// Parse message from reader. +/// Parse stops on EOF or when error encountered. +pub fn parse_from_reader<M: Message>(reader: &mut Read) -> ProtobufResult<M> { + reader.with_coded_input_stream(|is| parse_from::<M>(is)) +} + +/// Parse message from byte array. +pub fn parse_from_bytes<M: Message>(bytes: &[u8]) -> ProtobufResult<M> { + bytes.with_coded_input_stream(|is| parse_from::<M>(is)) +} + +/// Parse message from `Bytes` object. +/// Resulting message may share references to the passed bytes object. +#[cfg(feature = "bytes")] +pub fn parse_from_carllerche_bytes<M: Message>(bytes: &Bytes) -> ProtobufResult<M> { + // Call trait explicitly to avoid accidental construction from `&[u8]` + WithCodedInputStream::with_coded_input_stream(bytes, |is| parse_from::<M>(is)) +} + +/// Parse length-delimited message from stream. +/// +/// Read varint length first, and read messages of that length then. +/// +/// This function is deprecated and will be removed in the next major release. +#[deprecated] +pub fn parse_length_delimited_from<M: Message>(is: &mut CodedInputStream) -> ProtobufResult<M> { + is.read_message::<M>() +} + +/// Parse length-delimited message from `Read`. +/// +/// This function is deprecated and will be removed in the next major release. +#[deprecated] +pub fn parse_length_delimited_from_reader<M: Message>(r: &mut Read) -> ProtobufResult<M> { + // TODO: wrong: we may read length first, and then read exact number of bytes needed + r.with_coded_input_stream(|is| is.read_message::<M>()) +} + +/// Parse length-delimited message from bytes. +/// +/// This function is deprecated and will be removed in the next major release. +#[deprecated] +pub fn parse_length_delimited_from_bytes<M: Message>(bytes: &[u8]) -> ProtobufResult<M> { + bytes.with_coded_input_stream(|is| is.read_message::<M>()) +} diff --git a/src/descriptor.rs b/src/descriptor.rs new file mode 100644 index 0000000..92ca34e --- /dev/null +++ b/src/descriptor.rs @@ -0,0 +1,9852 @@ +// This file is generated by rust-protobuf 2.14.0-pre. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/protobuf/descriptor.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct FileDescriptorSet { + // message fields + file: ::protobuf::RepeatedField<FileDescriptorProto>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a FileDescriptorSet { + fn default() -> &'a FileDescriptorSet { + <FileDescriptorSet as ::protobuf::Message>::default_instance() + } +} + +impl FileDescriptorSet { + pub fn new() -> FileDescriptorSet { + ::std::default::Default::default() + } + + // repeated .google.protobuf.FileDescriptorProto file = 1; + + + pub fn get_file(&self) -> &[FileDescriptorProto] { + &self.file + } + pub fn clear_file(&mut self) { + self.file.clear(); + } + + // Param is passed by value, moved + pub fn set_file(&mut self, v: ::protobuf::RepeatedField<FileDescriptorProto>) { + self.file = v; + } + + // Mutable pointer to the field. + pub fn mut_file(&mut self) -> &mut ::protobuf::RepeatedField<FileDescriptorProto> { + &mut self.file + } + + // Take field + pub fn take_file(&mut self) -> ::protobuf::RepeatedField<FileDescriptorProto> { + ::std::mem::replace(&mut self.file, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for 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 ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.file)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.file { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + for v in &self.file { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> FileDescriptorSet { + FileDescriptorSet::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FileDescriptorProto>>( + "file", + |m: &FileDescriptorSet| { &m.file }, + |m: &mut FileDescriptorSet| { &mut m.file }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<FileDescriptorSet>( + "FileDescriptorSet", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static FileDescriptorSet { + static mut instance: ::protobuf::lazy::Lazy<FileDescriptorSet> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(FileDescriptorSet::new) + } + } +} + +impl ::protobuf::Clear for FileDescriptorSet { + fn clear(&mut self) { + self.file.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for FileDescriptorSet { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for FileDescriptorSet { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct FileDescriptorProto { + // message fields + name: ::protobuf::SingularField<::std::string::String>, + package: ::protobuf::SingularField<::std::string::String>, + dependency: ::protobuf::RepeatedField<::std::string::String>, + public_dependency: ::std::vec::Vec<i32>, + weak_dependency: ::std::vec::Vec<i32>, + message_type: ::protobuf::RepeatedField<DescriptorProto>, + enum_type: ::protobuf::RepeatedField<EnumDescriptorProto>, + service: ::protobuf::RepeatedField<ServiceDescriptorProto>, + extension: ::protobuf::RepeatedField<FieldDescriptorProto>, + options: ::protobuf::SingularPtrField<FileOptions>, + source_code_info: ::protobuf::SingularPtrField<SourceCodeInfo>, + syntax: ::protobuf::SingularField<::std::string::String>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a FileDescriptorProto { + fn default() -> &'a FileDescriptorProto { + <FileDescriptorProto as ::protobuf::Message>::default_instance() + } +} + +impl FileDescriptorProto { + pub fn new() -> FileDescriptorProto { + ::std::default::Default::default() + } + + // optional string name = 1; + + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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 get_package(&self) -> &str { + match self.package.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_package(&mut self) { + self.package.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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()) + } + + // repeated string dependency = 3; + + + pub fn get_dependency(&self) -> &[::std::string::String] { + &self.dependency + } + pub fn clear_dependency(&mut self) { + self.dependency.clear(); + } + + // Param is passed by value, moved + pub fn set_dependency(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.dependency = v; + } + + // Mutable pointer to the field. + pub fn mut_dependency(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.dependency + } + + // Take field + pub fn take_dependency(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.dependency, ::protobuf::RepeatedField::new()) + } + + // repeated int32 public_dependency = 10; + + + pub fn get_public_dependency(&self) -> &[i32] { + &self.public_dependency + } + pub fn clear_public_dependency(&mut self) { + self.public_dependency.clear(); + } + + // Param is passed by value, moved + pub fn set_public_dependency(&mut self, v: ::std::vec::Vec<i32>) { + self.public_dependency = v; + } + + // Mutable pointer to the field. + pub fn mut_public_dependency(&mut self) -> &mut ::std::vec::Vec<i32> { + &mut self.public_dependency + } + + // Take field + pub fn take_public_dependency(&mut self) -> ::std::vec::Vec<i32> { + ::std::mem::replace(&mut self.public_dependency, ::std::vec::Vec::new()) + } + + // repeated int32 weak_dependency = 11; + + + pub fn get_weak_dependency(&self) -> &[i32] { + &self.weak_dependency + } + pub fn clear_weak_dependency(&mut self) { + self.weak_dependency.clear(); + } + + // Param is passed by value, moved + pub fn set_weak_dependency(&mut self, v: ::std::vec::Vec<i32>) { + self.weak_dependency = v; + } + + // Mutable pointer to the field. + pub fn mut_weak_dependency(&mut self) -> &mut ::std::vec::Vec<i32> { + &mut self.weak_dependency + } + + // Take field + pub fn take_weak_dependency(&mut self) -> ::std::vec::Vec<i32> { + ::std::mem::replace(&mut self.weak_dependency, ::std::vec::Vec::new()) + } + + // repeated .google.protobuf.DescriptorProto message_type = 4; + + + pub fn get_message_type(&self) -> &[DescriptorProto] { + &self.message_type + } + pub fn clear_message_type(&mut self) { + self.message_type.clear(); + } + + // Param is passed by value, moved + pub fn set_message_type(&mut self, v: ::protobuf::RepeatedField<DescriptorProto>) { + self.message_type = v; + } + + // Mutable pointer to the field. + pub fn mut_message_type(&mut self) -> &mut ::protobuf::RepeatedField<DescriptorProto> { + &mut self.message_type + } + + // Take field + pub fn take_message_type(&mut self) -> ::protobuf::RepeatedField<DescriptorProto> { + ::std::mem::replace(&mut self.message_type, ::protobuf::RepeatedField::new()) + } + + // repeated .google.protobuf.EnumDescriptorProto enum_type = 5; + + + pub fn get_enum_type(&self) -> &[EnumDescriptorProto] { + &self.enum_type + } + pub fn clear_enum_type(&mut self) { + self.enum_type.clear(); + } + + // Param is passed by value, moved + pub fn set_enum_type(&mut self, v: ::protobuf::RepeatedField<EnumDescriptorProto>) { + self.enum_type = v; + } + + // Mutable pointer to the field. + pub fn mut_enum_type(&mut self) -> &mut ::protobuf::RepeatedField<EnumDescriptorProto> { + &mut self.enum_type + } + + // Take field + pub fn take_enum_type(&mut self) -> ::protobuf::RepeatedField<EnumDescriptorProto> { + ::std::mem::replace(&mut self.enum_type, ::protobuf::RepeatedField::new()) + } + + // repeated .google.protobuf.ServiceDescriptorProto service = 6; + + + pub fn get_service(&self) -> &[ServiceDescriptorProto] { + &self.service + } + pub fn clear_service(&mut self) { + self.service.clear(); + } + + // Param is passed by value, moved + pub fn set_service(&mut self, v: ::protobuf::RepeatedField<ServiceDescriptorProto>) { + self.service = v; + } + + // Mutable pointer to the field. + pub fn mut_service(&mut self) -> &mut ::protobuf::RepeatedField<ServiceDescriptorProto> { + &mut self.service + } + + // Take field + pub fn take_service(&mut self) -> ::protobuf::RepeatedField<ServiceDescriptorProto> { + ::std::mem::replace(&mut self.service, ::protobuf::RepeatedField::new()) + } + + // repeated .google.protobuf.FieldDescriptorProto extension = 7; + + + pub fn get_extension(&self) -> &[FieldDescriptorProto] { + &self.extension + } + pub fn clear_extension(&mut self) { + self.extension.clear(); + } + + // Param is passed by value, moved + pub fn set_extension(&mut self, v: ::protobuf::RepeatedField<FieldDescriptorProto>) { + self.extension = v; + } + + // Mutable pointer to the field. + pub fn mut_extension(&mut self) -> &mut ::protobuf::RepeatedField<FieldDescriptorProto> { + &mut self.extension + } + + // Take field + pub fn take_extension(&mut self) -> ::protobuf::RepeatedField<FieldDescriptorProto> { + ::std::mem::replace(&mut self.extension, ::protobuf::RepeatedField::new()) + } + + // optional .google.protobuf.FileOptions options = 8; + + + pub fn get_options(&self) -> &FileOptions { + self.options.as_ref().unwrap_or_else(|| FileOptions::default_instance()) + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + pub fn has_options(&self) -> bool { + self.options.is_some() + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: FileOptions) { + self.options = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_options(&mut self) -> &mut FileOptions { + if self.options.is_none() { + self.options.set_default(); + } + self.options.as_mut().unwrap() + } + + // Take field + pub fn take_options(&mut self) -> FileOptions { + self.options.take().unwrap_or_else(|| FileOptions::new()) + } + + // optional .google.protobuf.SourceCodeInfo source_code_info = 9; + + + pub fn get_source_code_info(&self) -> &SourceCodeInfo { + self.source_code_info.as_ref().unwrap_or_else(|| SourceCodeInfo::default_instance()) + } + pub fn clear_source_code_info(&mut self) { + self.source_code_info.clear(); + } + + pub fn has_source_code_info(&self) -> bool { + self.source_code_info.is_some() + } + + // Param is passed by value, moved + pub fn set_source_code_info(&mut self, v: SourceCodeInfo) { + self.source_code_info = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_source_code_info(&mut self) -> &mut SourceCodeInfo { + if self.source_code_info.is_none() { + self.source_code_info.set_default(); + } + self.source_code_info.as_mut().unwrap() + } + + // Take field + pub fn take_source_code_info(&mut self) -> SourceCodeInfo { + self.source_code_info.take().unwrap_or_else(|| SourceCodeInfo::new()) + } + + // optional string syntax = 12; + + + pub fn get_syntax(&self) -> &str { + match self.syntax.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_syntax(&mut self) { + self.syntax.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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()) + } +} + +impl ::protobuf::Message for 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 ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.package)?; + }, + 3 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.dependency)?; + }, + 10 => { + ::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.public_dependency)?; + }, + 11 => { + ::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.weak_dependency)?; + }, + 4 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.message_type)?; + }, + 5 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.enum_type)?; + }, + 6 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.service)?; + }, + 7 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.extension)?; + }, + 8 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?; + }, + 9 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.source_code_info)?; + }, + 12 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.syntax)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.name.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(ref v) = self.package.as_ref() { + my_size += ::protobuf::rt::string_size(2, &v); + } + for value in &self.dependency { + my_size += ::protobuf::rt::string_size(3, &value); + }; + for value in &self.public_dependency { + my_size += ::protobuf::rt::value_size(10, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.weak_dependency { + my_size += ::protobuf::rt::value_size(11, *value, ::protobuf::wire_format::WireTypeVarint); + }; + for value in &self.message_type { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.enum_type { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.service { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.extension { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if let Some(ref v) = self.options.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.source_code_info.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(ref v) = self.syntax.as_ref() { + my_size += ::protobuf::rt::string_size(12, &v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.name.as_ref() { + os.write_string(1, &v)?; + } + if let Some(ref 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 { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.enum_type { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.service { + os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.extension { + os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if let Some(ref v) = self.options.as_ref() { + os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.source_code_info.as_ref() { + os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(ref v) = self.syntax.as_ref() { + os.write_string(12, &v)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> FileDescriptorProto { + FileDescriptorProto::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &FileDescriptorProto| { &m.name }, + |m: &mut FileDescriptorProto| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "package", + |m: &FileDescriptorProto| { &m.package }, + |m: &mut FileDescriptorProto| { &mut m.package }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "dependency", + |m: &FileDescriptorProto| { &m.dependency }, + |m: &mut FileDescriptorProto| { &mut m.dependency }, + )); + fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "public_dependency", + |m: &FileDescriptorProto| { &m.public_dependency }, + |m: &mut FileDescriptorProto| { &mut m.public_dependency }, + )); + fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "weak_dependency", + |m: &FileDescriptorProto| { &m.weak_dependency }, + |m: &mut FileDescriptorProto| { &mut m.weak_dependency }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DescriptorProto>>( + "message_type", + |m: &FileDescriptorProto| { &m.message_type }, + |m: &mut FileDescriptorProto| { &mut m.message_type }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EnumDescriptorProto>>( + "enum_type", + |m: &FileDescriptorProto| { &m.enum_type }, + |m: &mut FileDescriptorProto| { &mut m.enum_type }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ServiceDescriptorProto>>( + "service", + |m: &FileDescriptorProto| { &m.service }, + |m: &mut FileDescriptorProto| { &mut m.service }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FieldDescriptorProto>>( + "extension", + |m: &FileDescriptorProto| { &m.extension }, + |m: &mut FileDescriptorProto| { &mut m.extension }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FileOptions>>( + "options", + |m: &FileDescriptorProto| { &m.options }, + |m: &mut FileDescriptorProto| { &mut m.options }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SourceCodeInfo>>( + "source_code_info", + |m: &FileDescriptorProto| { &m.source_code_info }, + |m: &mut FileDescriptorProto| { &mut m.source_code_info }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "syntax", + |m: &FileDescriptorProto| { &m.syntax }, + |m: &mut FileDescriptorProto| { &mut m.syntax }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<FileDescriptorProto>( + "FileDescriptorProto", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static FileDescriptorProto { + static mut instance: ::protobuf::lazy::Lazy<FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(FileDescriptorProto::new) + } + } +} + +impl ::protobuf::Clear for FileDescriptorProto { + fn clear(&mut self) { + self.name.clear(); + self.package.clear(); + 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.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for FileDescriptorProto { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for FileDescriptorProto { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct DescriptorProto { + // message fields + name: ::protobuf::SingularField<::std::string::String>, + field: ::protobuf::RepeatedField<FieldDescriptorProto>, + extension: ::protobuf::RepeatedField<FieldDescriptorProto>, + nested_type: ::protobuf::RepeatedField<DescriptorProto>, + enum_type: ::protobuf::RepeatedField<EnumDescriptorProto>, + extension_range: ::protobuf::RepeatedField<DescriptorProto_ExtensionRange>, + oneof_decl: ::protobuf::RepeatedField<OneofDescriptorProto>, + options: ::protobuf::SingularPtrField<MessageOptions>, + reserved_range: ::protobuf::RepeatedField<DescriptorProto_ReservedRange>, + reserved_name: ::protobuf::RepeatedField<::std::string::String>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DescriptorProto { + fn default() -> &'a DescriptorProto { + <DescriptorProto as ::protobuf::Message>::default_instance() + } +} + +impl DescriptorProto { + pub fn new() -> DescriptorProto { + ::std::default::Default::default() + } + + // optional string name = 1; + + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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()) + } + + // repeated .google.protobuf.FieldDescriptorProto field = 2; + + + pub fn get_field(&self) -> &[FieldDescriptorProto] { + &self.field + } + pub fn clear_field(&mut self) { + self.field.clear(); + } + + // Param is passed by value, moved + pub fn set_field(&mut self, v: ::protobuf::RepeatedField<FieldDescriptorProto>) { + self.field = v; + } + + // Mutable pointer to the field. + pub fn mut_field(&mut self) -> &mut ::protobuf::RepeatedField<FieldDescriptorProto> { + &mut self.field + } + + // Take field + pub fn take_field(&mut self) -> ::protobuf::RepeatedField<FieldDescriptorProto> { + ::std::mem::replace(&mut self.field, ::protobuf::RepeatedField::new()) + } + + // repeated .google.protobuf.FieldDescriptorProto extension = 6; + + + pub fn get_extension(&self) -> &[FieldDescriptorProto] { + &self.extension + } + pub fn clear_extension(&mut self) { + self.extension.clear(); + } + + // Param is passed by value, moved + pub fn set_extension(&mut self, v: ::protobuf::RepeatedField<FieldDescriptorProto>) { + self.extension = v; + } + + // Mutable pointer to the field. + pub fn mut_extension(&mut self) -> &mut ::protobuf::RepeatedField<FieldDescriptorProto> { + &mut self.extension + } + + // Take field + pub fn take_extension(&mut self) -> ::protobuf::RepeatedField<FieldDescriptorProto> { + ::std::mem::replace(&mut self.extension, ::protobuf::RepeatedField::new()) + } + + // repeated .google.protobuf.DescriptorProto nested_type = 3; + + + pub fn get_nested_type(&self) -> &[DescriptorProto] { + &self.nested_type + } + pub fn clear_nested_type(&mut self) { + self.nested_type.clear(); + } + + // Param is passed by value, moved + pub fn set_nested_type(&mut self, v: ::protobuf::RepeatedField<DescriptorProto>) { + self.nested_type = v; + } + + // Mutable pointer to the field. + pub fn mut_nested_type(&mut self) -> &mut ::protobuf::RepeatedField<DescriptorProto> { + &mut self.nested_type + } + + // Take field + pub fn take_nested_type(&mut self) -> ::protobuf::RepeatedField<DescriptorProto> { + ::std::mem::replace(&mut self.nested_type, ::protobuf::RepeatedField::new()) + } + + // repeated .google.protobuf.EnumDescriptorProto enum_type = 4; + + + pub fn get_enum_type(&self) -> &[EnumDescriptorProto] { + &self.enum_type + } + pub fn clear_enum_type(&mut self) { + self.enum_type.clear(); + } + + // Param is passed by value, moved + pub fn set_enum_type(&mut self, v: ::protobuf::RepeatedField<EnumDescriptorProto>) { + self.enum_type = v; + } + + // Mutable pointer to the field. + pub fn mut_enum_type(&mut self) -> &mut ::protobuf::RepeatedField<EnumDescriptorProto> { + &mut self.enum_type + } + + // Take field + pub fn take_enum_type(&mut self) -> ::protobuf::RepeatedField<EnumDescriptorProto> { + ::std::mem::replace(&mut self.enum_type, ::protobuf::RepeatedField::new()) + } + + // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; + + + pub fn get_extension_range(&self) -> &[DescriptorProto_ExtensionRange] { + &self.extension_range + } + pub fn clear_extension_range(&mut self) { + self.extension_range.clear(); + } + + // Param is passed by value, moved + pub fn set_extension_range(&mut self, v: ::protobuf::RepeatedField<DescriptorProto_ExtensionRange>) { + self.extension_range = v; + } + + // Mutable pointer to the field. + pub fn mut_extension_range(&mut self) -> &mut ::protobuf::RepeatedField<DescriptorProto_ExtensionRange> { + &mut self.extension_range + } + + // Take field + pub fn take_extension_range(&mut self) -> ::protobuf::RepeatedField<DescriptorProto_ExtensionRange> { + ::std::mem::replace(&mut self.extension_range, ::protobuf::RepeatedField::new()) + } + + // repeated .google.protobuf.OneofDescriptorProto oneof_decl = 8; + + + pub fn get_oneof_decl(&self) -> &[OneofDescriptorProto] { + &self.oneof_decl + } + pub fn clear_oneof_decl(&mut self) { + self.oneof_decl.clear(); + } + + // Param is passed by value, moved + pub fn set_oneof_decl(&mut self, v: ::protobuf::RepeatedField<OneofDescriptorProto>) { + self.oneof_decl = v; + } + + // Mutable pointer to the field. + pub fn mut_oneof_decl(&mut self) -> &mut ::protobuf::RepeatedField<OneofDescriptorProto> { + &mut self.oneof_decl + } + + // Take field + pub fn take_oneof_decl(&mut self) -> ::protobuf::RepeatedField<OneofDescriptorProto> { + ::std::mem::replace(&mut self.oneof_decl, ::protobuf::RepeatedField::new()) + } + + // optional .google.protobuf.MessageOptions options = 7; + + + pub fn get_options(&self) -> &MessageOptions { + self.options.as_ref().unwrap_or_else(|| MessageOptions::default_instance()) + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + pub fn has_options(&self) -> bool { + self.options.is_some() + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: MessageOptions) { + self.options = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_options(&mut self) -> &mut MessageOptions { + if self.options.is_none() { + self.options.set_default(); + } + self.options.as_mut().unwrap() + } + + // Take field + pub fn take_options(&mut self) -> MessageOptions { + self.options.take().unwrap_or_else(|| MessageOptions::new()) + } + + // repeated .google.protobuf.DescriptorProto.ReservedRange reserved_range = 9; + + + pub fn get_reserved_range(&self) -> &[DescriptorProto_ReservedRange] { + &self.reserved_range + } + pub fn clear_reserved_range(&mut self) { + self.reserved_range.clear(); + } + + // Param is passed by value, moved + pub fn set_reserved_range(&mut self, v: ::protobuf::RepeatedField<DescriptorProto_ReservedRange>) { + self.reserved_range = v; + } + + // Mutable pointer to the field. + pub fn mut_reserved_range(&mut self) -> &mut ::protobuf::RepeatedField<DescriptorProto_ReservedRange> { + &mut self.reserved_range + } + + // Take field + pub fn take_reserved_range(&mut self) -> ::protobuf::RepeatedField<DescriptorProto_ReservedRange> { + ::std::mem::replace(&mut self.reserved_range, ::protobuf::RepeatedField::new()) + } + + // repeated string reserved_name = 10; + + + pub fn get_reserved_name(&self) -> &[::std::string::String] { + &self.reserved_name + } + pub fn clear_reserved_name(&mut self) { + self.reserved_name.clear(); + } + + // Param is passed by value, moved + pub fn set_reserved_name(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.reserved_name = v; + } + + // Mutable pointer to the field. + pub fn mut_reserved_name(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.reserved_name + } + + // Take field + pub fn take_reserved_name(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.reserved_name, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for 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 ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.field)?; + }, + 6 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.extension)?; + }, + 3 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.nested_type)?; + }, + 4 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.enum_type)?; + }, + 5 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.extension_range)?; + }, + 8 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.oneof_decl)?; + }, + 7 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?; + }, + 9 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.reserved_range)?; + }, + 10 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.reserved_name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.name.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + for value in &self.field { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.extension { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.nested_type { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.enum_type { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.extension_range { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.oneof_decl { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if let Some(ref v) = self.options.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + for value in &self.reserved_range { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.reserved_name { + my_size += ::protobuf::rt::string_size(10, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.name.as_ref() { + os.write_string(1, &v)?; + } + for v in &self.field { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.extension { + os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.nested_type { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.enum_type { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.extension_range { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.oneof_decl { + os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if let Some(ref v) = self.options.as_ref() { + os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + for v in &self.reserved_range { + os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.reserved_name { + os.write_string(10, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DescriptorProto { + DescriptorProto::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &DescriptorProto| { &m.name }, + |m: &mut DescriptorProto| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FieldDescriptorProto>>( + "field", + |m: &DescriptorProto| { &m.field }, + |m: &mut DescriptorProto| { &mut m.field }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FieldDescriptorProto>>( + "extension", + |m: &DescriptorProto| { &m.extension }, + |m: &mut DescriptorProto| { &mut m.extension }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DescriptorProto>>( + "nested_type", + |m: &DescriptorProto| { &m.nested_type }, + |m: &mut DescriptorProto| { &mut m.nested_type }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EnumDescriptorProto>>( + "enum_type", + |m: &DescriptorProto| { &m.enum_type }, + |m: &mut DescriptorProto| { &mut m.enum_type }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DescriptorProto_ExtensionRange>>( + "extension_range", + |m: &DescriptorProto| { &m.extension_range }, + |m: &mut DescriptorProto| { &mut m.extension_range }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<OneofDescriptorProto>>( + "oneof_decl", + |m: &DescriptorProto| { &m.oneof_decl }, + |m: &mut DescriptorProto| { &mut m.oneof_decl }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MessageOptions>>( + "options", + |m: &DescriptorProto| { &m.options }, + |m: &mut DescriptorProto| { &mut m.options }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DescriptorProto_ReservedRange>>( + "reserved_range", + |m: &DescriptorProto| { &m.reserved_range }, + |m: &mut DescriptorProto| { &mut m.reserved_range }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "reserved_name", + |m: &DescriptorProto| { &m.reserved_name }, + |m: &mut DescriptorProto| { &mut m.reserved_name }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<DescriptorProto>( + "DescriptorProto", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DescriptorProto { + static mut instance: ::protobuf::lazy::Lazy<DescriptorProto> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(DescriptorProto::new) + } + } +} + +impl ::protobuf::Clear for DescriptorProto { + fn clear(&mut self) { + self.name.clear(); + 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.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DescriptorProto { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DescriptorProto { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct DescriptorProto_ExtensionRange { + // message fields + start: ::std::option::Option<i32>, + end: ::std::option::Option<i32>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DescriptorProto_ExtensionRange { + fn default() -> &'a DescriptorProto_ExtensionRange { + <DescriptorProto_ExtensionRange as ::protobuf::Message>::default_instance() + } +} + +impl DescriptorProto_ExtensionRange { + pub fn new() -> DescriptorProto_ExtensionRange { + ::std::default::Default::default() + } + + // optional int32 start = 1; + + + pub fn get_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 get_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); + } +} + +impl ::protobuf::Message for DescriptorProto_ExtensionRange { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.start = ::std::option::Option::Some(tmp); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.end = ::std::option::Option::Some(tmp); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(v) = self.start { + my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint); + } + if let Some(v) = self.end { + my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.start { + os.write_int32(1, v)?; + } + if let Some(v) = self.end { + os.write_int32(2, v)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DescriptorProto_ExtensionRange { + DescriptorProto_ExtensionRange::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "start", + |m: &DescriptorProto_ExtensionRange| { &m.start }, + |m: &mut DescriptorProto_ExtensionRange| { &mut m.start }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "end", + |m: &DescriptorProto_ExtensionRange| { &m.end }, + |m: &mut DescriptorProto_ExtensionRange| { &mut m.end }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<DescriptorProto_ExtensionRange>( + "DescriptorProto.ExtensionRange", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DescriptorProto_ExtensionRange { + static mut instance: ::protobuf::lazy::Lazy<DescriptorProto_ExtensionRange> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(DescriptorProto_ExtensionRange::new) + } + } +} + +impl ::protobuf::Clear for DescriptorProto_ExtensionRange { + fn clear(&mut self) { + self.start = ::std::option::Option::None; + self.end = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DescriptorProto_ExtensionRange { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DescriptorProto_ExtensionRange { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct DescriptorProto_ReservedRange { + // message fields + start: ::std::option::Option<i32>, + end: ::std::option::Option<i32>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DescriptorProto_ReservedRange { + fn default() -> &'a DescriptorProto_ReservedRange { + <DescriptorProto_ReservedRange as ::protobuf::Message>::default_instance() + } +} + +impl DescriptorProto_ReservedRange { + pub fn new() -> DescriptorProto_ReservedRange { + ::std::default::Default::default() + } + + // optional int32 start = 1; + + + pub fn get_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 get_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); + } +} + +impl ::protobuf::Message for DescriptorProto_ReservedRange { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.start = ::std::option::Option::Some(tmp); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.end = ::std::option::Option::Some(tmp); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(v) = self.start { + my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint); + } + if let Some(v) = self.end { + my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.start { + os.write_int32(1, v)?; + } + if let Some(v) = self.end { + os.write_int32(2, v)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DescriptorProto_ReservedRange { + DescriptorProto_ReservedRange::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "start", + |m: &DescriptorProto_ReservedRange| { &m.start }, + |m: &mut DescriptorProto_ReservedRange| { &mut m.start }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "end", + |m: &DescriptorProto_ReservedRange| { &m.end }, + |m: &mut DescriptorProto_ReservedRange| { &mut m.end }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<DescriptorProto_ReservedRange>( + "DescriptorProto.ReservedRange", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DescriptorProto_ReservedRange { + static mut instance: ::protobuf::lazy::Lazy<DescriptorProto_ReservedRange> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(DescriptorProto_ReservedRange::new) + } + } +} + +impl ::protobuf::Clear for DescriptorProto_ReservedRange { + fn clear(&mut self) { + self.start = ::std::option::Option::None; + self.end = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DescriptorProto_ReservedRange { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DescriptorProto_ReservedRange { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct FieldDescriptorProto { + // message fields + name: ::protobuf::SingularField<::std::string::String>, + number: ::std::option::Option<i32>, + label: ::std::option::Option<FieldDescriptorProto_Label>, + field_type: ::std::option::Option<FieldDescriptorProto_Type>, + type_name: ::protobuf::SingularField<::std::string::String>, + extendee: ::protobuf::SingularField<::std::string::String>, + default_value: ::protobuf::SingularField<::std::string::String>, + oneof_index: ::std::option::Option<i32>, + json_name: ::protobuf::SingularField<::std::string::String>, + options: ::protobuf::SingularPtrField<FieldOptions>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a FieldDescriptorProto { + fn default() -> &'a FieldDescriptorProto { + <FieldDescriptorProto as ::protobuf::Message>::default_instance() + } +} + +impl FieldDescriptorProto { + pub fn new() -> FieldDescriptorProto { + ::std::default::Default::default() + } + + // optional string name = 1; + + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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 get_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 get_label(&self) -> FieldDescriptorProto_Label { + self.label.unwrap_or(FieldDescriptorProto_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: FieldDescriptorProto_Label) { + self.label = ::std::option::Option::Some(v); + } + + // optional .google.protobuf.FieldDescriptorProto.Type type = 5; + + + pub fn get_field_type(&self) -> FieldDescriptorProto_Type { + self.field_type.unwrap_or(FieldDescriptorProto_Type::TYPE_DOUBLE) + } + pub fn clear_field_type(&mut self) { + self.field_type = ::std::option::Option::None; + } + + pub fn has_field_type(&self) -> bool { + self.field_type.is_some() + } + + // Param is passed by value, moved + pub fn set_field_type(&mut self, v: FieldDescriptorProto_Type) { + self.field_type = ::std::option::Option::Some(v); + } + + // optional string type_name = 6; + + + pub fn get_type_name(&self) -> &str { + match self.type_name.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_type_name(&mut self) { + self.type_name.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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 get_extendee(&self) -> &str { + match self.extendee.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_extendee(&mut self) { + self.extendee.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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 get_default_value(&self) -> &str { + match self.default_value.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_default_value(&mut self) { + self.default_value.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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 get_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 get_json_name(&self) -> &str { + match self.json_name.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_json_name(&mut self) { + self.json_name.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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 .google.protobuf.FieldOptions options = 8; + + + pub fn get_options(&self) -> &FieldOptions { + self.options.as_ref().unwrap_or_else(|| FieldOptions::default_instance()) + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + pub fn has_options(&self) -> bool { + self.options.is_some() + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: FieldOptions) { + self.options = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_options(&mut self) -> &mut FieldOptions { + if self.options.is_none() { + self.options.set_default(); + } + self.options.as_mut().unwrap() + } + + // Take field + pub fn take_options(&mut self) -> FieldOptions { + self.options.take().unwrap_or_else(|| FieldOptions::new()) + } +} + +impl ::protobuf::Message for 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 ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.number = ::std::option::Option::Some(tmp); + }, + 4 => { + ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.label, 4, &mut self.unknown_fields)? + }, + 5 => { + ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 5, &mut self.unknown_fields)? + }, + 6 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.type_name)?; + }, + 2 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.extendee)?; + }, + 7 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.default_value)?; + }, + 9 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.oneof_index = ::std::option::Option::Some(tmp); + }, + 10 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.json_name)?; + }, + 8 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.name.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(v) = self.number { + my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint); + } + if let Some(v) = self.label { + my_size += ::protobuf::rt::enum_size(4, v); + } + if let Some(v) = self.field_type { + my_size += ::protobuf::rt::enum_size(5, v); + } + if let Some(ref v) = self.type_name.as_ref() { + my_size += ::protobuf::rt::string_size(6, &v); + } + if let Some(ref v) = self.extendee.as_ref() { + my_size += ::protobuf::rt::string_size(2, &v); + } + if let Some(ref v) = self.default_value.as_ref() { + my_size += ::protobuf::rt::string_size(7, &v); + } + if let Some(v) = self.oneof_index { + my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint); + } + if let Some(ref v) = self.json_name.as_ref() { + my_size += ::protobuf::rt::string_size(10, &v); + } + if let Some(ref v) = self.options.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.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, v.value())?; + } + if let Some(v) = self.field_type { + os.write_enum(5, v.value())?; + } + if let Some(ref v) = self.type_name.as_ref() { + os.write_string(6, &v)?; + } + if let Some(ref v) = self.extendee.as_ref() { + os.write_string(2, &v)?; + } + if let Some(ref 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(ref v) = self.json_name.as_ref() { + os.write_string(10, &v)?; + } + if let Some(ref v) = self.options.as_ref() { + os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> FieldDescriptorProto { + FieldDescriptorProto::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &FieldDescriptorProto| { &m.name }, + |m: &mut FieldDescriptorProto| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "number", + |m: &FieldDescriptorProto| { &m.number }, + |m: &mut FieldDescriptorProto| { &mut m.number }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FieldDescriptorProto_Label>>( + "label", + |m: &FieldDescriptorProto| { &m.label }, + |m: &mut FieldDescriptorProto| { &mut m.label }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FieldDescriptorProto_Type>>( + "type", + |m: &FieldDescriptorProto| { &m.field_type }, + |m: &mut FieldDescriptorProto| { &mut m.field_type }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "type_name", + |m: &FieldDescriptorProto| { &m.type_name }, + |m: &mut FieldDescriptorProto| { &mut m.type_name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "extendee", + |m: &FieldDescriptorProto| { &m.extendee }, + |m: &mut FieldDescriptorProto| { &mut m.extendee }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "default_value", + |m: &FieldDescriptorProto| { &m.default_value }, + |m: &mut FieldDescriptorProto| { &mut m.default_value }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "oneof_index", + |m: &FieldDescriptorProto| { &m.oneof_index }, + |m: &mut FieldDescriptorProto| { &mut m.oneof_index }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "json_name", + |m: &FieldDescriptorProto| { &m.json_name }, + |m: &mut FieldDescriptorProto| { &mut m.json_name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FieldOptions>>( + "options", + |m: &FieldDescriptorProto| { &m.options }, + |m: &mut FieldDescriptorProto| { &mut m.options }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<FieldDescriptorProto>( + "FieldDescriptorProto", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static FieldDescriptorProto { + static mut instance: ::protobuf::lazy::Lazy<FieldDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(FieldDescriptorProto::new) + } + } +} + +impl ::protobuf::Clear for FieldDescriptorProto { + fn clear(&mut self) { + self.name.clear(); + self.number = ::std::option::Option::None; + self.label = ::std::option::Option::None; + self.field_type = ::std::option::Option::None; + self.type_name.clear(); + self.extendee.clear(); + self.default_value.clear(); + self.oneof_index = ::std::option::Option::None; + self.json_name.clear(); + self.options.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for FieldDescriptorProto { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for FieldDescriptorProto { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub enum FieldDescriptorProto_Type { + TYPE_DOUBLE = 1, + TYPE_FLOAT = 2, + TYPE_INT64 = 3, + TYPE_UINT64 = 4, + TYPE_INT32 = 5, + TYPE_FIXED64 = 6, + TYPE_FIXED32 = 7, + TYPE_BOOL = 8, + TYPE_STRING = 9, + TYPE_GROUP = 10, + TYPE_MESSAGE = 11, + TYPE_BYTES = 12, + TYPE_UINT32 = 13, + TYPE_ENUM = 14, + TYPE_SFIXED32 = 15, + TYPE_SFIXED64 = 16, + TYPE_SINT32 = 17, + TYPE_SINT64 = 18, +} + +impl ::protobuf::ProtobufEnum for FieldDescriptorProto_Type { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option<FieldDescriptorProto_Type> { + match value { + 1 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_DOUBLE), + 2 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_FLOAT), + 3 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_INT64), + 4 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_UINT64), + 5 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_INT32), + 6 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_FIXED64), + 7 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_FIXED32), + 8 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_BOOL), + 9 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_STRING), + 10 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_GROUP), + 11 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_MESSAGE), + 12 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_BYTES), + 13 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_UINT32), + 14 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_ENUM), + 15 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_SFIXED32), + 16 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_SFIXED64), + 17 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_SINT32), + 18 => ::std::option::Option::Some(FieldDescriptorProto_Type::TYPE_SINT64), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [FieldDescriptorProto_Type] = &[ + FieldDescriptorProto_Type::TYPE_DOUBLE, + FieldDescriptorProto_Type::TYPE_FLOAT, + FieldDescriptorProto_Type::TYPE_INT64, + FieldDescriptorProto_Type::TYPE_UINT64, + FieldDescriptorProto_Type::TYPE_INT32, + FieldDescriptorProto_Type::TYPE_FIXED64, + FieldDescriptorProto_Type::TYPE_FIXED32, + FieldDescriptorProto_Type::TYPE_BOOL, + FieldDescriptorProto_Type::TYPE_STRING, + FieldDescriptorProto_Type::TYPE_GROUP, + FieldDescriptorProto_Type::TYPE_MESSAGE, + FieldDescriptorProto_Type::TYPE_BYTES, + FieldDescriptorProto_Type::TYPE_UINT32, + FieldDescriptorProto_Type::TYPE_ENUM, + FieldDescriptorProto_Type::TYPE_SFIXED32, + FieldDescriptorProto_Type::TYPE_SFIXED64, + FieldDescriptorProto_Type::TYPE_SINT32, + FieldDescriptorProto_Type::TYPE_SINT64, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new_pb_name::<FieldDescriptorProto_Type>("FieldDescriptorProto.Type", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for FieldDescriptorProto_Type { +} + +// Note, `Default` is implemented although default value is not 0 +impl ::std::default::Default for FieldDescriptorProto_Type { + fn default() -> Self { + FieldDescriptorProto_Type::TYPE_DOUBLE + } +} + +impl ::protobuf::reflect::ProtobufValue for FieldDescriptorProto_Type { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor()) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub enum FieldDescriptorProto_Label { + LABEL_OPTIONAL = 1, + LABEL_REQUIRED = 2, + LABEL_REPEATED = 3, +} + +impl ::protobuf::ProtobufEnum for FieldDescriptorProto_Label { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option<FieldDescriptorProto_Label> { + match value { + 1 => ::std::option::Option::Some(FieldDescriptorProto_Label::LABEL_OPTIONAL), + 2 => ::std::option::Option::Some(FieldDescriptorProto_Label::LABEL_REQUIRED), + 3 => ::std::option::Option::Some(FieldDescriptorProto_Label::LABEL_REPEATED), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [FieldDescriptorProto_Label] = &[ + FieldDescriptorProto_Label::LABEL_OPTIONAL, + FieldDescriptorProto_Label::LABEL_REQUIRED, + FieldDescriptorProto_Label::LABEL_REPEATED, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new_pb_name::<FieldDescriptorProto_Label>("FieldDescriptorProto.Label", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for FieldDescriptorProto_Label { +} + +// Note, `Default` is implemented although default value is not 0 +impl ::std::default::Default for FieldDescriptorProto_Label { + fn default() -> Self { + FieldDescriptorProto_Label::LABEL_OPTIONAL + } +} + +impl ::protobuf::reflect::ProtobufValue for FieldDescriptorProto_Label { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor()) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct OneofDescriptorProto { + // message fields + name: ::protobuf::SingularField<::std::string::String>, + options: ::protobuf::SingularPtrField<OneofOptions>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a OneofDescriptorProto { + fn default() -> &'a OneofDescriptorProto { + <OneofDescriptorProto as ::protobuf::Message>::default_instance() + } +} + +impl OneofDescriptorProto { + pub fn new() -> OneofDescriptorProto { + ::std::default::Default::default() + } + + // optional string name = 1; + + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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 .google.protobuf.OneofOptions options = 2; + + + pub fn get_options(&self) -> &OneofOptions { + self.options.as_ref().unwrap_or_else(|| OneofOptions::default_instance()) + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + pub fn has_options(&self) -> bool { + self.options.is_some() + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: OneofOptions) { + self.options = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_options(&mut self) -> &mut OneofOptions { + if self.options.is_none() { + self.options.set_default(); + } + self.options.as_mut().unwrap() + } + + // Take field + pub fn take_options(&mut self) -> OneofOptions { + self.options.take().unwrap_or_else(|| OneofOptions::new()) + } +} + +impl ::protobuf::Message for OneofDescriptorProto { + fn is_initialized(&self) -> bool { + for v in &self.options { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.name.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(ref v) = self.options.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.name.as_ref() { + os.write_string(1, &v)?; + } + if let Some(ref v) = self.options.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> OneofDescriptorProto { + OneofDescriptorProto::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &OneofDescriptorProto| { &m.name }, + |m: &mut OneofDescriptorProto| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<OneofOptions>>( + "options", + |m: &OneofDescriptorProto| { &m.options }, + |m: &mut OneofDescriptorProto| { &mut m.options }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<OneofDescriptorProto>( + "OneofDescriptorProto", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static OneofDescriptorProto { + static mut instance: ::protobuf::lazy::Lazy<OneofDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(OneofDescriptorProto::new) + } + } +} + +impl ::protobuf::Clear for OneofDescriptorProto { + fn clear(&mut self) { + self.name.clear(); + self.options.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for OneofDescriptorProto { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for OneofDescriptorProto { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct EnumDescriptorProto { + // message fields + name: ::protobuf::SingularField<::std::string::String>, + value: ::protobuf::RepeatedField<EnumValueDescriptorProto>, + options: ::protobuf::SingularPtrField<EnumOptions>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a EnumDescriptorProto { + fn default() -> &'a EnumDescriptorProto { + <EnumDescriptorProto as ::protobuf::Message>::default_instance() + } +} + +impl EnumDescriptorProto { + pub fn new() -> EnumDescriptorProto { + ::std::default::Default::default() + } + + // optional string name = 1; + + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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()) + } + + // repeated .google.protobuf.EnumValueDescriptorProto value = 2; + + + pub fn get_value(&self) -> &[EnumValueDescriptorProto] { + &self.value + } + pub fn clear_value(&mut self) { + self.value.clear(); + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: ::protobuf::RepeatedField<EnumValueDescriptorProto>) { + self.value = v; + } + + // Mutable pointer to the field. + pub fn mut_value(&mut self) -> &mut ::protobuf::RepeatedField<EnumValueDescriptorProto> { + &mut self.value + } + + // Take field + pub fn take_value(&mut self) -> ::protobuf::RepeatedField<EnumValueDescriptorProto> { + ::std::mem::replace(&mut self.value, ::protobuf::RepeatedField::new()) + } + + // optional .google.protobuf.EnumOptions options = 3; + + + pub fn get_options(&self) -> &EnumOptions { + self.options.as_ref().unwrap_or_else(|| EnumOptions::default_instance()) + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + pub fn has_options(&self) -> bool { + self.options.is_some() + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: EnumOptions) { + self.options = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_options(&mut self) -> &mut EnumOptions { + if self.options.is_none() { + self.options.set_default(); + } + self.options.as_mut().unwrap() + } + + // Take field + pub fn take_options(&mut self) -> EnumOptions { + self.options.take().unwrap_or_else(|| EnumOptions::new()) + } +} + +impl ::protobuf::Message for EnumDescriptorProto { + fn is_initialized(&self) -> bool { + for v in &self.value { + if !v.is_initialized() { + return false; + } + }; + for v in &self.options { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.value)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.name.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + for value in &self.value { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if let Some(ref v) = self.options.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.name.as_ref() { + os.write_string(1, &v)?; + } + for v in &self.value { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if let Some(ref v) = self.options.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> EnumDescriptorProto { + EnumDescriptorProto::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &EnumDescriptorProto| { &m.name }, + |m: &mut EnumDescriptorProto| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EnumValueDescriptorProto>>( + "value", + |m: &EnumDescriptorProto| { &m.value }, + |m: &mut EnumDescriptorProto| { &mut m.value }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EnumOptions>>( + "options", + |m: &EnumDescriptorProto| { &m.options }, + |m: &mut EnumDescriptorProto| { &mut m.options }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<EnumDescriptorProto>( + "EnumDescriptorProto", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static EnumDescriptorProto { + static mut instance: ::protobuf::lazy::Lazy<EnumDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(EnumDescriptorProto::new) + } + } +} + +impl ::protobuf::Clear for EnumDescriptorProto { + fn clear(&mut self) { + self.name.clear(); + self.value.clear(); + self.options.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for EnumDescriptorProto { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for EnumDescriptorProto { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct EnumValueDescriptorProto { + // message fields + name: ::protobuf::SingularField<::std::string::String>, + number: ::std::option::Option<i32>, + options: ::protobuf::SingularPtrField<EnumValueOptions>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a EnumValueDescriptorProto { + fn default() -> &'a EnumValueDescriptorProto { + <EnumValueDescriptorProto as ::protobuf::Message>::default_instance() + } +} + +impl EnumValueDescriptorProto { + pub fn new() -> EnumValueDescriptorProto { + ::std::default::Default::default() + } + + // optional string name = 1; + + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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 = 2; + + + pub fn get_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.EnumValueOptions options = 3; + + + pub fn get_options(&self) -> &EnumValueOptions { + self.options.as_ref().unwrap_or_else(|| EnumValueOptions::default_instance()) + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + pub fn has_options(&self) -> bool { + self.options.is_some() + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: EnumValueOptions) { + self.options = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_options(&mut self) -> &mut EnumValueOptions { + if self.options.is_none() { + self.options.set_default(); + } + self.options.as_mut().unwrap() + } + + // Take field + pub fn take_options(&mut self) -> EnumValueOptions { + self.options.take().unwrap_or_else(|| EnumValueOptions::new()) + } +} + +impl ::protobuf::Message for EnumValueDescriptorProto { + fn is_initialized(&self) -> bool { + for v in &self.options { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.number = ::std::option::Option::Some(tmp); + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.name.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(v) = self.number { + my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint); + } + if let Some(ref v) = self.options.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.name.as_ref() { + os.write_string(1, &v)?; + } + if let Some(v) = self.number { + os.write_int32(2, v)?; + } + if let Some(ref v) = self.options.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> EnumValueDescriptorProto { + EnumValueDescriptorProto::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &EnumValueDescriptorProto| { &m.name }, + |m: &mut EnumValueDescriptorProto| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "number", + |m: &EnumValueDescriptorProto| { &m.number }, + |m: &mut EnumValueDescriptorProto| { &mut m.number }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EnumValueOptions>>( + "options", + |m: &EnumValueDescriptorProto| { &m.options }, + |m: &mut EnumValueDescriptorProto| { &mut m.options }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<EnumValueDescriptorProto>( + "EnumValueDescriptorProto", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static EnumValueDescriptorProto { + static mut instance: ::protobuf::lazy::Lazy<EnumValueDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(EnumValueDescriptorProto::new) + } + } +} + +impl ::protobuf::Clear for EnumValueDescriptorProto { + fn clear(&mut self) { + self.name.clear(); + self.number = ::std::option::Option::None; + self.options.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for EnumValueDescriptorProto { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for EnumValueDescriptorProto { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct ServiceDescriptorProto { + // message fields + name: ::protobuf::SingularField<::std::string::String>, + method: ::protobuf::RepeatedField<MethodDescriptorProto>, + options: ::protobuf::SingularPtrField<ServiceOptions>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ServiceDescriptorProto { + fn default() -> &'a ServiceDescriptorProto { + <ServiceDescriptorProto as ::protobuf::Message>::default_instance() + } +} + +impl ServiceDescriptorProto { + pub fn new() -> ServiceDescriptorProto { + ::std::default::Default::default() + } + + // optional string name = 1; + + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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()) + } + + // repeated .google.protobuf.MethodDescriptorProto method = 2; + + + pub fn get_method(&self) -> &[MethodDescriptorProto] { + &self.method + } + pub fn clear_method(&mut self) { + self.method.clear(); + } + + // Param is passed by value, moved + pub fn set_method(&mut self, v: ::protobuf::RepeatedField<MethodDescriptorProto>) { + self.method = v; + } + + // Mutable pointer to the field. + pub fn mut_method(&mut self) -> &mut ::protobuf::RepeatedField<MethodDescriptorProto> { + &mut self.method + } + + // Take field + pub fn take_method(&mut self) -> ::protobuf::RepeatedField<MethodDescriptorProto> { + ::std::mem::replace(&mut self.method, ::protobuf::RepeatedField::new()) + } + + // optional .google.protobuf.ServiceOptions options = 3; + + + pub fn get_options(&self) -> &ServiceOptions { + self.options.as_ref().unwrap_or_else(|| ServiceOptions::default_instance()) + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + pub fn has_options(&self) -> bool { + self.options.is_some() + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: ServiceOptions) { + self.options = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_options(&mut self) -> &mut ServiceOptions { + if self.options.is_none() { + self.options.set_default(); + } + self.options.as_mut().unwrap() + } + + // Take field + pub fn take_options(&mut self) -> ServiceOptions { + self.options.take().unwrap_or_else(|| ServiceOptions::new()) + } +} + +impl ::protobuf::Message for ServiceDescriptorProto { + fn is_initialized(&self) -> bool { + for v in &self.method { + if !v.is_initialized() { + return false; + } + }; + for v in &self.options { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.method)?; + }, + 3 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.name.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + for value in &self.method { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if let Some(ref v) = self.options.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.name.as_ref() { + os.write_string(1, &v)?; + } + for v in &self.method { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if let Some(ref v) = self.options.as_ref() { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ServiceDescriptorProto { + ServiceDescriptorProto::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &ServiceDescriptorProto| { &m.name }, + |m: &mut ServiceDescriptorProto| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MethodDescriptorProto>>( + "method", + |m: &ServiceDescriptorProto| { &m.method }, + |m: &mut ServiceDescriptorProto| { &mut m.method }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ServiceOptions>>( + "options", + |m: &ServiceDescriptorProto| { &m.options }, + |m: &mut ServiceDescriptorProto| { &mut m.options }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<ServiceDescriptorProto>( + "ServiceDescriptorProto", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ServiceDescriptorProto { + static mut instance: ::protobuf::lazy::Lazy<ServiceDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(ServiceDescriptorProto::new) + } + } +} + +impl ::protobuf::Clear for ServiceDescriptorProto { + fn clear(&mut self) { + self.name.clear(); + self.method.clear(); + self.options.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ServiceDescriptorProto { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ServiceDescriptorProto { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct MethodDescriptorProto { + // message fields + name: ::protobuf::SingularField<::std::string::String>, + input_type: ::protobuf::SingularField<::std::string::String>, + output_type: ::protobuf::SingularField<::std::string::String>, + options: ::protobuf::SingularPtrField<MethodOptions>, + client_streaming: ::std::option::Option<bool>, + server_streaming: ::std::option::Option<bool>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MethodDescriptorProto { + fn default() -> &'a MethodDescriptorProto { + <MethodDescriptorProto as ::protobuf::Message>::default_instance() + } +} + +impl MethodDescriptorProto { + pub fn new() -> MethodDescriptorProto { + ::std::default::Default::default() + } + + // optional string name = 1; + + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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 input_type = 2; + + + pub fn get_input_type(&self) -> &str { + match self.input_type.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_input_type(&mut self) { + self.input_type.clear(); + } + + pub fn has_input_type(&self) -> bool { + self.input_type.is_some() + } + + // Param is passed by value, moved + pub fn set_input_type(&mut self, v: ::std::string::String) { + self.input_type = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_input_type(&mut self) -> &mut ::std::string::String { + if self.input_type.is_none() { + self.input_type.set_default(); + } + self.input_type.as_mut().unwrap() + } + + // Take field + pub fn take_input_type(&mut self) -> ::std::string::String { + self.input_type.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional string output_type = 3; + + + pub fn get_output_type(&self) -> &str { + match self.output_type.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_output_type(&mut self) { + self.output_type.clear(); + } + + pub fn has_output_type(&self) -> bool { + self.output_type.is_some() + } + + // Param is passed by value, moved + pub fn set_output_type(&mut self, v: ::std::string::String) { + self.output_type = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_output_type(&mut self) -> &mut ::std::string::String { + if self.output_type.is_none() { + self.output_type.set_default(); + } + self.output_type.as_mut().unwrap() + } + + // Take field + pub fn take_output_type(&mut self) -> ::std::string::String { + self.output_type.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional .google.protobuf.MethodOptions options = 4; + + + pub fn get_options(&self) -> &MethodOptions { + self.options.as_ref().unwrap_or_else(|| MethodOptions::default_instance()) + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + pub fn has_options(&self) -> bool { + self.options.is_some() + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: MethodOptions) { + self.options = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_options(&mut self) -> &mut MethodOptions { + if self.options.is_none() { + self.options.set_default(); + } + self.options.as_mut().unwrap() + } + + // Take field + pub fn take_options(&mut self) -> MethodOptions { + self.options.take().unwrap_or_else(|| MethodOptions::new()) + } + + // optional bool client_streaming = 5; + + + pub fn get_client_streaming(&self) -> bool { + self.client_streaming.unwrap_or(false) + } + pub fn clear_client_streaming(&mut self) { + self.client_streaming = ::std::option::Option::None; + } + + pub fn has_client_streaming(&self) -> bool { + self.client_streaming.is_some() + } + + // Param is passed by value, moved + pub fn set_client_streaming(&mut self, v: bool) { + self.client_streaming = ::std::option::Option::Some(v); + } + + // optional bool server_streaming = 6; + + + pub fn get_server_streaming(&self) -> bool { + self.server_streaming.unwrap_or(false) + } + pub fn clear_server_streaming(&mut self) { + self.server_streaming = ::std::option::Option::None; + } + + pub fn has_server_streaming(&self) -> bool { + self.server_streaming.is_some() + } + + // Param is passed by value, moved + pub fn set_server_streaming(&mut self, v: bool) { + self.server_streaming = ::std::option::Option::Some(v); + } +} + +impl ::protobuf::Message for MethodDescriptorProto { + fn is_initialized(&self) -> bool { + for v in &self.options { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.input_type)?; + }, + 3 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.output_type)?; + }, + 4 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?; + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.client_streaming = ::std::option::Option::Some(tmp); + }, + 6 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.server_streaming = ::std::option::Option::Some(tmp); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.name.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(ref v) = self.input_type.as_ref() { + my_size += ::protobuf::rt::string_size(2, &v); + } + if let Some(ref v) = self.output_type.as_ref() { + my_size += ::protobuf::rt::string_size(3, &v); + } + if let Some(ref v) = self.options.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if let Some(v) = self.client_streaming { + my_size += 2; + } + if let Some(v) = self.server_streaming { + my_size += 2; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.name.as_ref() { + os.write_string(1, &v)?; + } + if let Some(ref v) = self.input_type.as_ref() { + os.write_string(2, &v)?; + } + if let Some(ref v) = self.output_type.as_ref() { + os.write_string(3, &v)?; + } + if let Some(ref v) = self.options.as_ref() { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if let Some(v) = self.client_streaming { + os.write_bool(5, v)?; + } + if let Some(v) = self.server_streaming { + os.write_bool(6, v)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MethodDescriptorProto { + MethodDescriptorProto::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &MethodDescriptorProto| { &m.name }, + |m: &mut MethodDescriptorProto| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "input_type", + |m: &MethodDescriptorProto| { &m.input_type }, + |m: &mut MethodDescriptorProto| { &mut m.input_type }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "output_type", + |m: &MethodDescriptorProto| { &m.output_type }, + |m: &mut MethodDescriptorProto| { &mut m.output_type }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MethodOptions>>( + "options", + |m: &MethodDescriptorProto| { &m.options }, + |m: &mut MethodDescriptorProto| { &mut m.options }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "client_streaming", + |m: &MethodDescriptorProto| { &m.client_streaming }, + |m: &mut MethodDescriptorProto| { &mut m.client_streaming }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "server_streaming", + |m: &MethodDescriptorProto| { &m.server_streaming }, + |m: &mut MethodDescriptorProto| { &mut m.server_streaming }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<MethodDescriptorProto>( + "MethodDescriptorProto", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MethodDescriptorProto { + static mut instance: ::protobuf::lazy::Lazy<MethodDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(MethodDescriptorProto::new) + } + } +} + +impl ::protobuf::Clear for MethodDescriptorProto { + fn clear(&mut self) { + self.name.clear(); + self.input_type.clear(); + self.output_type.clear(); + self.options.clear(); + self.client_streaming = ::std::option::Option::None; + self.server_streaming = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MethodDescriptorProto { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MethodDescriptorProto { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct FileOptions { + // message fields + java_package: ::protobuf::SingularField<::std::string::String>, + java_outer_classname: ::protobuf::SingularField<::std::string::String>, + java_multiple_files: ::std::option::Option<bool>, + java_generate_equals_and_hash: ::std::option::Option<bool>, + java_string_check_utf8: ::std::option::Option<bool>, + optimize_for: ::std::option::Option<FileOptions_OptimizeMode>, + go_package: ::protobuf::SingularField<::std::string::String>, + cc_generic_services: ::std::option::Option<bool>, + java_generic_services: ::std::option::Option<bool>, + py_generic_services: ::std::option::Option<bool>, + deprecated: ::std::option::Option<bool>, + cc_enable_arenas: ::std::option::Option<bool>, + objc_class_prefix: ::protobuf::SingularField<::std::string::String>, + csharp_namespace: ::protobuf::SingularField<::std::string::String>, + uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a FileOptions { + fn default() -> &'a FileOptions { + <FileOptions as ::protobuf::Message>::default_instance() + } +} + +impl FileOptions { + pub fn new() -> FileOptions { + ::std::default::Default::default() + } + + // optional string java_package = 1; + + + pub fn get_java_package(&self) -> &str { + match self.java_package.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_java_package(&mut self) { + self.java_package.clear(); + } + + pub fn has_java_package(&self) -> bool { + self.java_package.is_some() + } + + // Param is passed by value, moved + pub fn set_java_package(&mut self, v: ::std::string::String) { + self.java_package = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_java_package(&mut self) -> &mut ::std::string::String { + if self.java_package.is_none() { + self.java_package.set_default(); + } + self.java_package.as_mut().unwrap() + } + + // Take field + pub fn take_java_package(&mut self) -> ::std::string::String { + self.java_package.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional string java_outer_classname = 8; + + + pub fn get_java_outer_classname(&self) -> &str { + match self.java_outer_classname.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_java_outer_classname(&mut self) { + self.java_outer_classname.clear(); + } + + pub fn has_java_outer_classname(&self) -> bool { + self.java_outer_classname.is_some() + } + + // Param is passed by value, moved + pub fn set_java_outer_classname(&mut self, v: ::std::string::String) { + self.java_outer_classname = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_java_outer_classname(&mut self) -> &mut ::std::string::String { + if self.java_outer_classname.is_none() { + self.java_outer_classname.set_default(); + } + self.java_outer_classname.as_mut().unwrap() + } + + // Take field + pub fn take_java_outer_classname(&mut self) -> ::std::string::String { + self.java_outer_classname.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional bool java_multiple_files = 10; + + + pub fn get_java_multiple_files(&self) -> bool { + self.java_multiple_files.unwrap_or(false) + } + pub fn clear_java_multiple_files(&mut self) { + self.java_multiple_files = ::std::option::Option::None; + } + + pub fn has_java_multiple_files(&self) -> bool { + self.java_multiple_files.is_some() + } + + // Param is passed by value, moved + pub fn set_java_multiple_files(&mut self, v: bool) { + self.java_multiple_files = ::std::option::Option::Some(v); + } + + // optional bool java_generate_equals_and_hash = 20; + + + pub fn get_java_generate_equals_and_hash(&self) -> bool { + self.java_generate_equals_and_hash.unwrap_or(false) + } + pub fn clear_java_generate_equals_and_hash(&mut self) { + self.java_generate_equals_and_hash = ::std::option::Option::None; + } + + pub fn has_java_generate_equals_and_hash(&self) -> bool { + self.java_generate_equals_and_hash.is_some() + } + + // Param is passed by value, moved + pub fn set_java_generate_equals_and_hash(&mut self, v: bool) { + self.java_generate_equals_and_hash = ::std::option::Option::Some(v); + } + + // optional bool java_string_check_utf8 = 27; + + + pub fn get_java_string_check_utf8(&self) -> bool { + self.java_string_check_utf8.unwrap_or(false) + } + pub fn clear_java_string_check_utf8(&mut self) { + self.java_string_check_utf8 = ::std::option::Option::None; + } + + pub fn has_java_string_check_utf8(&self) -> bool { + self.java_string_check_utf8.is_some() + } + + // Param is passed by value, moved + pub fn set_java_string_check_utf8(&mut self, v: bool) { + self.java_string_check_utf8 = ::std::option::Option::Some(v); + } + + // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9; + + + pub fn get_optimize_for(&self) -> FileOptions_OptimizeMode { + self.optimize_for.unwrap_or(FileOptions_OptimizeMode::SPEED) + } + pub fn clear_optimize_for(&mut self) { + self.optimize_for = ::std::option::Option::None; + } + + pub fn has_optimize_for(&self) -> bool { + self.optimize_for.is_some() + } + + // Param is passed by value, moved + pub fn set_optimize_for(&mut self, v: FileOptions_OptimizeMode) { + self.optimize_for = ::std::option::Option::Some(v); + } + + // optional string go_package = 11; + + + pub fn get_go_package(&self) -> &str { + match self.go_package.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_go_package(&mut self) { + self.go_package.clear(); + } + + pub fn has_go_package(&self) -> bool { + self.go_package.is_some() + } + + // Param is passed by value, moved + pub fn set_go_package(&mut self, v: ::std::string::String) { + self.go_package = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_go_package(&mut self) -> &mut ::std::string::String { + if self.go_package.is_none() { + self.go_package.set_default(); + } + self.go_package.as_mut().unwrap() + } + + // Take field + pub fn take_go_package(&mut self) -> ::std::string::String { + self.go_package.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional bool cc_generic_services = 16; + + + pub fn get_cc_generic_services(&self) -> bool { + self.cc_generic_services.unwrap_or(false) + } + pub fn clear_cc_generic_services(&mut self) { + self.cc_generic_services = ::std::option::Option::None; + } + + pub fn has_cc_generic_services(&self) -> bool { + self.cc_generic_services.is_some() + } + + // Param is passed by value, moved + pub fn set_cc_generic_services(&mut self, v: bool) { + self.cc_generic_services = ::std::option::Option::Some(v); + } + + // optional bool java_generic_services = 17; + + + pub fn get_java_generic_services(&self) -> bool { + self.java_generic_services.unwrap_or(false) + } + pub fn clear_java_generic_services(&mut self) { + self.java_generic_services = ::std::option::Option::None; + } + + pub fn has_java_generic_services(&self) -> bool { + self.java_generic_services.is_some() + } + + // Param is passed by value, moved + pub fn set_java_generic_services(&mut self, v: bool) { + self.java_generic_services = ::std::option::Option::Some(v); + } + + // optional bool py_generic_services = 18; + + + pub fn get_py_generic_services(&self) -> bool { + self.py_generic_services.unwrap_or(false) + } + pub fn clear_py_generic_services(&mut self) { + self.py_generic_services = ::std::option::Option::None; + } + + pub fn has_py_generic_services(&self) -> bool { + self.py_generic_services.is_some() + } + + // Param is passed by value, moved + pub fn set_py_generic_services(&mut self, v: bool) { + self.py_generic_services = ::std::option::Option::Some(v); + } + + // optional bool deprecated = 23; + + + pub fn get_deprecated(&self) -> bool { + self.deprecated.unwrap_or(false) + } + pub fn clear_deprecated(&mut self) { + self.deprecated = ::std::option::Option::None; + } + + pub fn has_deprecated(&self) -> bool { + self.deprecated.is_some() + } + + // Param is passed by value, moved + pub fn set_deprecated(&mut self, v: bool) { + self.deprecated = ::std::option::Option::Some(v); + } + + // optional bool cc_enable_arenas = 31; + + + pub fn get_cc_enable_arenas(&self) -> bool { + self.cc_enable_arenas.unwrap_or(false) + } + pub fn clear_cc_enable_arenas(&mut self) { + self.cc_enable_arenas = ::std::option::Option::None; + } + + pub fn has_cc_enable_arenas(&self) -> bool { + self.cc_enable_arenas.is_some() + } + + // Param is passed by value, moved + pub fn set_cc_enable_arenas(&mut self, v: bool) { + self.cc_enable_arenas = ::std::option::Option::Some(v); + } + + // optional string objc_class_prefix = 36; + + + pub fn get_objc_class_prefix(&self) -> &str { + match self.objc_class_prefix.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_objc_class_prefix(&mut self) { + self.objc_class_prefix.clear(); + } + + pub fn has_objc_class_prefix(&self) -> bool { + self.objc_class_prefix.is_some() + } + + // Param is passed by value, moved + pub fn set_objc_class_prefix(&mut self, v: ::std::string::String) { + self.objc_class_prefix = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_objc_class_prefix(&mut self) -> &mut ::std::string::String { + if self.objc_class_prefix.is_none() { + self.objc_class_prefix.set_default(); + } + self.objc_class_prefix.as_mut().unwrap() + } + + // Take field + pub fn take_objc_class_prefix(&mut self) -> ::std::string::String { + self.objc_class_prefix.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional string csharp_namespace = 37; + + + pub fn get_csharp_namespace(&self) -> &str { + match self.csharp_namespace.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_csharp_namespace(&mut self) { + self.csharp_namespace.clear(); + } + + pub fn has_csharp_namespace(&self) -> bool { + self.csharp_namespace.is_some() + } + + // Param is passed by value, moved + pub fn set_csharp_namespace(&mut self, v: ::std::string::String) { + self.csharp_namespace = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_csharp_namespace(&mut self) -> &mut ::std::string::String { + if self.csharp_namespace.is_none() { + self.csharp_namespace.set_default(); + } + self.csharp_namespace.as_mut().unwrap() + } + + // Take field + pub fn take_csharp_namespace(&mut self) -> ::std::string::String { + self.csharp_namespace.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; + + + pub fn get_uninterpreted_option(&self) -> &[UninterpretedOption] { + &self.uninterpreted_option + } + pub fn clear_uninterpreted_option(&mut self) { + self.uninterpreted_option.clear(); + } + + // Param is passed by value, moved + pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) { + self.uninterpreted_option = v; + } + + // Mutable pointer to the field. + pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> { + &mut self.uninterpreted_option + } + + // Take field + pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> { + ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for FileOptions { + 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 ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.java_package)?; + }, + 8 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.java_outer_classname)?; + }, + 10 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.java_multiple_files = ::std::option::Option::Some(tmp); + }, + 20 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.java_generate_equals_and_hash = ::std::option::Option::Some(tmp); + }, + 27 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.java_string_check_utf8 = ::std::option::Option::Some(tmp); + }, + 9 => { + ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.optimize_for, 9, &mut self.unknown_fields)? + }, + 11 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.go_package)?; + }, + 16 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.cc_generic_services = ::std::option::Option::Some(tmp); + }, + 17 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.java_generic_services = ::std::option::Option::Some(tmp); + }, + 18 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.py_generic_services = ::std::option::Option::Some(tmp); + }, + 23 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.deprecated = ::std::option::Option::Some(tmp); + }, + 31 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.cc_enable_arenas = ::std::option::Option::Some(tmp); + }, + 36 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.objc_class_prefix)?; + }, + 37 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.csharp_namespace)?; + }, + 999 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.java_package.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(ref v) = self.java_outer_classname.as_ref() { + my_size += ::protobuf::rt::string_size(8, &v); + } + if let Some(v) = self.java_multiple_files { + my_size += 2; + } + if let Some(v) = self.java_generate_equals_and_hash { + my_size += 3; + } + if let Some(v) = self.java_string_check_utf8 { + my_size += 3; + } + if let Some(v) = self.optimize_for { + my_size += ::protobuf::rt::enum_size(9, v); + } + if let Some(ref v) = self.go_package.as_ref() { + my_size += ::protobuf::rt::string_size(11, &v); + } + if let Some(v) = self.cc_generic_services { + my_size += 3; + } + if let Some(v) = self.java_generic_services { + my_size += 3; + } + if let Some(v) = self.py_generic_services { + my_size += 3; + } + if let Some(v) = self.deprecated { + my_size += 3; + } + if let Some(v) = self.cc_enable_arenas { + my_size += 3; + } + if let Some(ref v) = self.objc_class_prefix.as_ref() { + my_size += ::protobuf::rt::string_size(36, &v); + } + if let Some(ref v) = self.csharp_namespace.as_ref() { + my_size += ::protobuf::rt::string_size(37, &v); + } + for value in &self.uninterpreted_option { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.java_package.as_ref() { + os.write_string(1, &v)?; + } + if let Some(ref v) = self.java_outer_classname.as_ref() { + os.write_string(8, &v)?; + } + if let Some(v) = self.java_multiple_files { + os.write_bool(10, v)?; + } + if let Some(v) = self.java_generate_equals_and_hash { + os.write_bool(20, v)?; + } + if let Some(v) = self.java_string_check_utf8 { + os.write_bool(27, v)?; + } + if let Some(v) = self.optimize_for { + os.write_enum(9, v.value())?; + } + if let Some(ref v) = self.go_package.as_ref() { + os.write_string(11, &v)?; + } + if let Some(v) = self.cc_generic_services { + os.write_bool(16, v)?; + } + if let Some(v) = self.java_generic_services { + os.write_bool(17, v)?; + } + if let Some(v) = self.py_generic_services { + os.write_bool(18, v)?; + } + if let Some(v) = self.deprecated { + os.write_bool(23, v)?; + } + if let Some(v) = self.cc_enable_arenas { + os.write_bool(31, v)?; + } + if let Some(ref v) = self.objc_class_prefix.as_ref() { + os.write_string(36, &v)?; + } + if let Some(ref v) = self.csharp_namespace.as_ref() { + os.write_string(37, &v)?; + } + for v in &self.uninterpreted_option { + os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> FileOptions { + FileOptions::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "java_package", + |m: &FileOptions| { &m.java_package }, + |m: &mut FileOptions| { &mut m.java_package }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "java_outer_classname", + |m: &FileOptions| { &m.java_outer_classname }, + |m: &mut FileOptions| { &mut m.java_outer_classname }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "java_multiple_files", + |m: &FileOptions| { &m.java_multiple_files }, + |m: &mut FileOptions| { &mut m.java_multiple_files }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "java_generate_equals_and_hash", + |m: &FileOptions| { &m.java_generate_equals_and_hash }, + |m: &mut FileOptions| { &mut m.java_generate_equals_and_hash }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "java_string_check_utf8", + |m: &FileOptions| { &m.java_string_check_utf8 }, + |m: &mut FileOptions| { &mut m.java_string_check_utf8 }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FileOptions_OptimizeMode>>( + "optimize_for", + |m: &FileOptions| { &m.optimize_for }, + |m: &mut FileOptions| { &mut m.optimize_for }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "go_package", + |m: &FileOptions| { &m.go_package }, + |m: &mut FileOptions| { &mut m.go_package }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "cc_generic_services", + |m: &FileOptions| { &m.cc_generic_services }, + |m: &mut FileOptions| { &mut m.cc_generic_services }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "java_generic_services", + |m: &FileOptions| { &m.java_generic_services }, + |m: &mut FileOptions| { &mut m.java_generic_services }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "py_generic_services", + |m: &FileOptions| { &m.py_generic_services }, + |m: &mut FileOptions| { &mut m.py_generic_services }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "deprecated", + |m: &FileOptions| { &m.deprecated }, + |m: &mut FileOptions| { &mut m.deprecated }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "cc_enable_arenas", + |m: &FileOptions| { &m.cc_enable_arenas }, + |m: &mut FileOptions| { &mut m.cc_enable_arenas }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "objc_class_prefix", + |m: &FileOptions| { &m.objc_class_prefix }, + |m: &mut FileOptions| { &mut m.objc_class_prefix }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "csharp_namespace", + |m: &FileOptions| { &m.csharp_namespace }, + |m: &mut FileOptions| { &mut m.csharp_namespace }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>( + "uninterpreted_option", + |m: &FileOptions| { &m.uninterpreted_option }, + |m: &mut FileOptions| { &mut m.uninterpreted_option }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<FileOptions>( + "FileOptions", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static FileOptions { + static mut instance: ::protobuf::lazy::Lazy<FileOptions> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(FileOptions::new) + } + } +} + +impl ::protobuf::Clear for FileOptions { + fn clear(&mut self) { + self.java_package.clear(); + self.java_outer_classname.clear(); + self.java_multiple_files = ::std::option::Option::None; + self.java_generate_equals_and_hash = ::std::option::Option::None; + self.java_string_check_utf8 = ::std::option::Option::None; + self.optimize_for = ::std::option::Option::None; + self.go_package.clear(); + self.cc_generic_services = ::std::option::Option::None; + self.java_generic_services = ::std::option::Option::None; + self.py_generic_services = ::std::option::Option::None; + self.deprecated = ::std::option::Option::None; + self.cc_enable_arenas = ::std::option::Option::None; + self.objc_class_prefix.clear(); + self.csharp_namespace.clear(); + self.uninterpreted_option.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for FileOptions { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for FileOptions { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub enum FileOptions_OptimizeMode { + SPEED = 1, + CODE_SIZE = 2, + LITE_RUNTIME = 3, +} + +impl ::protobuf::ProtobufEnum for FileOptions_OptimizeMode { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option<FileOptions_OptimizeMode> { + match value { + 1 => ::std::option::Option::Some(FileOptions_OptimizeMode::SPEED), + 2 => ::std::option::Option::Some(FileOptions_OptimizeMode::CODE_SIZE), + 3 => ::std::option::Option::Some(FileOptions_OptimizeMode::LITE_RUNTIME), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [FileOptions_OptimizeMode] = &[ + FileOptions_OptimizeMode::SPEED, + FileOptions_OptimizeMode::CODE_SIZE, + FileOptions_OptimizeMode::LITE_RUNTIME, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new_pb_name::<FileOptions_OptimizeMode>("FileOptions.OptimizeMode", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for FileOptions_OptimizeMode { +} + +// Note, `Default` is implemented although default value is not 0 +impl ::std::default::Default for FileOptions_OptimizeMode { + fn default() -> Self { + FileOptions_OptimizeMode::SPEED + } +} + +impl ::protobuf::reflect::ProtobufValue for FileOptions_OptimizeMode { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor()) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct MessageOptions { + // message fields + message_set_wire_format: ::std::option::Option<bool>, + no_standard_descriptor_accessor: ::std::option::Option<bool>, + deprecated: ::std::option::Option<bool>, + map_entry: ::std::option::Option<bool>, + uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MessageOptions { + fn default() -> &'a MessageOptions { + <MessageOptions as ::protobuf::Message>::default_instance() + } +} + +impl MessageOptions { + pub fn new() -> MessageOptions { + ::std::default::Default::default() + } + + // optional bool message_set_wire_format = 1; + + + pub fn get_message_set_wire_format(&self) -> bool { + self.message_set_wire_format.unwrap_or(false) + } + pub fn clear_message_set_wire_format(&mut self) { + self.message_set_wire_format = ::std::option::Option::None; + } + + pub fn has_message_set_wire_format(&self) -> bool { + self.message_set_wire_format.is_some() + } + + // Param is passed by value, moved + pub fn set_message_set_wire_format(&mut self, v: bool) { + self.message_set_wire_format = ::std::option::Option::Some(v); + } + + // optional bool no_standard_descriptor_accessor = 2; + + + pub fn get_no_standard_descriptor_accessor(&self) -> bool { + self.no_standard_descriptor_accessor.unwrap_or(false) + } + pub fn clear_no_standard_descriptor_accessor(&mut self) { + self.no_standard_descriptor_accessor = ::std::option::Option::None; + } + + pub fn has_no_standard_descriptor_accessor(&self) -> bool { + self.no_standard_descriptor_accessor.is_some() + } + + // Param is passed by value, moved + pub fn set_no_standard_descriptor_accessor(&mut self, v: bool) { + self.no_standard_descriptor_accessor = ::std::option::Option::Some(v); + } + + // optional bool deprecated = 3; + + + pub fn get_deprecated(&self) -> bool { + self.deprecated.unwrap_or(false) + } + pub fn clear_deprecated(&mut self) { + self.deprecated = ::std::option::Option::None; + } + + pub fn has_deprecated(&self) -> bool { + self.deprecated.is_some() + } + + // Param is passed by value, moved + pub fn set_deprecated(&mut self, v: bool) { + self.deprecated = ::std::option::Option::Some(v); + } + + // optional bool map_entry = 7; + + + pub fn get_map_entry(&self) -> bool { + self.map_entry.unwrap_or(false) + } + pub fn clear_map_entry(&mut self) { + self.map_entry = ::std::option::Option::None; + } + + pub fn has_map_entry(&self) -> bool { + self.map_entry.is_some() + } + + // Param is passed by value, moved + pub fn set_map_entry(&mut self, v: bool) { + self.map_entry = ::std::option::Option::Some(v); + } + + // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; + + + pub fn get_uninterpreted_option(&self) -> &[UninterpretedOption] { + &self.uninterpreted_option + } + pub fn clear_uninterpreted_option(&mut self) { + self.uninterpreted_option.clear(); + } + + // Param is passed by value, moved + pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) { + self.uninterpreted_option = v; + } + + // Mutable pointer to the field. + pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> { + &mut self.uninterpreted_option + } + + // Take field + pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> { + ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for MessageOptions { + 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 ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.message_set_wire_format = ::std::option::Option::Some(tmp); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.no_standard_descriptor_accessor = ::std::option::Option::Some(tmp); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.deprecated = ::std::option::Option::Some(tmp); + }, + 7 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.map_entry = ::std::option::Option::Some(tmp); + }, + 999 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(v) = self.message_set_wire_format { + my_size += 2; + } + if let Some(v) = self.no_standard_descriptor_accessor { + my_size += 2; + } + if let Some(v) = self.deprecated { + my_size += 2; + } + if let Some(v) = self.map_entry { + my_size += 2; + } + for value in &self.uninterpreted_option { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.message_set_wire_format { + os.write_bool(1, v)?; + } + if let Some(v) = self.no_standard_descriptor_accessor { + os.write_bool(2, v)?; + } + if let Some(v) = self.deprecated { + os.write_bool(3, v)?; + } + if let Some(v) = self.map_entry { + os.write_bool(7, v)?; + } + for v in &self.uninterpreted_option { + os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MessageOptions { + MessageOptions::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "message_set_wire_format", + |m: &MessageOptions| { &m.message_set_wire_format }, + |m: &mut MessageOptions| { &mut m.message_set_wire_format }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "no_standard_descriptor_accessor", + |m: &MessageOptions| { &m.no_standard_descriptor_accessor }, + |m: &mut MessageOptions| { &mut m.no_standard_descriptor_accessor }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "deprecated", + |m: &MessageOptions| { &m.deprecated }, + |m: &mut MessageOptions| { &mut m.deprecated }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "map_entry", + |m: &MessageOptions| { &m.map_entry }, + |m: &mut MessageOptions| { &mut m.map_entry }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>( + "uninterpreted_option", + |m: &MessageOptions| { &m.uninterpreted_option }, + |m: &mut MessageOptions| { &mut m.uninterpreted_option }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<MessageOptions>( + "MessageOptions", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MessageOptions { + static mut instance: ::protobuf::lazy::Lazy<MessageOptions> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(MessageOptions::new) + } + } +} + +impl ::protobuf::Clear for MessageOptions { + fn clear(&mut self) { + self.message_set_wire_format = ::std::option::Option::None; + self.no_standard_descriptor_accessor = ::std::option::Option::None; + self.deprecated = ::std::option::Option::None; + self.map_entry = ::std::option::Option::None; + self.uninterpreted_option.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MessageOptions { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MessageOptions { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct FieldOptions { + // message fields + ctype: ::std::option::Option<FieldOptions_CType>, + packed: ::std::option::Option<bool>, + jstype: ::std::option::Option<FieldOptions_JSType>, + lazy: ::std::option::Option<bool>, + deprecated: ::std::option::Option<bool>, + weak: ::std::option::Option<bool>, + uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a FieldOptions { + fn default() -> &'a FieldOptions { + <FieldOptions as ::protobuf::Message>::default_instance() + } +} + +impl FieldOptions { + pub fn new() -> FieldOptions { + ::std::default::Default::default() + } + + // optional .google.protobuf.FieldOptions.CType ctype = 1; + + + pub fn get_ctype(&self) -> FieldOptions_CType { + self.ctype.unwrap_or(FieldOptions_CType::STRING) + } + pub fn clear_ctype(&mut self) { + self.ctype = ::std::option::Option::None; + } + + pub fn has_ctype(&self) -> bool { + self.ctype.is_some() + } + + // Param is passed by value, moved + pub fn set_ctype(&mut self, v: FieldOptions_CType) { + self.ctype = ::std::option::Option::Some(v); + } + + // optional bool packed = 2; + + + pub fn get_packed(&self) -> bool { + self.packed.unwrap_or(false) + } + pub fn clear_packed(&mut self) { + self.packed = ::std::option::Option::None; + } + + pub fn has_packed(&self) -> bool { + self.packed.is_some() + } + + // Param is passed by value, moved + pub fn set_packed(&mut self, v: bool) { + self.packed = ::std::option::Option::Some(v); + } + + // optional .google.protobuf.FieldOptions.JSType jstype = 6; + + + pub fn get_jstype(&self) -> FieldOptions_JSType { + self.jstype.unwrap_or(FieldOptions_JSType::JS_NORMAL) + } + pub fn clear_jstype(&mut self) { + self.jstype = ::std::option::Option::None; + } + + pub fn has_jstype(&self) -> bool { + self.jstype.is_some() + } + + // Param is passed by value, moved + pub fn set_jstype(&mut self, v: FieldOptions_JSType) { + self.jstype = ::std::option::Option::Some(v); + } + + // optional bool lazy = 5; + + + pub fn get_lazy(&self) -> bool { + self.lazy.unwrap_or(false) + } + pub fn clear_lazy(&mut self) { + self.lazy = ::std::option::Option::None; + } + + pub fn has_lazy(&self) -> bool { + self.lazy.is_some() + } + + // Param is passed by value, moved + pub fn set_lazy(&mut self, v: bool) { + self.lazy = ::std::option::Option::Some(v); + } + + // optional bool deprecated = 3; + + + pub fn get_deprecated(&self) -> bool { + self.deprecated.unwrap_or(false) + } + pub fn clear_deprecated(&mut self) { + self.deprecated = ::std::option::Option::None; + } + + pub fn has_deprecated(&self) -> bool { + self.deprecated.is_some() + } + + // Param is passed by value, moved + pub fn set_deprecated(&mut self, v: bool) { + self.deprecated = ::std::option::Option::Some(v); + } + + // optional bool weak = 10; + + + pub fn get_weak(&self) -> bool { + self.weak.unwrap_or(false) + } + pub fn clear_weak(&mut self) { + self.weak = ::std::option::Option::None; + } + + pub fn has_weak(&self) -> bool { + self.weak.is_some() + } + + // Param is passed by value, moved + pub fn set_weak(&mut self, v: bool) { + self.weak = ::std::option::Option::Some(v); + } + + // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; + + + pub fn get_uninterpreted_option(&self) -> &[UninterpretedOption] { + &self.uninterpreted_option + } + pub fn clear_uninterpreted_option(&mut self) { + self.uninterpreted_option.clear(); + } + + // Param is passed by value, moved + pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) { + self.uninterpreted_option = v; + } + + // Mutable pointer to the field. + pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> { + &mut self.uninterpreted_option + } + + // Take field + pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> { + ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for FieldOptions { + 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 ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.ctype, 1, &mut self.unknown_fields)? + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.packed = ::std::option::Option::Some(tmp); + }, + 6 => { + ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.jstype, 6, &mut self.unknown_fields)? + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.lazy = ::std::option::Option::Some(tmp); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.deprecated = ::std::option::Option::Some(tmp); + }, + 10 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.weak = ::std::option::Option::Some(tmp); + }, + 999 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(v) = self.ctype { + my_size += ::protobuf::rt::enum_size(1, v); + } + if let Some(v) = self.packed { + my_size += 2; + } + if let Some(v) = self.jstype { + my_size += ::protobuf::rt::enum_size(6, v); + } + if let Some(v) = self.lazy { + my_size += 2; + } + if let Some(v) = self.deprecated { + my_size += 2; + } + if let Some(v) = self.weak { + my_size += 2; + } + for value in &self.uninterpreted_option { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.ctype { + os.write_enum(1, v.value())?; + } + if let Some(v) = self.packed { + os.write_bool(2, v)?; + } + if let Some(v) = self.jstype { + os.write_enum(6, v.value())?; + } + if let Some(v) = self.lazy { + os.write_bool(5, v)?; + } + if let Some(v) = self.deprecated { + os.write_bool(3, v)?; + } + if let Some(v) = self.weak { + os.write_bool(10, v)?; + } + for v in &self.uninterpreted_option { + os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> FieldOptions { + FieldOptions::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FieldOptions_CType>>( + "ctype", + |m: &FieldOptions| { &m.ctype }, + |m: &mut FieldOptions| { &mut m.ctype }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "packed", + |m: &FieldOptions| { &m.packed }, + |m: &mut FieldOptions| { &mut m.packed }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FieldOptions_JSType>>( + "jstype", + |m: &FieldOptions| { &m.jstype }, + |m: &mut FieldOptions| { &mut m.jstype }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "lazy", + |m: &FieldOptions| { &m.lazy }, + |m: &mut FieldOptions| { &mut m.lazy }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "deprecated", + |m: &FieldOptions| { &m.deprecated }, + |m: &mut FieldOptions| { &mut m.deprecated }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "weak", + |m: &FieldOptions| { &m.weak }, + |m: &mut FieldOptions| { &mut m.weak }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>( + "uninterpreted_option", + |m: &FieldOptions| { &m.uninterpreted_option }, + |m: &mut FieldOptions| { &mut m.uninterpreted_option }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<FieldOptions>( + "FieldOptions", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static FieldOptions { + static mut instance: ::protobuf::lazy::Lazy<FieldOptions> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(FieldOptions::new) + } + } +} + +impl ::protobuf::Clear for FieldOptions { + fn clear(&mut self) { + self.ctype = ::std::option::Option::None; + self.packed = ::std::option::Option::None; + self.jstype = ::std::option::Option::None; + self.lazy = ::std::option::Option::None; + self.deprecated = ::std::option::Option::None; + self.weak = ::std::option::Option::None; + self.uninterpreted_option.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for FieldOptions { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for FieldOptions { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub enum FieldOptions_CType { + STRING = 0, + CORD = 1, + STRING_PIECE = 2, +} + +impl ::protobuf::ProtobufEnum for FieldOptions_CType { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option<FieldOptions_CType> { + match value { + 0 => ::std::option::Option::Some(FieldOptions_CType::STRING), + 1 => ::std::option::Option::Some(FieldOptions_CType::CORD), + 2 => ::std::option::Option::Some(FieldOptions_CType::STRING_PIECE), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [FieldOptions_CType] = &[ + FieldOptions_CType::STRING, + FieldOptions_CType::CORD, + FieldOptions_CType::STRING_PIECE, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new_pb_name::<FieldOptions_CType>("FieldOptions.CType", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for FieldOptions_CType { +} + +impl ::std::default::Default for FieldOptions_CType { + fn default() -> Self { + FieldOptions_CType::STRING + } +} + +impl ::protobuf::reflect::ProtobufValue for FieldOptions_CType { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor()) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub enum FieldOptions_JSType { + JS_NORMAL = 0, + JS_STRING = 1, + JS_NUMBER = 2, +} + +impl ::protobuf::ProtobufEnum for FieldOptions_JSType { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option<FieldOptions_JSType> { + match value { + 0 => ::std::option::Option::Some(FieldOptions_JSType::JS_NORMAL), + 1 => ::std::option::Option::Some(FieldOptions_JSType::JS_STRING), + 2 => ::std::option::Option::Some(FieldOptions_JSType::JS_NUMBER), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [FieldOptions_JSType] = &[ + FieldOptions_JSType::JS_NORMAL, + FieldOptions_JSType::JS_STRING, + FieldOptions_JSType::JS_NUMBER, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new_pb_name::<FieldOptions_JSType>("FieldOptions.JSType", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for FieldOptions_JSType { +} + +impl ::std::default::Default for FieldOptions_JSType { + fn default() -> Self { + FieldOptions_JSType::JS_NORMAL + } +} + +impl ::protobuf::reflect::ProtobufValue for FieldOptions_JSType { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor()) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct OneofOptions { + // message fields + uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a OneofOptions { + fn default() -> &'a OneofOptions { + <OneofOptions as ::protobuf::Message>::default_instance() + } +} + +impl OneofOptions { + pub fn new() -> OneofOptions { + ::std::default::Default::default() + } + + // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; + + + pub fn get_uninterpreted_option(&self) -> &[UninterpretedOption] { + &self.uninterpreted_option + } + pub fn clear_uninterpreted_option(&mut self) { + self.uninterpreted_option.clear(); + } + + // Param is passed by value, moved + pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) { + self.uninterpreted_option = v; + } + + // Mutable pointer to the field. + pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> { + &mut self.uninterpreted_option + } + + // Take field + pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> { + ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for OneofOptions { + 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 ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 999 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.uninterpreted_option { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + for v in &self.uninterpreted_option { + os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> OneofOptions { + OneofOptions::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>( + "uninterpreted_option", + |m: &OneofOptions| { &m.uninterpreted_option }, + |m: &mut OneofOptions| { &mut m.uninterpreted_option }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<OneofOptions>( + "OneofOptions", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static OneofOptions { + static mut instance: ::protobuf::lazy::Lazy<OneofOptions> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(OneofOptions::new) + } + } +} + +impl ::protobuf::Clear for OneofOptions { + fn clear(&mut self) { + self.uninterpreted_option.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for OneofOptions { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for OneofOptions { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct EnumOptions { + // message fields + allow_alias: ::std::option::Option<bool>, + deprecated: ::std::option::Option<bool>, + uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a EnumOptions { + fn default() -> &'a EnumOptions { + <EnumOptions as ::protobuf::Message>::default_instance() + } +} + +impl EnumOptions { + pub fn new() -> EnumOptions { + ::std::default::Default::default() + } + + // optional bool allow_alias = 2; + + + pub fn get_allow_alias(&self) -> bool { + self.allow_alias.unwrap_or(false) + } + pub fn clear_allow_alias(&mut self) { + self.allow_alias = ::std::option::Option::None; + } + + pub fn has_allow_alias(&self) -> bool { + self.allow_alias.is_some() + } + + // Param is passed by value, moved + pub fn set_allow_alias(&mut self, v: bool) { + self.allow_alias = ::std::option::Option::Some(v); + } + + // optional bool deprecated = 3; + + + pub fn get_deprecated(&self) -> bool { + self.deprecated.unwrap_or(false) + } + pub fn clear_deprecated(&mut self) { + self.deprecated = ::std::option::Option::None; + } + + pub fn has_deprecated(&self) -> bool { + self.deprecated.is_some() + } + + // Param is passed by value, moved + pub fn set_deprecated(&mut self, v: bool) { + self.deprecated = ::std::option::Option::Some(v); + } + + // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; + + + pub fn get_uninterpreted_option(&self) -> &[UninterpretedOption] { + &self.uninterpreted_option + } + pub fn clear_uninterpreted_option(&mut self) { + self.uninterpreted_option.clear(); + } + + // Param is passed by value, moved + pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) { + self.uninterpreted_option = v; + } + + // Mutable pointer to the field. + pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> { + &mut self.uninterpreted_option + } + + // Take field + pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> { + ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for EnumOptions { + 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 ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.allow_alias = ::std::option::Option::Some(tmp); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.deprecated = ::std::option::Option::Some(tmp); + }, + 999 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(v) = self.allow_alias { + my_size += 2; + } + if let Some(v) = self.deprecated { + my_size += 2; + } + for value in &self.uninterpreted_option { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.allow_alias { + os.write_bool(2, v)?; + } + if let Some(v) = self.deprecated { + os.write_bool(3, v)?; + } + for v in &self.uninterpreted_option { + os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> EnumOptions { + EnumOptions::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "allow_alias", + |m: &EnumOptions| { &m.allow_alias }, + |m: &mut EnumOptions| { &mut m.allow_alias }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "deprecated", + |m: &EnumOptions| { &m.deprecated }, + |m: &mut EnumOptions| { &mut m.deprecated }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>( + "uninterpreted_option", + |m: &EnumOptions| { &m.uninterpreted_option }, + |m: &mut EnumOptions| { &mut m.uninterpreted_option }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<EnumOptions>( + "EnumOptions", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static EnumOptions { + static mut instance: ::protobuf::lazy::Lazy<EnumOptions> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(EnumOptions::new) + } + } +} + +impl ::protobuf::Clear for EnumOptions { + fn clear(&mut self) { + self.allow_alias = ::std::option::Option::None; + self.deprecated = ::std::option::Option::None; + self.uninterpreted_option.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for EnumOptions { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for EnumOptions { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct EnumValueOptions { + // message fields + deprecated: ::std::option::Option<bool>, + uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a EnumValueOptions { + fn default() -> &'a EnumValueOptions { + <EnumValueOptions as ::protobuf::Message>::default_instance() + } +} + +impl EnumValueOptions { + pub fn new() -> EnumValueOptions { + ::std::default::Default::default() + } + + // optional bool deprecated = 1; + + + pub fn get_deprecated(&self) -> bool { + self.deprecated.unwrap_or(false) + } + pub fn clear_deprecated(&mut self) { + self.deprecated = ::std::option::Option::None; + } + + pub fn has_deprecated(&self) -> bool { + self.deprecated.is_some() + } + + // Param is passed by value, moved + pub fn set_deprecated(&mut self, v: bool) { + self.deprecated = ::std::option::Option::Some(v); + } + + // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; + + + pub fn get_uninterpreted_option(&self) -> &[UninterpretedOption] { + &self.uninterpreted_option + } + pub fn clear_uninterpreted_option(&mut self) { + self.uninterpreted_option.clear(); + } + + // Param is passed by value, moved + pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) { + self.uninterpreted_option = v; + } + + // Mutable pointer to the field. + pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> { + &mut self.uninterpreted_option + } + + // Take field + pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> { + ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for EnumValueOptions { + 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 ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.deprecated = ::std::option::Option::Some(tmp); + }, + 999 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(v) = self.deprecated { + my_size += 2; + } + for value in &self.uninterpreted_option { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.deprecated { + os.write_bool(1, v)?; + } + for v in &self.uninterpreted_option { + os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> EnumValueOptions { + EnumValueOptions::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "deprecated", + |m: &EnumValueOptions| { &m.deprecated }, + |m: &mut EnumValueOptions| { &mut m.deprecated }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>( + "uninterpreted_option", + |m: &EnumValueOptions| { &m.uninterpreted_option }, + |m: &mut EnumValueOptions| { &mut m.uninterpreted_option }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<EnumValueOptions>( + "EnumValueOptions", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static EnumValueOptions { + static mut instance: ::protobuf::lazy::Lazy<EnumValueOptions> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(EnumValueOptions::new) + } + } +} + +impl ::protobuf::Clear for EnumValueOptions { + fn clear(&mut self) { + self.deprecated = ::std::option::Option::None; + self.uninterpreted_option.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for EnumValueOptions { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for EnumValueOptions { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct ServiceOptions { + // message fields + deprecated: ::std::option::Option<bool>, + uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ServiceOptions { + fn default() -> &'a ServiceOptions { + <ServiceOptions as ::protobuf::Message>::default_instance() + } +} + +impl ServiceOptions { + pub fn new() -> ServiceOptions { + ::std::default::Default::default() + } + + // optional bool deprecated = 33; + + + pub fn get_deprecated(&self) -> bool { + self.deprecated.unwrap_or(false) + } + pub fn clear_deprecated(&mut self) { + self.deprecated = ::std::option::Option::None; + } + + pub fn has_deprecated(&self) -> bool { + self.deprecated.is_some() + } + + // Param is passed by value, moved + pub fn set_deprecated(&mut self, v: bool) { + self.deprecated = ::std::option::Option::Some(v); + } + + // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; + + + pub fn get_uninterpreted_option(&self) -> &[UninterpretedOption] { + &self.uninterpreted_option + } + pub fn clear_uninterpreted_option(&mut self) { + self.uninterpreted_option.clear(); + } + + // Param is passed by value, moved + pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) { + self.uninterpreted_option = v; + } + + // Mutable pointer to the field. + pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> { + &mut self.uninterpreted_option + } + + // Take field + pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> { + ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for ServiceOptions { + 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 ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 33 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.deprecated = ::std::option::Option::Some(tmp); + }, + 999 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(v) = self.deprecated { + my_size += 3; + } + for value in &self.uninterpreted_option { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.deprecated { + os.write_bool(33, v)?; + } + for v in &self.uninterpreted_option { + os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ServiceOptions { + ServiceOptions::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "deprecated", + |m: &ServiceOptions| { &m.deprecated }, + |m: &mut ServiceOptions| { &mut m.deprecated }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>( + "uninterpreted_option", + |m: &ServiceOptions| { &m.uninterpreted_option }, + |m: &mut ServiceOptions| { &mut m.uninterpreted_option }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<ServiceOptions>( + "ServiceOptions", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ServiceOptions { + static mut instance: ::protobuf::lazy::Lazy<ServiceOptions> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(ServiceOptions::new) + } + } +} + +impl ::protobuf::Clear for ServiceOptions { + fn clear(&mut self) { + self.deprecated = ::std::option::Option::None; + self.uninterpreted_option.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ServiceOptions { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ServiceOptions { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct MethodOptions { + // message fields + deprecated: ::std::option::Option<bool>, + uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a MethodOptions { + fn default() -> &'a MethodOptions { + <MethodOptions as ::protobuf::Message>::default_instance() + } +} + +impl MethodOptions { + pub fn new() -> MethodOptions { + ::std::default::Default::default() + } + + // optional bool deprecated = 33; + + + pub fn get_deprecated(&self) -> bool { + self.deprecated.unwrap_or(false) + } + pub fn clear_deprecated(&mut self) { + self.deprecated = ::std::option::Option::None; + } + + pub fn has_deprecated(&self) -> bool { + self.deprecated.is_some() + } + + // Param is passed by value, moved + pub fn set_deprecated(&mut self, v: bool) { + self.deprecated = ::std::option::Option::Some(v); + } + + // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; + + + pub fn get_uninterpreted_option(&self) -> &[UninterpretedOption] { + &self.uninterpreted_option + } + pub fn clear_uninterpreted_option(&mut self) { + self.uninterpreted_option.clear(); + } + + // Param is passed by value, moved + pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) { + self.uninterpreted_option = v; + } + + // Mutable pointer to the field. + pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> { + &mut self.uninterpreted_option + } + + // Take field + pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> { + ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for MethodOptions { + 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 ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 33 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.deprecated = ::std::option::Option::Some(tmp); + }, + 999 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(v) = self.deprecated { + my_size += 3; + } + for value in &self.uninterpreted_option { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(v) = self.deprecated { + os.write_bool(33, v)?; + } + for v in &self.uninterpreted_option { + os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> MethodOptions { + MethodOptions::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "deprecated", + |m: &MethodOptions| { &m.deprecated }, + |m: &mut MethodOptions| { &mut m.deprecated }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>( + "uninterpreted_option", + |m: &MethodOptions| { &m.uninterpreted_option }, + |m: &mut MethodOptions| { &mut m.uninterpreted_option }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<MethodOptions>( + "MethodOptions", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static MethodOptions { + static mut instance: ::protobuf::lazy::Lazy<MethodOptions> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(MethodOptions::new) + } + } +} + +impl ::protobuf::Clear for MethodOptions { + fn clear(&mut self) { + self.deprecated = ::std::option::Option::None; + self.uninterpreted_option.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for MethodOptions { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for MethodOptions { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct UninterpretedOption { + // message fields + name: ::protobuf::RepeatedField<UninterpretedOption_NamePart>, + identifier_value: ::protobuf::SingularField<::std::string::String>, + positive_int_value: ::std::option::Option<u64>, + negative_int_value: ::std::option::Option<i64>, + double_value: ::std::option::Option<f64>, + string_value: ::protobuf::SingularField<::std::vec::Vec<u8>>, + aggregate_value: ::protobuf::SingularField<::std::string::String>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UninterpretedOption { + fn default() -> &'a UninterpretedOption { + <UninterpretedOption as ::protobuf::Message>::default_instance() + } +} + +impl UninterpretedOption { + pub fn new() -> UninterpretedOption { + ::std::default::Default::default() + } + + // repeated .google.protobuf.UninterpretedOption.NamePart name = 2; + + + pub fn get_name(&self) -> &[UninterpretedOption_NamePart] { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption_NamePart>) { + self.name = v; + } + + // Mutable pointer to the field. + pub fn mut_name(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption_NamePart> { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption_NamePart> { + ::std::mem::replace(&mut self.name, ::protobuf::RepeatedField::new()) + } + + // optional string identifier_value = 3; + + + pub fn get_identifier_value(&self) -> &str { + match self.identifier_value.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_identifier_value(&mut self) { + self.identifier_value.clear(); + } + + pub fn has_identifier_value(&self) -> bool { + self.identifier_value.is_some() + } + + // Param is passed by value, moved + pub fn set_identifier_value(&mut self, v: ::std::string::String) { + self.identifier_value = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_identifier_value(&mut self) -> &mut ::std::string::String { + if self.identifier_value.is_none() { + self.identifier_value.set_default(); + } + self.identifier_value.as_mut().unwrap() + } + + // Take field + pub fn take_identifier_value(&mut self) -> ::std::string::String { + self.identifier_value.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional uint64 positive_int_value = 4; + + + pub fn get_positive_int_value(&self) -> u64 { + self.positive_int_value.unwrap_or(0) + } + pub fn clear_positive_int_value(&mut self) { + self.positive_int_value = ::std::option::Option::None; + } + + pub fn has_positive_int_value(&self) -> bool { + self.positive_int_value.is_some() + } + + // Param is passed by value, moved + pub fn set_positive_int_value(&mut self, v: u64) { + self.positive_int_value = ::std::option::Option::Some(v); + } + + // optional int64 negative_int_value = 5; + + + pub fn get_negative_int_value(&self) -> i64 { + self.negative_int_value.unwrap_or(0) + } + pub fn clear_negative_int_value(&mut self) { + self.negative_int_value = ::std::option::Option::None; + } + + pub fn has_negative_int_value(&self) -> bool { + self.negative_int_value.is_some() + } + + // Param is passed by value, moved + pub fn set_negative_int_value(&mut self, v: i64) { + self.negative_int_value = ::std::option::Option::Some(v); + } + + // optional double double_value = 6; + + + pub fn get_double_value(&self) -> f64 { + self.double_value.unwrap_or(0.) + } + pub fn clear_double_value(&mut self) { + self.double_value = ::std::option::Option::None; + } + + pub fn has_double_value(&self) -> bool { + self.double_value.is_some() + } + + // Param is passed by value, moved + pub fn set_double_value(&mut self, v: f64) { + self.double_value = ::std::option::Option::Some(v); + } + + // optional bytes string_value = 7; + + + pub fn get_string_value(&self) -> &[u8] { + match self.string_value.as_ref() { + Some(v) => &v, + None => &[], + } + } + pub fn clear_string_value(&mut self) { + self.string_value.clear(); + } + + pub fn has_string_value(&self) -> bool { + self.string_value.is_some() + } + + // Param is passed by value, moved + pub fn set_string_value(&mut self, v: ::std::vec::Vec<u8>) { + self.string_value = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_string_value(&mut self) -> &mut ::std::vec::Vec<u8> { + if self.string_value.is_none() { + self.string_value.set_default(); + } + self.string_value.as_mut().unwrap() + } + + // Take field + pub fn take_string_value(&mut self) -> ::std::vec::Vec<u8> { + self.string_value.take().unwrap_or_else(|| ::std::vec::Vec::new()) + } + + // optional string aggregate_value = 8; + + + pub fn get_aggregate_value(&self) -> &str { + match self.aggregate_value.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_aggregate_value(&mut self) { + self.aggregate_value.clear(); + } + + pub fn has_aggregate_value(&self) -> bool { + self.aggregate_value.is_some() + } + + // Param is passed by value, moved + pub fn set_aggregate_value(&mut self, v: ::std::string::String) { + self.aggregate_value = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_aggregate_value(&mut self) -> &mut ::std::string::String { + if self.aggregate_value.is_none() { + self.aggregate_value.set_default(); + } + self.aggregate_value.as_mut().unwrap() + } + + // Take field + pub fn take_aggregate_value(&mut self) -> ::std::string::String { + self.aggregate_value.take().unwrap_or_else(|| ::std::string::String::new()) + } +} + +impl ::protobuf::Message for UninterpretedOption { + fn is_initialized(&self) -> bool { + for v in &self.name { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.name)?; + }, + 3 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.identifier_value)?; + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_uint64()?; + self.positive_int_value = ::std::option::Option::Some(tmp); + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.negative_int_value = ::std::option::Option::Some(tmp); + }, + 6 => { + if wire_type != ::protobuf::wire_format::WireTypeFixed64 { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_double()?; + self.double_value = ::std::option::Option::Some(tmp); + }, + 7 => { + ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.string_value)?; + }, + 8 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.aggregate_value)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.name { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if let Some(ref v) = self.identifier_value.as_ref() { + my_size += ::protobuf::rt::string_size(3, &v); + } + if let Some(v) = self.positive_int_value { + my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint); + } + if let Some(v) = self.negative_int_value { + my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint); + } + if let Some(v) = self.double_value { + my_size += 9; + } + if let Some(ref v) = self.string_value.as_ref() { + my_size += ::protobuf::rt::bytes_size(7, &v); + } + if let Some(ref v) = self.aggregate_value.as_ref() { + my_size += ::protobuf::rt::string_size(8, &v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + for v in &self.name { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if let Some(ref v) = self.identifier_value.as_ref() { + os.write_string(3, &v)?; + } + if let Some(v) = self.positive_int_value { + os.write_uint64(4, v)?; + } + if let Some(v) = self.negative_int_value { + os.write_int64(5, v)?; + } + if let Some(v) = self.double_value { + os.write_double(6, v)?; + } + if let Some(ref v) = self.string_value.as_ref() { + os.write_bytes(7, &v)?; + } + if let Some(ref v) = self.aggregate_value.as_ref() { + os.write_string(8, &v)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UninterpretedOption { + UninterpretedOption::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption_NamePart>>( + "name", + |m: &UninterpretedOption| { &m.name }, + |m: &mut UninterpretedOption| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "identifier_value", + |m: &UninterpretedOption| { &m.identifier_value }, + |m: &mut UninterpretedOption| { &mut m.identifier_value }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>( + "positive_int_value", + |m: &UninterpretedOption| { &m.positive_int_value }, + |m: &mut UninterpretedOption| { &mut m.positive_int_value }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "negative_int_value", + |m: &UninterpretedOption| { &m.negative_int_value }, + |m: &mut UninterpretedOption| { &mut m.negative_int_value }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeDouble>( + "double_value", + |m: &UninterpretedOption| { &m.double_value }, + |m: &mut UninterpretedOption| { &mut m.double_value }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "string_value", + |m: &UninterpretedOption| { &m.string_value }, + |m: &mut UninterpretedOption| { &mut m.string_value }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "aggregate_value", + |m: &UninterpretedOption| { &m.aggregate_value }, + |m: &mut UninterpretedOption| { &mut m.aggregate_value }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<UninterpretedOption>( + "UninterpretedOption", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UninterpretedOption { + static mut instance: ::protobuf::lazy::Lazy<UninterpretedOption> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(UninterpretedOption::new) + } + } +} + +impl ::protobuf::Clear for UninterpretedOption { + fn clear(&mut self) { + self.name.clear(); + self.identifier_value.clear(); + self.positive_int_value = ::std::option::Option::None; + self.negative_int_value = ::std::option::Option::None; + self.double_value = ::std::option::Option::None; + self.string_value.clear(); + self.aggregate_value.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UninterpretedOption { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UninterpretedOption { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct UninterpretedOption_NamePart { + // message fields + name_part: ::protobuf::SingularField<::std::string::String>, + is_extension: ::std::option::Option<bool>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UninterpretedOption_NamePart { + fn default() -> &'a UninterpretedOption_NamePart { + <UninterpretedOption_NamePart as ::protobuf::Message>::default_instance() + } +} + +impl UninterpretedOption_NamePart { + pub fn new() -> UninterpretedOption_NamePart { + ::std::default::Default::default() + } + + // required string name_part = 1; + + + pub fn get_name_part(&self) -> &str { + match self.name_part.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_name_part(&mut self) { + self.name_part.clear(); + } + + pub fn has_name_part(&self) -> bool { + self.name_part.is_some() + } + + // Param is passed by value, moved + pub fn set_name_part(&mut self, v: ::std::string::String) { + self.name_part = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name_part(&mut self) -> &mut ::std::string::String { + if self.name_part.is_none() { + self.name_part.set_default(); + } + self.name_part.as_mut().unwrap() + } + + // Take field + pub fn take_name_part(&mut self) -> ::std::string::String { + self.name_part.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // required bool is_extension = 2; + + + pub fn get_is_extension(&self) -> bool { + self.is_extension.unwrap_or(false) + } + pub fn clear_is_extension(&mut self) { + self.is_extension = ::std::option::Option::None; + } + + pub fn has_is_extension(&self) -> bool { + self.is_extension.is_some() + } + + // Param is passed by value, moved + pub fn set_is_extension(&mut self, v: bool) { + self.is_extension = ::std::option::Option::Some(v); + } +} + +impl ::protobuf::Message for UninterpretedOption_NamePart { + fn is_initialized(&self) -> bool { + if self.name_part.is_none() { + return false; + } + if self.is_extension.is_none() { + return false; + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name_part)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.is_extension = ::std::option::Option::Some(tmp); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.name_part.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(v) = self.is_extension { + my_size += 2; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.name_part.as_ref() { + os.write_string(1, &v)?; + } + if let Some(v) = self.is_extension { + os.write_bool(2, v)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UninterpretedOption_NamePart { + UninterpretedOption_NamePart::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name_part", + |m: &UninterpretedOption_NamePart| { &m.name_part }, + |m: &mut UninterpretedOption_NamePart| { &mut m.name_part }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "is_extension", + |m: &UninterpretedOption_NamePart| { &m.is_extension }, + |m: &mut UninterpretedOption_NamePart| { &mut m.is_extension }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<UninterpretedOption_NamePart>( + "UninterpretedOption.NamePart", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UninterpretedOption_NamePart { + static mut instance: ::protobuf::lazy::Lazy<UninterpretedOption_NamePart> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(UninterpretedOption_NamePart::new) + } + } +} + +impl ::protobuf::Clear for UninterpretedOption_NamePart { + fn clear(&mut self) { + self.name_part.clear(); + self.is_extension = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UninterpretedOption_NamePart { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UninterpretedOption_NamePart { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct SourceCodeInfo { + // message fields + location: ::protobuf::RepeatedField<SourceCodeInfo_Location>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a SourceCodeInfo { + fn default() -> &'a SourceCodeInfo { + <SourceCodeInfo as ::protobuf::Message>::default_instance() + } +} + +impl SourceCodeInfo { + pub fn new() -> SourceCodeInfo { + ::std::default::Default::default() + } + + // repeated .google.protobuf.SourceCodeInfo.Location location = 1; + + + pub fn get_location(&self) -> &[SourceCodeInfo_Location] { + &self.location + } + pub fn clear_location(&mut self) { + self.location.clear(); + } + + // Param is passed by value, moved + pub fn set_location(&mut self, v: ::protobuf::RepeatedField<SourceCodeInfo_Location>) { + self.location = v; + } + + // Mutable pointer to the field. + pub fn mut_location(&mut self) -> &mut ::protobuf::RepeatedField<SourceCodeInfo_Location> { + &mut self.location + } + + // Take field + pub fn take_location(&mut self) -> ::protobuf::RepeatedField<SourceCodeInfo_Location> { + ::std::mem::replace(&mut self.location, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for SourceCodeInfo { + fn is_initialized(&self) -> bool { + for v in &self.location { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.location)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.location { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + for v in &self.location { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> SourceCodeInfo { + SourceCodeInfo::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SourceCodeInfo_Location>>( + "location", + |m: &SourceCodeInfo| { &m.location }, + |m: &mut SourceCodeInfo| { &mut m.location }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<SourceCodeInfo>( + "SourceCodeInfo", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static SourceCodeInfo { + static mut instance: ::protobuf::lazy::Lazy<SourceCodeInfo> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(SourceCodeInfo::new) + } + } +} + +impl ::protobuf::Clear for SourceCodeInfo { + fn clear(&mut self) { + self.location.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for SourceCodeInfo { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for SourceCodeInfo { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct SourceCodeInfo_Location { + // message fields + path: ::std::vec::Vec<i32>, + span: ::std::vec::Vec<i32>, + leading_comments: ::protobuf::SingularField<::std::string::String>, + trailing_comments: ::protobuf::SingularField<::std::string::String>, + leading_detached_comments: ::protobuf::RepeatedField<::std::string::String>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a SourceCodeInfo_Location { + fn default() -> &'a SourceCodeInfo_Location { + <SourceCodeInfo_Location as ::protobuf::Message>::default_instance() + } +} + +impl SourceCodeInfo_Location { + pub fn new() -> SourceCodeInfo_Location { + ::std::default::Default::default() + } + + // repeated int32 path = 1; + + + pub fn get_path(&self) -> &[i32] { + &self.path + } + pub fn clear_path(&mut self) { + self.path.clear(); + } + + // Param is passed by value, moved + pub fn set_path(&mut self, v: ::std::vec::Vec<i32>) { + self.path = v; + } + + // Mutable pointer to the field. + pub fn mut_path(&mut self) -> &mut ::std::vec::Vec<i32> { + &mut self.path + } + + // Take field + pub fn take_path(&mut self) -> ::std::vec::Vec<i32> { + ::std::mem::replace(&mut self.path, ::std::vec::Vec::new()) + } + + // repeated int32 span = 2; + + + pub fn get_span(&self) -> &[i32] { + &self.span + } + pub fn clear_span(&mut self) { + self.span.clear(); + } + + // Param is passed by value, moved + pub fn set_span(&mut self, v: ::std::vec::Vec<i32>) { + self.span = v; + } + + // Mutable pointer to the field. + pub fn mut_span(&mut self) -> &mut ::std::vec::Vec<i32> { + &mut self.span + } + + // Take field + pub fn take_span(&mut self) -> ::std::vec::Vec<i32> { + ::std::mem::replace(&mut self.span, ::std::vec::Vec::new()) + } + + // optional string leading_comments = 3; + + + pub fn get_leading_comments(&self) -> &str { + match self.leading_comments.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_leading_comments(&mut self) { + self.leading_comments.clear(); + } + + pub fn has_leading_comments(&self) -> bool { + self.leading_comments.is_some() + } + + // Param is passed by value, moved + pub fn set_leading_comments(&mut self, v: ::std::string::String) { + self.leading_comments = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_leading_comments(&mut self) -> &mut ::std::string::String { + if self.leading_comments.is_none() { + self.leading_comments.set_default(); + } + self.leading_comments.as_mut().unwrap() + } + + // Take field + pub fn take_leading_comments(&mut self) -> ::std::string::String { + self.leading_comments.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional string trailing_comments = 4; + + + pub fn get_trailing_comments(&self) -> &str { + match self.trailing_comments.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_trailing_comments(&mut self) { + self.trailing_comments.clear(); + } + + pub fn has_trailing_comments(&self) -> bool { + self.trailing_comments.is_some() + } + + // Param is passed by value, moved + pub fn set_trailing_comments(&mut self, v: ::std::string::String) { + self.trailing_comments = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_trailing_comments(&mut self) -> &mut ::std::string::String { + if self.trailing_comments.is_none() { + self.trailing_comments.set_default(); + } + self.trailing_comments.as_mut().unwrap() + } + + // Take field + pub fn take_trailing_comments(&mut self) -> ::std::string::String { + self.trailing_comments.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // repeated string leading_detached_comments = 6; + + + pub fn get_leading_detached_comments(&self) -> &[::std::string::String] { + &self.leading_detached_comments + } + pub fn clear_leading_detached_comments(&mut self) { + self.leading_detached_comments.clear(); + } + + // Param is passed by value, moved + pub fn set_leading_detached_comments(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.leading_detached_comments = v; + } + + // Mutable pointer to the field. + pub fn mut_leading_detached_comments(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.leading_detached_comments + } + + // Take field + pub fn take_leading_detached_comments(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.leading_detached_comments, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for SourceCodeInfo_Location { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.path)?; + }, + 2 => { + ::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.span)?; + }, + 3 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.leading_comments)?; + }, + 4 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.trailing_comments)?; + }, + 6 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.leading_detached_comments)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.path.is_empty() { + my_size += ::protobuf::rt::vec_packed_varint_size(1, &self.path); + } + if !self.span.is_empty() { + my_size += ::protobuf::rt::vec_packed_varint_size(2, &self.span); + } + if let Some(ref v) = self.leading_comments.as_ref() { + my_size += ::protobuf::rt::string_size(3, &v); + } + if let Some(ref v) = self.trailing_comments.as_ref() { + my_size += ::protobuf::rt::string_size(4, &v); + } + for value in &self.leading_detached_comments { + my_size += ::protobuf::rt::string_size(6, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.path.is_empty() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + // TODO: Data size is computed again, it should be cached + os.write_raw_varint32(::protobuf::rt::vec_packed_varint_data_size(&self.path))?; + for v in &self.path { + os.write_int32_no_tag(*v)?; + }; + } + if !self.span.is_empty() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + // TODO: Data size is computed again, it should be cached + os.write_raw_varint32(::protobuf::rt::vec_packed_varint_data_size(&self.span))?; + for v in &self.span { + os.write_int32_no_tag(*v)?; + }; + } + if let Some(ref v) = self.leading_comments.as_ref() { + os.write_string(3, &v)?; + } + if let Some(ref v) = self.trailing_comments.as_ref() { + os.write_string(4, &v)?; + } + for v in &self.leading_detached_comments { + os.write_string(6, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> SourceCodeInfo_Location { + SourceCodeInfo_Location::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "path", + |m: &SourceCodeInfo_Location| { &m.path }, + |m: &mut SourceCodeInfo_Location| { &mut m.path }, + )); + fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "span", + |m: &SourceCodeInfo_Location| { &m.span }, + |m: &mut SourceCodeInfo_Location| { &mut m.span }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "leading_comments", + |m: &SourceCodeInfo_Location| { &m.leading_comments }, + |m: &mut SourceCodeInfo_Location| { &mut m.leading_comments }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "trailing_comments", + |m: &SourceCodeInfo_Location| { &m.trailing_comments }, + |m: &mut SourceCodeInfo_Location| { &mut m.trailing_comments }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "leading_detached_comments", + |m: &SourceCodeInfo_Location| { &m.leading_detached_comments }, + |m: &mut SourceCodeInfo_Location| { &mut m.leading_detached_comments }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<SourceCodeInfo_Location>( + "SourceCodeInfo.Location", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static SourceCodeInfo_Location { + static mut instance: ::protobuf::lazy::Lazy<SourceCodeInfo_Location> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(SourceCodeInfo_Location::new) + } + } +} + +impl ::protobuf::Clear for SourceCodeInfo_Location { + fn clear(&mut self) { + self.path.clear(); + self.span.clear(); + self.leading_comments.clear(); + self.trailing_comments.clear(); + self.leading_detached_comments.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for SourceCodeInfo_Location { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for SourceCodeInfo_Location { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct GeneratedCodeInfo { + // message fields + annotation: ::protobuf::RepeatedField<GeneratedCodeInfo_Annotation>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GeneratedCodeInfo { + fn default() -> &'a GeneratedCodeInfo { + <GeneratedCodeInfo as ::protobuf::Message>::default_instance() + } +} + +impl GeneratedCodeInfo { + pub fn new() -> GeneratedCodeInfo { + ::std::default::Default::default() + } + + // repeated .google.protobuf.GeneratedCodeInfo.Annotation annotation = 1; + + + pub fn get_annotation(&self) -> &[GeneratedCodeInfo_Annotation] { + &self.annotation + } + pub fn clear_annotation(&mut self) { + self.annotation.clear(); + } + + // Param is passed by value, moved + pub fn set_annotation(&mut self, v: ::protobuf::RepeatedField<GeneratedCodeInfo_Annotation>) { + self.annotation = v; + } + + // Mutable pointer to the field. + pub fn mut_annotation(&mut self) -> &mut ::protobuf::RepeatedField<GeneratedCodeInfo_Annotation> { + &mut self.annotation + } + + // Take field + pub fn take_annotation(&mut self) -> ::protobuf::RepeatedField<GeneratedCodeInfo_Annotation> { + ::std::mem::replace(&mut self.annotation, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for GeneratedCodeInfo { + fn is_initialized(&self) -> bool { + for v in &self.annotation { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.annotation)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.annotation { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + for v in &self.annotation { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GeneratedCodeInfo { + GeneratedCodeInfo::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<GeneratedCodeInfo_Annotation>>( + "annotation", + |m: &GeneratedCodeInfo| { &m.annotation }, + |m: &mut GeneratedCodeInfo| { &mut m.annotation }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<GeneratedCodeInfo>( + "GeneratedCodeInfo", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GeneratedCodeInfo { + static mut instance: ::protobuf::lazy::Lazy<GeneratedCodeInfo> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(GeneratedCodeInfo::new) + } + } +} + +impl ::protobuf::Clear for GeneratedCodeInfo { + fn clear(&mut self) { + self.annotation.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GeneratedCodeInfo { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GeneratedCodeInfo { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct GeneratedCodeInfo_Annotation { + // message fields + path: ::std::vec::Vec<i32>, + source_file: ::protobuf::SingularField<::std::string::String>, + begin: ::std::option::Option<i32>, + end: ::std::option::Option<i32>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a GeneratedCodeInfo_Annotation { + fn default() -> &'a GeneratedCodeInfo_Annotation { + <GeneratedCodeInfo_Annotation as ::protobuf::Message>::default_instance() + } +} + +impl GeneratedCodeInfo_Annotation { + pub fn new() -> GeneratedCodeInfo_Annotation { + ::std::default::Default::default() + } + + // repeated int32 path = 1; + + + pub fn get_path(&self) -> &[i32] { + &self.path + } + pub fn clear_path(&mut self) { + self.path.clear(); + } + + // Param is passed by value, moved + pub fn set_path(&mut self, v: ::std::vec::Vec<i32>) { + self.path = v; + } + + // Mutable pointer to the field. + pub fn mut_path(&mut self) -> &mut ::std::vec::Vec<i32> { + &mut self.path + } + + // Take field + pub fn take_path(&mut self) -> ::std::vec::Vec<i32> { + ::std::mem::replace(&mut self.path, ::std::vec::Vec::new()) + } + + // optional string source_file = 2; + + + pub fn get_source_file(&self) -> &str { + match self.source_file.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_source_file(&mut self) { + self.source_file.clear(); + } + + pub fn has_source_file(&self) -> bool { + self.source_file.is_some() + } + + // Param is passed by value, moved + pub fn set_source_file(&mut self, v: ::std::string::String) { + self.source_file = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_source_file(&mut self) -> &mut ::std::string::String { + if self.source_file.is_none() { + self.source_file.set_default(); + } + self.source_file.as_mut().unwrap() + } + + // Take field + pub fn take_source_file(&mut self) -> ::std::string::String { + self.source_file.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional int32 begin = 3; + + + pub fn get_begin(&self) -> i32 { + self.begin.unwrap_or(0) + } + pub fn clear_begin(&mut self) { + self.begin = ::std::option::Option::None; + } + + pub fn has_begin(&self) -> bool { + self.begin.is_some() + } + + // Param is passed by value, moved + pub fn set_begin(&mut self, v: i32) { + self.begin = ::std::option::Option::Some(v); + } + + // optional int32 end = 4; + + + pub fn get_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); + } +} + +impl ::protobuf::Message for GeneratedCodeInfo_Annotation { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.path)?; + }, + 2 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.source_file)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.begin = ::std::option::Option::Some(tmp); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.end = ::std::option::Option::Some(tmp); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.path.is_empty() { + my_size += ::protobuf::rt::vec_packed_varint_size(1, &self.path); + } + if let Some(ref v) = self.source_file.as_ref() { + my_size += ::protobuf::rt::string_size(2, &v); + } + if let Some(v) = self.begin { + my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint); + } + if let Some(v) = self.end { + my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.path.is_empty() { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + // TODO: Data size is computed again, it should be cached + os.write_raw_varint32(::protobuf::rt::vec_packed_varint_data_size(&self.path))?; + for v in &self.path { + os.write_int32_no_tag(*v)?; + }; + } + if let Some(ref v) = self.source_file.as_ref() { + os.write_string(2, &v)?; + } + if let Some(v) = self.begin { + os.write_int32(3, v)?; + } + if let Some(v) = self.end { + os.write_int32(4, v)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> GeneratedCodeInfo_Annotation { + GeneratedCodeInfo_Annotation::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "path", + |m: &GeneratedCodeInfo_Annotation| { &m.path }, + |m: &mut GeneratedCodeInfo_Annotation| { &mut m.path }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "source_file", + |m: &GeneratedCodeInfo_Annotation| { &m.source_file }, + |m: &mut GeneratedCodeInfo_Annotation| { &mut m.source_file }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "begin", + |m: &GeneratedCodeInfo_Annotation| { &m.begin }, + |m: &mut GeneratedCodeInfo_Annotation| { &mut m.begin }, + )); + fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "end", + |m: &GeneratedCodeInfo_Annotation| { &m.end }, + |m: &mut GeneratedCodeInfo_Annotation| { &mut m.end }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<GeneratedCodeInfo_Annotation>( + "GeneratedCodeInfo.Annotation", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static GeneratedCodeInfo_Annotation { + static mut instance: ::protobuf::lazy::Lazy<GeneratedCodeInfo_Annotation> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(GeneratedCodeInfo_Annotation::new) + } + } +} + +impl ::protobuf::Clear for GeneratedCodeInfo_Annotation { + fn clear(&mut self) { + self.path.clear(); + self.source_file.clear(); + self.begin = ::std::option::Option::None; + self.end = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for GeneratedCodeInfo_Annotation { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for GeneratedCodeInfo_Annotation { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x20google/protobuf/descriptor.proto\x12\x0fgoogle.protobuf\"M\n\x11Fi\ + leDescriptorSet\x128\n\x04file\x18\x01\x20\x03(\x0b2$.google.protobuf.Fi\ + leDescriptorProtoR\x04file\"\xe4\x04\n\x13FileDescriptorProto\x12\x12\n\ + \x04name\x18\x01\x20\x01(\tR\x04name\x12\x18\n\x07package\x18\x02\x20\ + \x01(\tR\x07package\x12\x1e\n\ndependency\x18\x03\x20\x03(\tR\ndependenc\ + y\x12+\n\x11public_dependency\x18\n\x20\x03(\x05R\x10publicDependency\ + \x12'\n\x0fweak_dependency\x18\x0b\x20\x03(\x05R\x0eweakDependency\x12C\ + \n\x0cmessage_type\x18\x04\x20\x03(\x0b2\x20.google.protobuf.DescriptorP\ + rotoR\x0bmessageType\x12A\n\tenum_type\x18\x05\x20\x03(\x0b2$.google.pro\ + tobuf.EnumDescriptorProtoR\x08enumType\x12A\n\x07service\x18\x06\x20\x03\ + (\x0b2'.google.protobuf.ServiceDescriptorProtoR\x07service\x12C\n\texten\ + sion\x18\x07\x20\x03(\x0b2%.google.protobuf.FieldDescriptorProtoR\texten\ + sion\x126\n\x07options\x18\x08\x20\x01(\x0b2\x1c.google.protobuf.FileOpt\ + ionsR\x07options\x12I\n\x10source_code_info\x18\t\x20\x01(\x0b2\x1f.goog\ + le.protobuf.SourceCodeInfoR\x0esourceCodeInfo\x12\x16\n\x06syntax\x18\ + \x0c\x20\x01(\tR\x06syntax\"\xf7\x05\n\x0fDescriptorProto\x12\x12\n\x04n\ + ame\x18\x01\x20\x01(\tR\x04name\x12;\n\x05field\x18\x02\x20\x03(\x0b2%.g\ + oogle.protobuf.FieldDescriptorProtoR\x05field\x12C\n\textension\x18\x06\ + \x20\x03(\x0b2%.google.protobuf.FieldDescriptorProtoR\textension\x12A\n\ + \x0bnested_type\x18\x03\x20\x03(\x0b2\x20.google.protobuf.DescriptorProt\ + oR\nnestedType\x12A\n\tenum_type\x18\x04\x20\x03(\x0b2$.google.protobuf.\ + EnumDescriptorProtoR\x08enumType\x12X\n\x0fextension_range\x18\x05\x20\ + \x03(\x0b2/.google.protobuf.DescriptorProto.ExtensionRangeR\x0eextension\ + Range\x12D\n\noneof_decl\x18\x08\x20\x03(\x0b2%.google.protobuf.OneofDes\ + criptorProtoR\toneofDecl\x129\n\x07options\x18\x07\x20\x01(\x0b2\x1f.goo\ + gle.protobuf.MessageOptionsR\x07options\x12U\n\x0ereserved_range\x18\t\ + \x20\x03(\x0b2..google.protobuf.DescriptorProto.ReservedRangeR\rreserved\ + Range\x12#\n\rreserved_name\x18\n\x20\x03(\tR\x0creservedName\x1a8\n\x0e\ + ExtensionRange\x12\x14\n\x05start\x18\x01\x20\x01(\x05R\x05start\x12\x10\ + \n\x03end\x18\x02\x20\x01(\x05R\x03end\x1a7\n\rReservedRange\x12\x14\n\ + \x05start\x18\x01\x20\x01(\x05R\x05start\x12\x10\n\x03end\x18\x02\x20\ + \x01(\x05R\x03end\"\x98\x06\n\x14FieldDescriptorProto\x12\x12\n\x04name\ + \x18\x01\x20\x01(\tR\x04name\x12\x16\n\x06number\x18\x03\x20\x01(\x05R\ + \x06number\x12A\n\x05label\x18\x04\x20\x01(\x0e2+.google.protobuf.FieldD\ + escriptorProto.LabelR\x05label\x12>\n\x04type\x18\x05\x20\x01(\x0e2*.goo\ + gle.protobuf.FieldDescriptorProto.TypeR\x04type\x12\x1b\n\ttype_name\x18\ + \x06\x20\x01(\tR\x08typeName\x12\x1a\n\x08extendee\x18\x02\x20\x01(\tR\ + \x08extendee\x12#\n\rdefault_value\x18\x07\x20\x01(\tR\x0cdefaultValue\ + \x12\x1f\n\x0boneof_index\x18\t\x20\x01(\x05R\noneofIndex\x12\x1b\n\tjso\ + n_name\x18\n\x20\x01(\tR\x08jsonName\x127\n\x07options\x18\x08\x20\x01(\ + \x0b2\x1d.google.protobuf.FieldOptionsR\x07options\"\xb6\x02\n\x04Type\ + \x12\x0f\n\x0bTYPE_DOUBLE\x10\x01\x12\x0e\n\nTYPE_FLOAT\x10\x02\x12\x0e\ + \n\nTYPE_INT64\x10\x03\x12\x0f\n\x0bTYPE_UINT64\x10\x04\x12\x0e\n\nTYPE_\ + INT32\x10\x05\x12\x10\n\x0cTYPE_FIXED64\x10\x06\x12\x10\n\x0cTYPE_FIXED3\ + 2\x10\x07\x12\r\n\tTYPE_BOOL\x10\x08\x12\x0f\n\x0bTYPE_STRING\x10\t\x12\ + \x0e\n\nTYPE_GROUP\x10\n\x12\x10\n\x0cTYPE_MESSAGE\x10\x0b\x12\x0e\n\nTY\ + PE_BYTES\x10\x0c\x12\x0f\n\x0bTYPE_UINT32\x10\r\x12\r\n\tTYPE_ENUM\x10\ + \x0e\x12\x11\n\rTYPE_SFIXED32\x10\x0f\x12\x11\n\rTYPE_SFIXED64\x10\x10\ + \x12\x0f\n\x0bTYPE_SINT32\x10\x11\x12\x0f\n\x0bTYPE_SINT64\x10\x12\"C\n\ + \x05Label\x12\x12\n\x0eLABEL_OPTIONAL\x10\x01\x12\x12\n\x0eLABEL_REQUIRE\ + D\x10\x02\x12\x12\n\x0eLABEL_REPEATED\x10\x03\"c\n\x14OneofDescriptorPro\ + to\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x127\n\x07options\x18\ + \x02\x20\x01(\x0b2\x1d.google.protobuf.OneofOptionsR\x07options\"\xa2\ + \x01\n\x13EnumDescriptorProto\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04n\ + ame\x12?\n\x05value\x18\x02\x20\x03(\x0b2).google.protobuf.EnumValueDesc\ + riptorProtoR\x05value\x126\n\x07options\x18\x03\x20\x01(\x0b2\x1c.google\ + .protobuf.EnumOptionsR\x07options\"\x83\x01\n\x18EnumValueDescriptorProt\ + o\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x16\n\x06number\x18\ + \x02\x20\x01(\x05R\x06number\x12;\n\x07options\x18\x03\x20\x01(\x0b2!.go\ + ogle.protobuf.EnumValueOptionsR\x07options\"\xa7\x01\n\x16ServiceDescrip\ + torProto\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12>\n\x06method\ + \x18\x02\x20\x03(\x0b2&.google.protobuf.MethodDescriptorProtoR\x06method\ + \x129\n\x07options\x18\x03\x20\x01(\x0b2\x1f.google.protobuf.ServiceOpti\ + onsR\x07options\"\x89\x02\n\x15MethodDescriptorProto\x12\x12\n\x04name\ + \x18\x01\x20\x01(\tR\x04name\x12\x1d\n\ninput_type\x18\x02\x20\x01(\tR\t\ + inputType\x12\x1f\n\x0boutput_type\x18\x03\x20\x01(\tR\noutputType\x128\ + \n\x07options\x18\x04\x20\x01(\x0b2\x1e.google.protobuf.MethodOptionsR\ + \x07options\x120\n\x10client_streaming\x18\x05\x20\x01(\x08:\x05falseR\ + \x0fclientStreaming\x120\n\x10server_streaming\x18\x06\x20\x01(\x08:\x05\ + falseR\x0fserverStreaming\"\x88\x07\n\x0bFileOptions\x12!\n\x0cjava_pack\ + age\x18\x01\x20\x01(\tR\x0bjavaPackage\x120\n\x14java_outer_classname\ + \x18\x08\x20\x01(\tR\x12javaOuterClassname\x125\n\x13java_multiple_files\ + \x18\n\x20\x01(\x08:\x05falseR\x11javaMultipleFiles\x12D\n\x1djava_gener\ + ate_equals_and_hash\x18\x14\x20\x01(\x08R\x19javaGenerateEqualsAndHashB\ + \x02\x18\x01\x12:\n\x16java_string_check_utf8\x18\x1b\x20\x01(\x08:\x05f\ + alseR\x13javaStringCheckUtf8\x12S\n\x0coptimize_for\x18\t\x20\x01(\x0e2)\ + .google.protobuf.FileOptions.OptimizeMode:\x05SPEEDR\x0boptimizeFor\x12\ + \x1d\n\ngo_package\x18\x0b\x20\x01(\tR\tgoPackage\x125\n\x13cc_generic_s\ + ervices\x18\x10\x20\x01(\x08:\x05falseR\x11ccGenericServices\x129\n\x15j\ + ava_generic_services\x18\x11\x20\x01(\x08:\x05falseR\x13javaGenericServi\ + ces\x125\n\x13py_generic_services\x18\x12\x20\x01(\x08:\x05falseR\x11pyG\ + enericServices\x12%\n\ndeprecated\x18\x17\x20\x01(\x08:\x05falseR\ndepre\ + cated\x12/\n\x10cc_enable_arenas\x18\x1f\x20\x01(\x08:\x05falseR\x0eccEn\ + ableArenas\x12*\n\x11objc_class_prefix\x18$\x20\x01(\tR\x0fobjcClassPref\ + ix\x12)\n\x10csharp_namespace\x18%\x20\x01(\tR\x0fcsharpNamespace\x12X\n\ + \x14uninterpreted_option\x18\xe7\x07\x20\x03(\x0b2$.google.protobuf.Unin\ + terpretedOptionR\x13uninterpretedOption\":\n\x0cOptimizeMode\x12\t\n\x05\ + SPEED\x10\x01\x12\r\n\tCODE_SIZE\x10\x02\x12\x10\n\x0cLITE_RUNTIME\x10\ + \x03*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xc5\x02\n\x0eMessageOption\ + s\x12<\n\x17message_set_wire_format\x18\x01\x20\x01(\x08:\x05falseR\x14m\ + essageSetWireFormat\x12L\n\x1fno_standard_descriptor_accessor\x18\x02\ + \x20\x01(\x08:\x05falseR\x1cnoStandardDescriptorAccessor\x12%\n\ndepreca\ + ted\x18\x03\x20\x01(\x08:\x05falseR\ndeprecated\x12\x1b\n\tmap_entry\x18\ + \x07\x20\x01(\x08R\x08mapEntry\x12X\n\x14uninterpreted_option\x18\xe7\ + \x07\x20\x03(\x0b2$.google.protobuf.UninterpretedOptionR\x13uninterprete\ + dOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xdc\x03\n\x0cFieldOptio\ + ns\x12A\n\x05ctype\x18\x01\x20\x01(\x0e2#.google.protobuf.FieldOptions.C\ + Type:\x06STRINGR\x05ctype\x12\x16\n\x06packed\x18\x02\x20\x01(\x08R\x06p\ + acked\x12G\n\x06jstype\x18\x06\x20\x01(\x0e2$.google.protobuf.FieldOptio\ + ns.JSType:\tJS_NORMALR\x06jstype\x12\x19\n\x04lazy\x18\x05\x20\x01(\x08:\ + \x05falseR\x04lazy\x12%\n\ndeprecated\x18\x03\x20\x01(\x08:\x05falseR\nd\ + eprecated\x12\x19\n\x04weak\x18\n\x20\x01(\x08:\x05falseR\x04weak\x12X\n\ + \x14uninterpreted_option\x18\xe7\x07\x20\x03(\x0b2$.google.protobuf.Unin\ + terpretedOptionR\x13uninterpretedOption\"/\n\x05CType\x12\n\n\x06STRING\ + \x10\0\x12\x08\n\x04CORD\x10\x01\x12\x10\n\x0cSTRING_PIECE\x10\x02\"5\n\ + \x06JSType\x12\r\n\tJS_NORMAL\x10\0\x12\r\n\tJS_STRING\x10\x01\x12\r\n\t\ + JS_NUMBER\x10\x02*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"s\n\x0cOneofOp\ + tions\x12X\n\x14uninterpreted_option\x18\xe7\x07\x20\x03(\x0b2$.google.p\ + rotobuf.UninterpretedOptionR\x13uninterpretedOption*\t\x08\xe8\x07\x10\ + \x80\x80\x80\x80\x02\"\xba\x01\n\x0bEnumOptions\x12\x1f\n\x0ballow_alias\ + \x18\x02\x20\x01(\x08R\nallowAlias\x12%\n\ndeprecated\x18\x03\x20\x01(\ + \x08:\x05falseR\ndeprecated\x12X\n\x14uninterpreted_option\x18\xe7\x07\ + \x20\x03(\x0b2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOpt\ + ion*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\x9e\x01\n\x10EnumValueOptio\ + ns\x12%\n\ndeprecated\x18\x01\x20\x01(\x08:\x05falseR\ndeprecated\x12X\n\ + \x14uninterpreted_option\x18\xe7\x07\x20\x03(\x0b2$.google.protobuf.Unin\ + terpretedOptionR\x13uninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\ + \x80\x02\"\x9c\x01\n\x0eServiceOptions\x12%\n\ndeprecated\x18!\x20\x01(\ + \x08:\x05falseR\ndeprecated\x12X\n\x14uninterpreted_option\x18\xe7\x07\ + \x20\x03(\x0b2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOpt\ + ion*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\x9b\x01\n\rMethodOptions\ + \x12%\n\ndeprecated\x18!\x20\x01(\x08:\x05falseR\ndeprecated\x12X\n\x14u\ + ninterpreted_option\x18\xe7\x07\x20\x03(\x0b2$.google.protobuf.Uninterpr\ + etedOptionR\x13uninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\ + \x02\"\x9a\x03\n\x13UninterpretedOption\x12A\n\x04name\x18\x02\x20\x03(\ + \x0b2-.google.protobuf.UninterpretedOption.NamePartR\x04name\x12)\n\x10i\ + dentifier_value\x18\x03\x20\x01(\tR\x0fidentifierValue\x12,\n\x12positiv\ + e_int_value\x18\x04\x20\x01(\x04R\x10positiveIntValue\x12,\n\x12negative\ + _int_value\x18\x05\x20\x01(\x03R\x10negativeIntValue\x12!\n\x0cdouble_va\ + lue\x18\x06\x20\x01(\x01R\x0bdoubleValue\x12!\n\x0cstring_value\x18\x07\ + \x20\x01(\x0cR\x0bstringValue\x12'\n\x0faggregate_value\x18\x08\x20\x01(\ + \tR\x0eaggregateValue\x1aJ\n\x08NamePart\x12\x1b\n\tname_part\x18\x01\ + \x20\x02(\tR\x08namePart\x12!\n\x0cis_extension\x18\x02\x20\x02(\x08R\ + \x0bisExtension\"\xa7\x02\n\x0eSourceCodeInfo\x12D\n\x08location\x18\x01\ + \x20\x03(\x0b2(.google.protobuf.SourceCodeInfo.LocationR\x08location\x1a\ + \xce\x01\n\x08Location\x12\x16\n\x04path\x18\x01\x20\x03(\x05R\x04pathB\ + \x02\x10\x01\x12\x16\n\x04span\x18\x02\x20\x03(\x05R\x04spanB\x02\x10\ + \x01\x12)\n\x10leading_comments\x18\x03\x20\x01(\tR\x0fleadingComments\ + \x12+\n\x11trailing_comments\x18\x04\x20\x01(\tR\x10trailingComments\x12\ + :\n\x19leading_detached_comments\x18\x06\x20\x03(\tR\x17leadingDetachedC\ + omments\"\xd1\x01\n\x11GeneratedCodeInfo\x12M\n\nannotation\x18\x01\x20\ + \x03(\x0b2-.google.protobuf.GeneratedCodeInfo.AnnotationR\nannotation\ + \x1am\n\nAnnotation\x12\x16\n\x04path\x18\x01\x20\x03(\x05R\x04pathB\x02\ + \x10\x01\x12\x1f\n\x0bsource_file\x18\x02\x20\x01(\tR\nsourceFile\x12\ + \x14\n\x05begin\x18\x03\x20\x01(\x05R\x05begin\x12\x10\n\x03end\x18\x04\ + \x20\x01(\x05R\x03endBX\n\x13com.google.protobufB\x10DescriptorProtosH\ + \x01Z\ndescriptor\xa2\x02\x03GPB\xaa\x02\x1aGoogle.Protobuf.ReflectionJ\ + \xb3\x9f\x02\n\x07\x12\x05'\0\xa3\x06\x01\n\xaa\x0f\n\x01\x0c\x12\x03'\0\ + \x122\xc1\x0c\x20Protocol\x20Buffers\x20-\x20Google's\x20data\x20interch\ + ange\x20format\n\x20Copyright\x202008\x20Google\x20Inc.\x20\x20All\x20ri\ + ghts\x20reserved.\n\x20https://developers.google.com/protocol-buffers/\n\ + \n\x20Redistribution\x20and\x20use\x20in\x20source\x20and\x20binary\x20f\ + orms,\x20with\x20or\x20without\n\x20modification,\x20are\x20permitted\ + \x20provided\x20that\x20the\x20following\x20conditions\x20are\n\x20met:\ + \n\n\x20\x20\x20\x20\x20*\x20Redistributions\x20of\x20source\x20code\x20\ + must\x20retain\x20the\x20above\x20copyright\n\x20notice,\x20this\x20list\ + \x20of\x20conditions\x20and\x20the\x20following\x20disclaimer.\n\x20\x20\ + \x20\x20\x20*\x20Redistributions\x20in\x20binary\x20form\x20must\x20repr\ + oduce\x20the\x20above\n\x20copyright\x20notice,\x20this\x20list\x20of\ + \x20conditions\x20and\x20the\x20following\x20disclaimer\n\x20in\x20the\ + \x20documentation\x20and/or\x20other\x20materials\x20provided\x20with\ + \x20the\n\x20distribution.\n\x20\x20\x20\x20\x20*\x20Neither\x20the\x20n\ + ame\x20of\x20Google\x20Inc.\x20nor\x20the\x20names\x20of\x20its\n\x20con\ + tributors\x20may\x20be\x20used\x20to\x20endorse\x20or\x20promote\x20prod\ + ucts\x20derived\x20from\n\x20this\x20software\x20without\x20specific\x20\ + prior\x20written\x20permission.\n\n\x20THIS\x20SOFTWARE\x20IS\x20PROVIDE\ + D\x20BY\x20THE\x20COPYRIGHT\x20HOLDERS\x20AND\x20CONTRIBUTORS\n\x20\"AS\ + \x20IS\"\x20AND\x20ANY\x20EXPRESS\x20OR\x20IMPLIED\x20WARRANTIES,\x20INC\ + LUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\x20THE\x20IMPLIED\x20WARRANTIE\ + S\x20OF\x20MERCHANTABILITY\x20AND\x20FITNESS\x20FOR\n\x20A\x20PARTICULAR\ + \x20PURPOSE\x20ARE\x20DISCLAIMED.\x20IN\x20NO\x20EVENT\x20SHALL\x20THE\ + \x20COPYRIGHT\n\x20OWNER\x20OR\x20CONTRIBUTORS\x20BE\x20LIABLE\x20FOR\ + \x20ANY\x20DIRECT,\x20INDIRECT,\x20INCIDENTAL,\n\x20SPECIAL,\x20EXEMPLAR\ + Y,\x20OR\x20CONSEQUENTIAL\x20DAMAGES\x20(INCLUDING,\x20BUT\x20NOT\n\x20L\ + IMITED\x20TO,\x20PROCUREMENT\x20OF\x20SUBSTITUTE\x20GOODS\x20OR\x20SERVI\ + CES;\x20LOSS\x20OF\x20USE,\n\x20DATA,\x20OR\x20PROFITS;\x20OR\x20BUSINES\ + S\x20INTERRUPTION)\x20HOWEVER\x20CAUSED\x20AND\x20ON\x20ANY\n\x20THEORY\ + \x20OF\x20LIABILITY,\x20WHETHER\x20IN\x20CONTRACT,\x20STRICT\x20LIABILIT\ + Y,\x20OR\x20TORT\n\x20(INCLUDING\x20NEGLIGENCE\x20OR\x20OTHERWISE)\x20AR\ + ISING\x20IN\x20ANY\x20WAY\x20OUT\x20OF\x20THE\x20USE\n\x20OF\x20THIS\x20\ + SOFTWARE,\x20EVEN\x20IF\x20ADVISED\x20OF\x20THE\x20POSSIBILITY\x20OF\x20\ + SUCH\x20DAMAGE.\n2\xdb\x02\x20Author:\x20kenton@google.com\x20(Kenton\ + \x20Varda)\n\x20\x20Based\x20on\x20original\x20Protocol\x20Buffers\x20de\ + sign\x20by\n\x20\x20Sanjay\x20Ghemawat,\x20Jeff\x20Dean,\x20and\x20other\ + s.\n\n\x20The\x20messages\x20in\x20this\x20file\x20describe\x20the\x20de\ + finitions\x20found\x20in\x20.proto\x20files.\n\x20A\x20valid\x20.proto\ + \x20file\x20can\x20be\x20translated\x20directly\x20to\x20a\x20FileDescri\ + ptorProto\n\x20without\x20any\x20other\x20information\x20(e.g.\x20withou\ + t\x20reading\x20its\x20imports).\n\n\x08\n\x01\x02\x12\x03)\0\x18\n\x08\ + \n\x01\x08\x12\x03*\0!\n\t\n\x02\x08\x0b\x12\x03*\0!\n\x08\n\x01\x08\x12\ + \x03+\0,\n\t\n\x02\x08\x01\x12\x03+\0,\n\x08\n\x01\x08\x12\x03,\01\n\t\n\ + \x02\x08\x08\x12\x03,\01\n\x08\n\x01\x08\x12\x03-\07\n\t\n\x02\x08%\x12\ + \x03-\07\n\x08\n\x01\x08\x12\x03.\0!\n\t\n\x02\x08$\x12\x03.\0!\n\x08\n\ + \x01\x08\x12\x032\0\x1c\n\x7f\n\x02\x08\t\x12\x032\0\x1c\x1at\x20descrip\ + tor.proto\x20must\x20be\x20optimized\x20for\x20speed\x20because\x20refle\ + ction-based\n\x20algorithms\x20don't\x20work\x20during\x20bootstrapping.\ + \n\nj\n\x02\x04\0\x12\x046\08\x01\x1a^\x20The\x20protocol\x20compiler\ + \x20can\x20output\x20a\x20FileDescriptorSet\x20containing\x20the\x20.pro\ + to\n\x20files\x20it\x20parses.\n\n\n\n\x03\x04\0\x01\x12\x036\x08\x19\n\ + \x0b\n\x04\x04\0\x02\0\x12\x037\x02(\n\x0c\n\x05\x04\0\x02\0\x04\x12\x03\ + 7\x02\n\n\x0c\n\x05\x04\0\x02\0\x06\x12\x037\x0b\x1e\n\x0c\n\x05\x04\0\ + \x02\0\x01\x12\x037\x1f#\n\x0c\n\x05\x04\0\x02\0\x03\x12\x037&'\n/\n\x02\ + \x04\x01\x12\x04;\0X\x01\x1a#\x20Describes\x20a\x20complete\x20.proto\ + \x20file.\n\n\n\n\x03\x04\x01\x01\x12\x03;\x08\x1b\n9\n\x04\x04\x01\x02\ + \0\x12\x03<\x02\x1b\",\x20file\x20name,\x20relative\x20to\x20root\x20of\ + \x20source\x20tree\n\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03<\x02\n\n\x0c\ + \n\x05\x04\x01\x02\0\x05\x12\x03<\x0b\x11\n\x0c\n\x05\x04\x01\x02\0\x01\ + \x12\x03<\x12\x16\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03<\x19\x1a\n*\n\ + \x04\x04\x01\x02\x01\x12\x03=\x02\x1e\"\x1d\x20e.g.\x20\"foo\",\x20\"foo\ + .bar\",\x20etc.\n\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03=\x02\n\n\x0c\n\ + \x05\x04\x01\x02\x01\x05\x12\x03=\x0b\x11\n\x0c\n\x05\x04\x01\x02\x01\ + \x01\x12\x03=\x12\x19\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03=\x1c\x1d\n\ + 4\n\x04\x04\x01\x02\x02\x12\x03@\x02!\x1a'\x20Names\x20of\x20files\x20im\ + ported\x20by\x20this\x20file.\n\n\x0c\n\x05\x04\x01\x02\x02\x04\x12\x03@\ + \x02\n\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03@\x0b\x11\n\x0c\n\x05\x04\ + \x01\x02\x02\x01\x12\x03@\x12\x1c\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\ + \x03@\x1f\x20\nQ\n\x04\x04\x01\x02\x03\x12\x03B\x02(\x1aD\x20Indexes\x20\ + of\x20the\x20public\x20imported\x20files\x20in\x20the\x20dependency\x20l\ + ist\x20above.\n\n\x0c\n\x05\x04\x01\x02\x03\x04\x12\x03B\x02\n\n\x0c\n\ + \x05\x04\x01\x02\x03\x05\x12\x03B\x0b\x10\n\x0c\n\x05\x04\x01\x02\x03\ + \x01\x12\x03B\x11\"\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03B%'\nz\n\x04\ + \x04\x01\x02\x04\x12\x03E\x02&\x1am\x20Indexes\x20of\x20the\x20weak\x20i\ + mported\x20files\x20in\x20the\x20dependency\x20list.\n\x20For\x20Google-\ + internal\x20migration\x20only.\x20Do\x20not\x20use.\n\n\x0c\n\x05\x04\ + \x01\x02\x04\x04\x12\x03E\x02\n\n\x0c\n\x05\x04\x01\x02\x04\x05\x12\x03E\ + \x0b\x10\n\x0c\n\x05\x04\x01\x02\x04\x01\x12\x03E\x11\x20\n\x0c\n\x05\ + \x04\x01\x02\x04\x03\x12\x03E#%\n6\n\x04\x04\x01\x02\x05\x12\x03H\x02,\ + \x1a)\x20All\x20top-level\x20definitions\x20in\x20this\x20file.\n\n\x0c\ + \n\x05\x04\x01\x02\x05\x04\x12\x03H\x02\n\n\x0c\n\x05\x04\x01\x02\x05\ + \x06\x12\x03H\x0b\x1a\n\x0c\n\x05\x04\x01\x02\x05\x01\x12\x03H\x1b'\n\ + \x0c\n\x05\x04\x01\x02\x05\x03\x12\x03H*+\n\x0b\n\x04\x04\x01\x02\x06\ + \x12\x03I\x02-\n\x0c\n\x05\x04\x01\x02\x06\x04\x12\x03I\x02\n\n\x0c\n\ + \x05\x04\x01\x02\x06\x06\x12\x03I\x0b\x1e\n\x0c\n\x05\x04\x01\x02\x06\ + \x01\x12\x03I\x1f(\n\x0c\n\x05\x04\x01\x02\x06\x03\x12\x03I+,\n\x0b\n\ + \x04\x04\x01\x02\x07\x12\x03J\x02.\n\x0c\n\x05\x04\x01\x02\x07\x04\x12\ + \x03J\x02\n\n\x0c\n\x05\x04\x01\x02\x07\x06\x12\x03J\x0b!\n\x0c\n\x05\ + \x04\x01\x02\x07\x01\x12\x03J\")\n\x0c\n\x05\x04\x01\x02\x07\x03\x12\x03\ + J,-\n\x0b\n\x04\x04\x01\x02\x08\x12\x03K\x02.\n\x0c\n\x05\x04\x01\x02\ + \x08\x04\x12\x03K\x02\n\n\x0c\n\x05\x04\x01\x02\x08\x06\x12\x03K\x0b\x1f\ + \n\x0c\n\x05\x04\x01\x02\x08\x01\x12\x03K\x20)\n\x0c\n\x05\x04\x01\x02\ + \x08\x03\x12\x03K,-\n\x0b\n\x04\x04\x01\x02\t\x12\x03M\x02#\n\x0c\n\x05\ + \x04\x01\x02\t\x04\x12\x03M\x02\n\n\x0c\n\x05\x04\x01\x02\t\x06\x12\x03M\ + \x0b\x16\n\x0c\n\x05\x04\x01\x02\t\x01\x12\x03M\x17\x1e\n\x0c\n\x05\x04\ + \x01\x02\t\x03\x12\x03M!\"\n\xf4\x01\n\x04\x04\x01\x02\n\x12\x03S\x02/\ + \x1a\xe6\x01\x20This\x20field\x20contains\x20optional\x20information\x20\ + about\x20the\x20original\x20source\x20code.\n\x20You\x20may\x20safely\ + \x20remove\x20this\x20entire\x20field\x20without\x20harming\x20runtime\n\ + \x20functionality\x20of\x20the\x20descriptors\x20--\x20the\x20informatio\ + n\x20is\x20needed\x20only\x20by\n\x20development\x20tools.\n\n\x0c\n\x05\ + \x04\x01\x02\n\x04\x12\x03S\x02\n\n\x0c\n\x05\x04\x01\x02\n\x06\x12\x03S\ + \x0b\x19\n\x0c\n\x05\x04\x01\x02\n\x01\x12\x03S\x1a*\n\x0c\n\x05\x04\x01\ + \x02\n\x03\x12\x03S-.\n]\n\x04\x04\x01\x02\x0b\x12\x03W\x02\x1e\x1aP\x20\ + The\x20syntax\x20of\x20the\x20proto\x20file.\n\x20The\x20supported\x20va\ + lues\x20are\x20\"proto2\"\x20and\x20\"proto3\".\n\n\x0c\n\x05\x04\x01\ + \x02\x0b\x04\x12\x03W\x02\n\n\x0c\n\x05\x04\x01\x02\x0b\x05\x12\x03W\x0b\ + \x11\n\x0c\n\x05\x04\x01\x02\x0b\x01\x12\x03W\x12\x18\n\x0c\n\x05\x04\ + \x01\x02\x0b\x03\x12\x03W\x1b\x1d\n'\n\x02\x04\x02\x12\x04[\0y\x01\x1a\ + \x1b\x20Describes\x20a\x20message\x20type.\n\n\n\n\x03\x04\x02\x01\x12\ + \x03[\x08\x17\n\x0b\n\x04\x04\x02\x02\0\x12\x03\\\x02\x1b\n\x0c\n\x05\ + \x04\x02\x02\0\x04\x12\x03\\\x02\n\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03\ + \\\x0b\x11\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03\\\x12\x16\n\x0c\n\x05\ + \x04\x02\x02\0\x03\x12\x03\\\x19\x1a\n\x0b\n\x04\x04\x02\x02\x01\x12\x03\ + ^\x02*\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\x03^\x02\n\n\x0c\n\x05\x04\ + \x02\x02\x01\x06\x12\x03^\x0b\x1f\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\ + \x03^\x20%\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03^()\n\x0b\n\x04\x04\ + \x02\x02\x02\x12\x03_\x02.\n\x0c\n\x05\x04\x02\x02\x02\x04\x12\x03_\x02\ + \n\n\x0c\n\x05\x04\x02\x02\x02\x06\x12\x03_\x0b\x1f\n\x0c\n\x05\x04\x02\ + \x02\x02\x01\x12\x03_\x20)\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\x03_,-\n\ + \x0b\n\x04\x04\x02\x02\x03\x12\x03a\x02+\n\x0c\n\x05\x04\x02\x02\x03\x04\ + \x12\x03a\x02\n\n\x0c\n\x05\x04\x02\x02\x03\x06\x12\x03a\x0b\x1a\n\x0c\n\ + \x05\x04\x02\x02\x03\x01\x12\x03a\x1b&\n\x0c\n\x05\x04\x02\x02\x03\x03\ + \x12\x03a)*\n\x0b\n\x04\x04\x02\x02\x04\x12\x03b\x02-\n\x0c\n\x05\x04\ + \x02\x02\x04\x04\x12\x03b\x02\n\n\x0c\n\x05\x04\x02\x02\x04\x06\x12\x03b\ + \x0b\x1e\n\x0c\n\x05\x04\x02\x02\x04\x01\x12\x03b\x1f(\n\x0c\n\x05\x04\ + \x02\x02\x04\x03\x12\x03b+,\n\x0c\n\x04\x04\x02\x03\0\x12\x04d\x02g\x03\ + \n\x0c\n\x05\x04\x02\x03\0\x01\x12\x03d\n\x18\n\r\n\x06\x04\x02\x03\0\ + \x02\0\x12\x03e\x04\x1d\n\x0e\n\x07\x04\x02\x03\0\x02\0\x04\x12\x03e\x04\ + \x0c\n\x0e\n\x07\x04\x02\x03\0\x02\0\x05\x12\x03e\r\x12\n\x0e\n\x07\x04\ + \x02\x03\0\x02\0\x01\x12\x03e\x13\x18\n\x0e\n\x07\x04\x02\x03\0\x02\0\ + \x03\x12\x03e\x1b\x1c\n\r\n\x06\x04\x02\x03\0\x02\x01\x12\x03f\x04\x1b\n\ + \x0e\n\x07\x04\x02\x03\0\x02\x01\x04\x12\x03f\x04\x0c\n\x0e\n\x07\x04\ + \x02\x03\0\x02\x01\x05\x12\x03f\r\x12\n\x0e\n\x07\x04\x02\x03\0\x02\x01\ + \x01\x12\x03f\x13\x16\n\x0e\n\x07\x04\x02\x03\0\x02\x01\x03\x12\x03f\x19\ + \x1a\n\x0b\n\x04\x04\x02\x02\x05\x12\x03h\x02.\n\x0c\n\x05\x04\x02\x02\ + \x05\x04\x12\x03h\x02\n\n\x0c\n\x05\x04\x02\x02\x05\x06\x12\x03h\x0b\x19\ + \n\x0c\n\x05\x04\x02\x02\x05\x01\x12\x03h\x1a)\n\x0c\n\x05\x04\x02\x02\ + \x05\x03\x12\x03h,-\n\x0b\n\x04\x04\x02\x02\x06\x12\x03j\x02/\n\x0c\n\ + \x05\x04\x02\x02\x06\x04\x12\x03j\x02\n\n\x0c\n\x05\x04\x02\x02\x06\x06\ + \x12\x03j\x0b\x1f\n\x0c\n\x05\x04\x02\x02\x06\x01\x12\x03j\x20*\n\x0c\n\ + \x05\x04\x02\x02\x06\x03\x12\x03j-.\n\x0b\n\x04\x04\x02\x02\x07\x12\x03l\ + \x02&\n\x0c\n\x05\x04\x02\x02\x07\x04\x12\x03l\x02\n\n\x0c\n\x05\x04\x02\ + \x02\x07\x06\x12\x03l\x0b\x19\n\x0c\n\x05\x04\x02\x02\x07\x01\x12\x03l\ + \x1a!\n\x0c\n\x05\x04\x02\x02\x07\x03\x12\x03l$%\n\xaa\x01\n\x04\x04\x02\ + \x03\x01\x12\x04q\x02t\x03\x1a\x9b\x01\x20Range\x20of\x20reserved\x20tag\ + \x20numbers.\x20Reserved\x20tag\x20numbers\x20may\x20not\x20be\x20used\ + \x20by\n\x20fields\x20or\x20extension\x20ranges\x20in\x20the\x20same\x20\ + message.\x20Reserved\x20ranges\x20may\n\x20not\x20overlap.\n\n\x0c\n\x05\ + \x04\x02\x03\x01\x01\x12\x03q\n\x17\n\x1b\n\x06\x04\x02\x03\x01\x02\0\ + \x12\x03r\x04\x1d\"\x0c\x20Inclusive.\n\n\x0e\n\x07\x04\x02\x03\x01\x02\ + \0\x04\x12\x03r\x04\x0c\n\x0e\n\x07\x04\x02\x03\x01\x02\0\x05\x12\x03r\r\ + \x12\n\x0e\n\x07\x04\x02\x03\x01\x02\0\x01\x12\x03r\x13\x18\n\x0e\n\x07\ + \x04\x02\x03\x01\x02\0\x03\x12\x03r\x1b\x1c\n\x1b\n\x06\x04\x02\x03\x01\ + \x02\x01\x12\x03s\x04\x1b\"\x0c\x20Exclusive.\n\n\x0e\n\x07\x04\x02\x03\ + \x01\x02\x01\x04\x12\x03s\x04\x0c\n\x0e\n\x07\x04\x02\x03\x01\x02\x01\ + \x05\x12\x03s\r\x12\n\x0e\n\x07\x04\x02\x03\x01\x02\x01\x01\x12\x03s\x13\ + \x16\n\x0e\n\x07\x04\x02\x03\x01\x02\x01\x03\x12\x03s\x19\x1a\n\x0b\n\ + \x04\x04\x02\x02\x08\x12\x03u\x02,\n\x0c\n\x05\x04\x02\x02\x08\x04\x12\ + \x03u\x02\n\n\x0c\n\x05\x04\x02\x02\x08\x06\x12\x03u\x0b\x18\n\x0c\n\x05\ + \x04\x02\x02\x08\x01\x12\x03u\x19'\n\x0c\n\x05\x04\x02\x02\x08\x03\x12\ + \x03u*+\n\x82\x01\n\x04\x04\x02\x02\t\x12\x03x\x02%\x1au\x20Reserved\x20\ + field\x20names,\x20which\x20may\x20not\x20be\x20used\x20by\x20fields\x20\ + in\x20the\x20same\x20message.\n\x20A\x20given\x20name\x20may\x20only\x20\ + be\x20reserved\x20once.\n\n\x0c\n\x05\x04\x02\x02\t\x04\x12\x03x\x02\n\n\ + \x0c\n\x05\x04\x02\x02\t\x05\x12\x03x\x0b\x11\n\x0c\n\x05\x04\x02\x02\t\ + \x01\x12\x03x\x12\x1f\n\x0c\n\x05\x04\x02\x02\t\x03\x12\x03x\"$\n2\n\x02\ + \x04\x03\x12\x05|\0\xc7\x01\x01\x1a%\x20Describes\x20a\x20field\x20withi\ + n\x20a\x20message.\n\n\n\n\x03\x04\x03\x01\x12\x03|\x08\x1c\n\r\n\x04\ + \x04\x03\x04\0\x12\x05}\x02\x98\x01\x03\n\x0c\n\x05\x04\x03\x04\0\x01\ + \x12\x03}\x07\x0b\nS\n\x06\x04\x03\x04\0\x02\0\x12\x04\x80\x01\x04\x1c\ + \x1aC\x200\x20is\x20reserved\x20for\x20errors.\n\x20Order\x20is\x20weird\ + \x20for\x20historical\x20reasons.\n\n\x0f\n\x07\x04\x03\x04\0\x02\0\x01\ + \x12\x04\x80\x01\x04\x0f\n\x0f\n\x07\x04\x03\x04\0\x02\0\x02\x12\x04\x80\ + \x01\x1a\x1b\n\x0e\n\x06\x04\x03\x04\0\x02\x01\x12\x04\x81\x01\x04\x1c\n\ + \x0f\n\x07\x04\x03\x04\0\x02\x01\x01\x12\x04\x81\x01\x04\x0e\n\x0f\n\x07\ + \x04\x03\x04\0\x02\x01\x02\x12\x04\x81\x01\x1a\x1b\nw\n\x06\x04\x03\x04\ + \0\x02\x02\x12\x04\x84\x01\x04\x1c\x1ag\x20Not\x20ZigZag\x20encoded.\x20\ + \x20Negative\x20numbers\x20take\x2010\x20bytes.\x20\x20Use\x20TYPE_SINT6\ + 4\x20if\n\x20negative\x20values\x20are\x20likely.\n\n\x0f\n\x07\x04\x03\ + \x04\0\x02\x02\x01\x12\x04\x84\x01\x04\x0e\n\x0f\n\x07\x04\x03\x04\0\x02\ + \x02\x02\x12\x04\x84\x01\x1a\x1b\n\x0e\n\x06\x04\x03\x04\0\x02\x03\x12\ + \x04\x85\x01\x04\x1c\n\x0f\n\x07\x04\x03\x04\0\x02\x03\x01\x12\x04\x85\ + \x01\x04\x0f\n\x0f\n\x07\x04\x03\x04\0\x02\x03\x02\x12\x04\x85\x01\x1a\ + \x1b\nw\n\x06\x04\x03\x04\0\x02\x04\x12\x04\x88\x01\x04\x1c\x1ag\x20Not\ + \x20ZigZag\x20encoded.\x20\x20Negative\x20numbers\x20take\x2010\x20bytes\ + .\x20\x20Use\x20TYPE_SINT32\x20if\n\x20negative\x20values\x20are\x20like\ + ly.\n\n\x0f\n\x07\x04\x03\x04\0\x02\x04\x01\x12\x04\x88\x01\x04\x0e\n\ + \x0f\n\x07\x04\x03\x04\0\x02\x04\x02\x12\x04\x88\x01\x1a\x1b\n\x0e\n\x06\ + \x04\x03\x04\0\x02\x05\x12\x04\x89\x01\x04\x1c\n\x0f\n\x07\x04\x03\x04\0\ + \x02\x05\x01\x12\x04\x89\x01\x04\x10\n\x0f\n\x07\x04\x03\x04\0\x02\x05\ + \x02\x12\x04\x89\x01\x1a\x1b\n\x0e\n\x06\x04\x03\x04\0\x02\x06\x12\x04\ + \x8a\x01\x04\x1c\n\x0f\n\x07\x04\x03\x04\0\x02\x06\x01\x12\x04\x8a\x01\ + \x04\x10\n\x0f\n\x07\x04\x03\x04\0\x02\x06\x02\x12\x04\x8a\x01\x1a\x1b\n\ + \x0e\n\x06\x04\x03\x04\0\x02\x07\x12\x04\x8b\x01\x04\x1c\n\x0f\n\x07\x04\ + \x03\x04\0\x02\x07\x01\x12\x04\x8b\x01\x04\r\n\x0f\n\x07\x04\x03\x04\0\ + \x02\x07\x02\x12\x04\x8b\x01\x1a\x1b\n\x0e\n\x06\x04\x03\x04\0\x02\x08\ + \x12\x04\x8c\x01\x04\x1c\n\x0f\n\x07\x04\x03\x04\0\x02\x08\x01\x12\x04\ + \x8c\x01\x04\x0f\n\x0f\n\x07\x04\x03\x04\0\x02\x08\x02\x12\x04\x8c\x01\ + \x1a\x1b\n*\n\x06\x04\x03\x04\0\x02\t\x12\x04\x8d\x01\x04\x1d\"\x1a\x20T\ + ag-delimited\x20aggregate.\n\n\x0f\n\x07\x04\x03\x04\0\x02\t\x01\x12\x04\ + \x8d\x01\x04\x0e\n\x0f\n\x07\x04\x03\x04\0\x02\t\x02\x12\x04\x8d\x01\x1a\ + \x1c\n-\n\x06\x04\x03\x04\0\x02\n\x12\x04\x8e\x01\x04\x1d\"\x1d\x20Lengt\ + h-delimited\x20aggregate.\n\n\x0f\n\x07\x04\x03\x04\0\x02\n\x01\x12\x04\ + \x8e\x01\x04\x10\n\x0f\n\x07\x04\x03\x04\0\x02\n\x02\x12\x04\x8e\x01\x1a\ + \x1c\n#\n\x06\x04\x03\x04\0\x02\x0b\x12\x04\x91\x01\x04\x1d\x1a\x13\x20N\ + ew\x20in\x20version\x202.\n\n\x0f\n\x07\x04\x03\x04\0\x02\x0b\x01\x12\ + \x04\x91\x01\x04\x0e\n\x0f\n\x07\x04\x03\x04\0\x02\x0b\x02\x12\x04\x91\ + \x01\x1a\x1c\n\x0e\n\x06\x04\x03\x04\0\x02\x0c\x12\x04\x92\x01\x04\x1d\n\ + \x0f\n\x07\x04\x03\x04\0\x02\x0c\x01\x12\x04\x92\x01\x04\x0f\n\x0f\n\x07\ + \x04\x03\x04\0\x02\x0c\x02\x12\x04\x92\x01\x1a\x1c\n\x0e\n\x06\x04\x03\ + \x04\0\x02\r\x12\x04\x93\x01\x04\x1d\n\x0f\n\x07\x04\x03\x04\0\x02\r\x01\ + \x12\x04\x93\x01\x04\r\n\x0f\n\x07\x04\x03\x04\0\x02\r\x02\x12\x04\x93\ + \x01\x1a\x1c\n\x0e\n\x06\x04\x03\x04\0\x02\x0e\x12\x04\x94\x01\x04\x1d\n\ + \x0f\n\x07\x04\x03\x04\0\x02\x0e\x01\x12\x04\x94\x01\x04\x11\n\x0f\n\x07\ + \x04\x03\x04\0\x02\x0e\x02\x12\x04\x94\x01\x1a\x1c\n\x0e\n\x06\x04\x03\ + \x04\0\x02\x0f\x12\x04\x95\x01\x04\x1d\n\x0f\n\x07\x04\x03\x04\0\x02\x0f\ + \x01\x12\x04\x95\x01\x04\x11\n\x0f\n\x07\x04\x03\x04\0\x02\x0f\x02\x12\ + \x04\x95\x01\x1a\x1c\n'\n\x06\x04\x03\x04\0\x02\x10\x12\x04\x96\x01\x04\ + \x1d\"\x17\x20Uses\x20ZigZag\x20encoding.\n\n\x0f\n\x07\x04\x03\x04\0\ + \x02\x10\x01\x12\x04\x96\x01\x04\x0f\n\x0f\n\x07\x04\x03\x04\0\x02\x10\ + \x02\x12\x04\x96\x01\x1a\x1c\n'\n\x06\x04\x03\x04\0\x02\x11\x12\x04\x97\ + \x01\x04\x1d\"\x17\x20Uses\x20ZigZag\x20encoding.\n\n\x0f\n\x07\x04\x03\ + \x04\0\x02\x11\x01\x12\x04\x97\x01\x04\x0f\n\x0f\n\x07\x04\x03\x04\0\x02\ + \x11\x02\x12\x04\x97\x01\x1a\x1c\n\x0e\n\x04\x04\x03\x04\x01\x12\x06\x9a\ + \x01\x02\xa0\x01\x03\n\r\n\x05\x04\x03\x04\x01\x01\x12\x04\x9a\x01\x07\ + \x0c\n*\n\x06\x04\x03\x04\x01\x02\0\x12\x04\x9c\x01\x04\x1c\x1a\x1a\x200\ + \x20is\x20reserved\x20for\x20errors\n\n\x0f\n\x07\x04\x03\x04\x01\x02\0\ + \x01\x12\x04\x9c\x01\x04\x12\n\x0f\n\x07\x04\x03\x04\x01\x02\0\x02\x12\ + \x04\x9c\x01\x1a\x1b\n\x0e\n\x06\x04\x03\x04\x01\x02\x01\x12\x04\x9d\x01\ + \x04\x1c\n\x0f\n\x07\x04\x03\x04\x01\x02\x01\x01\x12\x04\x9d\x01\x04\x12\ + \n\x0f\n\x07\x04\x03\x04\x01\x02\x01\x02\x12\x04\x9d\x01\x1a\x1b\n8\n\ + \x06\x04\x03\x04\x01\x02\x02\x12\x04\x9e\x01\x04\x1c\"(\x20TODO(sanjay):\ + \x20Should\x20we\x20add\x20LABEL_MAP?\n\n\x0f\n\x07\x04\x03\x04\x01\x02\ + \x02\x01\x12\x04\x9e\x01\x04\x12\n\x0f\n\x07\x04\x03\x04\x01\x02\x02\x02\ + \x12\x04\x9e\x01\x1a\x1b\n\x0c\n\x04\x04\x03\x02\0\x12\x04\xa2\x01\x02\ + \x1b\n\r\n\x05\x04\x03\x02\0\x04\x12\x04\xa2\x01\x02\n\n\r\n\x05\x04\x03\ + \x02\0\x05\x12\x04\xa2\x01\x0b\x11\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\ + \xa2\x01\x12\x16\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\xa2\x01\x19\x1a\n\ + \x0c\n\x04\x04\x03\x02\x01\x12\x04\xa3\x01\x02\x1c\n\r\n\x05\x04\x03\x02\ + \x01\x04\x12\x04\xa3\x01\x02\n\n\r\n\x05\x04\x03\x02\x01\x05\x12\x04\xa3\ + \x01\x0b\x10\n\r\n\x05\x04\x03\x02\x01\x01\x12\x04\xa3\x01\x11\x17\n\r\n\ + \x05\x04\x03\x02\x01\x03\x12\x04\xa3\x01\x1a\x1b\n\x0c\n\x04\x04\x03\x02\ + \x02\x12\x04\xa4\x01\x02\x1b\n\r\n\x05\x04\x03\x02\x02\x04\x12\x04\xa4\ + \x01\x02\n\n\r\n\x05\x04\x03\x02\x02\x06\x12\x04\xa4\x01\x0b\x10\n\r\n\ + \x05\x04\x03\x02\x02\x01\x12\x04\xa4\x01\x11\x16\n\r\n\x05\x04\x03\x02\ + \x02\x03\x12\x04\xa4\x01\x19\x1a\n\x9c\x01\n\x04\x04\x03\x02\x03\x12\x04\ + \xa8\x01\x02\x19\x1a\x8d\x01\x20If\x20type_name\x20is\x20set,\x20this\ + \x20need\x20not\x20be\x20set.\x20\x20If\x20both\x20this\x20and\x20type_n\ + ame\n\x20are\x20set,\x20this\x20must\x20be\x20one\x20of\x20TYPE_ENUM,\ + \x20TYPE_MESSAGE\x20or\x20TYPE_GROUP.\n\n\r\n\x05\x04\x03\x02\x03\x04\ + \x12\x04\xa8\x01\x02\n\n\r\n\x05\x04\x03\x02\x03\x06\x12\x04\xa8\x01\x0b\ + \x0f\n\r\n\x05\x04\x03\x02\x03\x01\x12\x04\xa8\x01\x10\x14\n\r\n\x05\x04\ + \x03\x02\x03\x03\x12\x04\xa8\x01\x17\x18\n\xb7\x02\n\x04\x04\x03\x02\x04\ + \x12\x04\xaf\x01\x02\x20\x1a\xa8\x02\x20For\x20message\x20and\x20enum\ + \x20types,\x20this\x20is\x20the\x20name\x20of\x20the\x20type.\x20\x20If\ + \x20the\x20name\n\x20starts\x20with\x20a\x20'.',\x20it\x20is\x20fully-qu\ + alified.\x20\x20Otherwise,\x20C++-like\x20scoping\n\x20rules\x20are\x20u\ + sed\x20to\x20find\x20the\x20type\x20(i.e.\x20first\x20the\x20nested\x20t\ + ypes\x20within\x20this\n\x20message\x20are\x20searched,\x20then\x20withi\ + n\x20the\x20parent,\x20on\x20up\x20to\x20the\x20root\n\x20namespace).\n\ + \n\r\n\x05\x04\x03\x02\x04\x04\x12\x04\xaf\x01\x02\n\n\r\n\x05\x04\x03\ + \x02\x04\x05\x12\x04\xaf\x01\x0b\x11\n\r\n\x05\x04\x03\x02\x04\x01\x12\ + \x04\xaf\x01\x12\x1b\n\r\n\x05\x04\x03\x02\x04\x03\x12\x04\xaf\x01\x1e\ + \x1f\n~\n\x04\x04\x03\x02\x05\x12\x04\xb3\x01\x02\x1f\x1ap\x20For\x20ext\ + ensions,\x20this\x20is\x20the\x20name\x20of\x20the\x20type\x20being\x20e\ + xtended.\x20\x20It\x20is\n\x20resolved\x20in\x20the\x20same\x20manner\ + \x20as\x20type_name.\n\n\r\n\x05\x04\x03\x02\x05\x04\x12\x04\xb3\x01\x02\ + \n\n\r\n\x05\x04\x03\x02\x05\x05\x12\x04\xb3\x01\x0b\x11\n\r\n\x05\x04\ + \x03\x02\x05\x01\x12\x04\xb3\x01\x12\x1a\n\r\n\x05\x04\x03\x02\x05\x03\ + \x12\x04\xb3\x01\x1d\x1e\n\xb1\x02\n\x04\x04\x03\x02\x06\x12\x04\xba\x01\ + \x02$\x1a\xa2\x02\x20For\x20numeric\x20types,\x20contains\x20the\x20orig\ + inal\x20text\x20representation\x20of\x20the\x20value.\n\x20For\x20boolea\ + ns,\x20\"true\"\x20or\x20\"false\".\n\x20For\x20strings,\x20contains\x20\ + the\x20default\x20text\x20contents\x20(not\x20escaped\x20in\x20any\x20wa\ + y).\n\x20For\x20bytes,\x20contains\x20the\x20C\x20escaped\x20value.\x20\ + \x20All\x20bytes\x20>=\x20128\x20are\x20escaped.\n\x20TODO(kenton):\x20\ + \x20Base-64\x20encode?\n\n\r\n\x05\x04\x03\x02\x06\x04\x12\x04\xba\x01\ + \x02\n\n\r\n\x05\x04\x03\x02\x06\x05\x12\x04\xba\x01\x0b\x11\n\r\n\x05\ + \x04\x03\x02\x06\x01\x12\x04\xba\x01\x12\x1f\n\r\n\x05\x04\x03\x02\x06\ + \x03\x12\x04\xba\x01\"#\n\x84\x01\n\x04\x04\x03\x02\x07\x12\x04\xbe\x01\ + \x02!\x1av\x20If\x20set,\x20gives\x20the\x20index\x20of\x20a\x20oneof\ + \x20in\x20the\x20containing\x20type's\x20oneof_decl\n\x20list.\x20\x20Th\ + is\x20field\x20is\x20a\x20member\x20of\x20that\x20oneof.\n\n\r\n\x05\x04\ + \x03\x02\x07\x04\x12\x04\xbe\x01\x02\n\n\r\n\x05\x04\x03\x02\x07\x05\x12\ + \x04\xbe\x01\x0b\x10\n\r\n\x05\x04\x03\x02\x07\x01\x12\x04\xbe\x01\x11\ + \x1c\n\r\n\x05\x04\x03\x02\x07\x03\x12\x04\xbe\x01\x1f\x20\n\xfa\x01\n\ + \x04\x04\x03\x02\x08\x12\x04\xc4\x01\x02!\x1a\xeb\x01\x20JSON\x20name\ + \x20of\x20this\x20field.\x20The\x20value\x20is\x20set\x20by\x20protocol\ + \x20compiler.\x20If\x20the\n\x20user\x20has\x20set\x20a\x20\"json_name\"\ + \x20option\x20on\x20this\x20field,\x20that\x20option's\x20value\n\x20wil\ + l\x20be\x20used.\x20Otherwise,\x20it's\x20deduced\x20from\x20the\x20fiel\ + d's\x20name\x20by\x20converting\n\x20it\x20to\x20camelCase.\n\n\r\n\x05\ + \x04\x03\x02\x08\x04\x12\x04\xc4\x01\x02\n\n\r\n\x05\x04\x03\x02\x08\x05\ + \x12\x04\xc4\x01\x0b\x11\n\r\n\x05\x04\x03\x02\x08\x01\x12\x04\xc4\x01\ + \x12\x1b\n\r\n\x05\x04\x03\x02\x08\x03\x12\x04\xc4\x01\x1e\x20\n\x0c\n\ + \x04\x04\x03\x02\t\x12\x04\xc6\x01\x02$\n\r\n\x05\x04\x03\x02\t\x04\x12\ + \x04\xc6\x01\x02\n\n\r\n\x05\x04\x03\x02\t\x06\x12\x04\xc6\x01\x0b\x17\n\ + \r\n\x05\x04\x03\x02\t\x01\x12\x04\xc6\x01\x18\x1f\n\r\n\x05\x04\x03\x02\ + \t\x03\x12\x04\xc6\x01\"#\n\"\n\x02\x04\x04\x12\x06\xca\x01\0\xcd\x01\ + \x01\x1a\x14\x20Describes\x20a\x20oneof.\n\n\x0b\n\x03\x04\x04\x01\x12\ + \x04\xca\x01\x08\x1c\n\x0c\n\x04\x04\x04\x02\0\x12\x04\xcb\x01\x02\x1b\n\ + \r\n\x05\x04\x04\x02\0\x04\x12\x04\xcb\x01\x02\n\n\r\n\x05\x04\x04\x02\0\ + \x05\x12\x04\xcb\x01\x0b\x11\n\r\n\x05\x04\x04\x02\0\x01\x12\x04\xcb\x01\ + \x12\x16\n\r\n\x05\x04\x04\x02\0\x03\x12\x04\xcb\x01\x19\x1a\n\x0c\n\x04\ + \x04\x04\x02\x01\x12\x04\xcc\x01\x02$\n\r\n\x05\x04\x04\x02\x01\x04\x12\ + \x04\xcc\x01\x02\n\n\r\n\x05\x04\x04\x02\x01\x06\x12\x04\xcc\x01\x0b\x17\ + \n\r\n\x05\x04\x04\x02\x01\x01\x12\x04\xcc\x01\x18\x1f\n\r\n\x05\x04\x04\ + \x02\x01\x03\x12\x04\xcc\x01\"#\n'\n\x02\x04\x05\x12\x06\xd0\x01\0\xd6\ + \x01\x01\x1a\x19\x20Describes\x20an\x20enum\x20type.\n\n\x0b\n\x03\x04\ + \x05\x01\x12\x04\xd0\x01\x08\x1b\n\x0c\n\x04\x04\x05\x02\0\x12\x04\xd1\ + \x01\x02\x1b\n\r\n\x05\x04\x05\x02\0\x04\x12\x04\xd1\x01\x02\n\n\r\n\x05\ + \x04\x05\x02\0\x05\x12\x04\xd1\x01\x0b\x11\n\r\n\x05\x04\x05\x02\0\x01\ + \x12\x04\xd1\x01\x12\x16\n\r\n\x05\x04\x05\x02\0\x03\x12\x04\xd1\x01\x19\ + \x1a\n\x0c\n\x04\x04\x05\x02\x01\x12\x04\xd3\x01\x02.\n\r\n\x05\x04\x05\ + \x02\x01\x04\x12\x04\xd3\x01\x02\n\n\r\n\x05\x04\x05\x02\x01\x06\x12\x04\ + \xd3\x01\x0b#\n\r\n\x05\x04\x05\x02\x01\x01\x12\x04\xd3\x01$)\n\r\n\x05\ + \x04\x05\x02\x01\x03\x12\x04\xd3\x01,-\n\x0c\n\x04\x04\x05\x02\x02\x12\ + \x04\xd5\x01\x02#\n\r\n\x05\x04\x05\x02\x02\x04\x12\x04\xd5\x01\x02\n\n\ + \r\n\x05\x04\x05\x02\x02\x06\x12\x04\xd5\x01\x0b\x16\n\r\n\x05\x04\x05\ + \x02\x02\x01\x12\x04\xd5\x01\x17\x1e\n\r\n\x05\x04\x05\x02\x02\x03\x12\ + \x04\xd5\x01!\"\n1\n\x02\x04\x06\x12\x06\xd9\x01\0\xde\x01\x01\x1a#\x20D\ + escribes\x20a\x20value\x20within\x20an\x20enum.\n\n\x0b\n\x03\x04\x06\ + \x01\x12\x04\xd9\x01\x08\x20\n\x0c\n\x04\x04\x06\x02\0\x12\x04\xda\x01\ + \x02\x1b\n\r\n\x05\x04\x06\x02\0\x04\x12\x04\xda\x01\x02\n\n\r\n\x05\x04\ + \x06\x02\0\x05\x12\x04\xda\x01\x0b\x11\n\r\n\x05\x04\x06\x02\0\x01\x12\ + \x04\xda\x01\x12\x16\n\r\n\x05\x04\x06\x02\0\x03\x12\x04\xda\x01\x19\x1a\ + \n\x0c\n\x04\x04\x06\x02\x01\x12\x04\xdb\x01\x02\x1c\n\r\n\x05\x04\x06\ + \x02\x01\x04\x12\x04\xdb\x01\x02\n\n\r\n\x05\x04\x06\x02\x01\x05\x12\x04\ + \xdb\x01\x0b\x10\n\r\n\x05\x04\x06\x02\x01\x01\x12\x04\xdb\x01\x11\x17\n\ + \r\n\x05\x04\x06\x02\x01\x03\x12\x04\xdb\x01\x1a\x1b\n\x0c\n\x04\x04\x06\ + \x02\x02\x12\x04\xdd\x01\x02(\n\r\n\x05\x04\x06\x02\x02\x04\x12\x04\xdd\ + \x01\x02\n\n\r\n\x05\x04\x06\x02\x02\x06\x12\x04\xdd\x01\x0b\x1b\n\r\n\ + \x05\x04\x06\x02\x02\x01\x12\x04\xdd\x01\x1c#\n\r\n\x05\x04\x06\x02\x02\ + \x03\x12\x04\xdd\x01&'\n$\n\x02\x04\x07\x12\x06\xe1\x01\0\xe6\x01\x01\ + \x1a\x16\x20Describes\x20a\x20service.\n\n\x0b\n\x03\x04\x07\x01\x12\x04\ + \xe1\x01\x08\x1e\n\x0c\n\x04\x04\x07\x02\0\x12\x04\xe2\x01\x02\x1b\n\r\n\ + \x05\x04\x07\x02\0\x04\x12\x04\xe2\x01\x02\n\n\r\n\x05\x04\x07\x02\0\x05\ + \x12\x04\xe2\x01\x0b\x11\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\xe2\x01\x12\ + \x16\n\r\n\x05\x04\x07\x02\0\x03\x12\x04\xe2\x01\x19\x1a\n\x0c\n\x04\x04\ + \x07\x02\x01\x12\x04\xe3\x01\x02,\n\r\n\x05\x04\x07\x02\x01\x04\x12\x04\ + \xe3\x01\x02\n\n\r\n\x05\x04\x07\x02\x01\x06\x12\x04\xe3\x01\x0b\x20\n\r\ + \n\x05\x04\x07\x02\x01\x01\x12\x04\xe3\x01!'\n\r\n\x05\x04\x07\x02\x01\ + \x03\x12\x04\xe3\x01*+\n\x0c\n\x04\x04\x07\x02\x02\x12\x04\xe5\x01\x02&\ + \n\r\n\x05\x04\x07\x02\x02\x04\x12\x04\xe5\x01\x02\n\n\r\n\x05\x04\x07\ + \x02\x02\x06\x12\x04\xe5\x01\x0b\x19\n\r\n\x05\x04\x07\x02\x02\x01\x12\ + \x04\xe5\x01\x1a!\n\r\n\x05\x04\x07\x02\x02\x03\x12\x04\xe5\x01$%\n0\n\ + \x02\x04\x08\x12\x06\xe9\x01\0\xf7\x01\x01\x1a\"\x20Describes\x20a\x20me\ + thod\x20of\x20a\x20service.\n\n\x0b\n\x03\x04\x08\x01\x12\x04\xe9\x01\ + \x08\x1d\n\x0c\n\x04\x04\x08\x02\0\x12\x04\xea\x01\x02\x1b\n\r\n\x05\x04\ + \x08\x02\0\x04\x12\x04\xea\x01\x02\n\n\r\n\x05\x04\x08\x02\0\x05\x12\x04\ + \xea\x01\x0b\x11\n\r\n\x05\x04\x08\x02\0\x01\x12\x04\xea\x01\x12\x16\n\r\ + \n\x05\x04\x08\x02\0\x03\x12\x04\xea\x01\x19\x1a\n\x97\x01\n\x04\x04\x08\ + \x02\x01\x12\x04\xee\x01\x02!\x1a\x88\x01\x20Input\x20and\x20output\x20t\ + ype\x20names.\x20\x20These\x20are\x20resolved\x20in\x20the\x20same\x20wa\ + y\x20as\n\x20FieldDescriptorProto.type_name,\x20but\x20must\x20refer\x20\ + to\x20a\x20message\x20type.\n\n\r\n\x05\x04\x08\x02\x01\x04\x12\x04\xee\ + \x01\x02\n\n\r\n\x05\x04\x08\x02\x01\x05\x12\x04\xee\x01\x0b\x11\n\r\n\ + \x05\x04\x08\x02\x01\x01\x12\x04\xee\x01\x12\x1c\n\r\n\x05\x04\x08\x02\ + \x01\x03\x12\x04\xee\x01\x1f\x20\n\x0c\n\x04\x04\x08\x02\x02\x12\x04\xef\ + \x01\x02\"\n\r\n\x05\x04\x08\x02\x02\x04\x12\x04\xef\x01\x02\n\n\r\n\x05\ + \x04\x08\x02\x02\x05\x12\x04\xef\x01\x0b\x11\n\r\n\x05\x04\x08\x02\x02\ + \x01\x12\x04\xef\x01\x12\x1d\n\r\n\x05\x04\x08\x02\x02\x03\x12\x04\xef\ + \x01\x20!\n\x0c\n\x04\x04\x08\x02\x03\x12\x04\xf1\x01\x02%\n\r\n\x05\x04\ + \x08\x02\x03\x04\x12\x04\xf1\x01\x02\n\n\r\n\x05\x04\x08\x02\x03\x06\x12\ + \x04\xf1\x01\x0b\x18\n\r\n\x05\x04\x08\x02\x03\x01\x12\x04\xf1\x01\x19\ + \x20\n\r\n\x05\x04\x08\x02\x03\x03\x12\x04\xf1\x01#$\nE\n\x04\x04\x08\ + \x02\x04\x12\x04\xf4\x01\x025\x1a7\x20Identifies\x20if\x20client\x20stre\ + ams\x20multiple\x20client\x20messages\n\n\r\n\x05\x04\x08\x02\x04\x04\ + \x12\x04\xf4\x01\x02\n\n\r\n\x05\x04\x08\x02\x04\x05\x12\x04\xf4\x01\x0b\ + \x0f\n\r\n\x05\x04\x08\x02\x04\x01\x12\x04\xf4\x01\x10\x20\n\r\n\x05\x04\ + \x08\x02\x04\x03\x12\x04\xf4\x01#$\n\r\n\x05\x04\x08\x02\x04\x08\x12\x04\ + \xf4\x01%4\n\r\n\x05\x04\x08\x02\x04\x07\x12\x04\xf4\x01.3\nE\n\x04\x04\ + \x08\x02\x05\x12\x04\xf6\x01\x025\x1a7\x20Identifies\x20if\x20server\x20\ + streams\x20multiple\x20server\x20messages\n\n\r\n\x05\x04\x08\x02\x05\ + \x04\x12\x04\xf6\x01\x02\n\n\r\n\x05\x04\x08\x02\x05\x05\x12\x04\xf6\x01\ + \x0b\x0f\n\r\n\x05\x04\x08\x02\x05\x01\x12\x04\xf6\x01\x10\x20\n\r\n\x05\ + \x04\x08\x02\x05\x03\x12\x04\xf6\x01#$\n\r\n\x05\x04\x08\x02\x05\x08\x12\ + \x04\xf6\x01%4\n\r\n\x05\x04\x08\x02\x05\x07\x12\x04\xf6\x01.3\n\xaf\x0e\ + \n\x02\x04\t\x12\x06\x9b\x02\0\xf8\x02\x012N\x20========================\ + ===========================================\n\x20Options\n2\xd0\r\x20Eac\ + h\x20of\x20the\x20definitions\x20above\x20may\x20have\x20\"options\"\x20\ + attached.\x20\x20These\x20are\n\x20just\x20annotations\x20which\x20may\ + \x20cause\x20code\x20to\x20be\x20generated\x20slightly\x20differently\n\ + \x20or\x20may\x20contain\x20hints\x20for\x20code\x20that\x20manipulates\ + \x20protocol\x20messages.\n\n\x20Clients\x20may\x20define\x20custom\x20o\ + ptions\x20as\x20extensions\x20of\x20the\x20*Options\x20messages.\n\x20Th\ + ese\x20extensions\x20may\x20not\x20yet\x20be\x20known\x20at\x20parsing\ + \x20time,\x20so\x20the\x20parser\x20cannot\n\x20store\x20the\x20values\ + \x20in\x20them.\x20\x20Instead\x20it\x20stores\x20them\x20in\x20a\x20fie\ + ld\x20in\x20the\x20*Options\n\x20message\x20called\x20uninterpreted_opti\ + on.\x20This\x20field\x20must\x20have\x20the\x20same\x20name\n\x20across\ + \x20all\x20*Options\x20messages.\x20We\x20then\x20use\x20this\x20field\ + \x20to\x20populate\x20the\n\x20extensions\x20when\x20we\x20build\x20a\ + \x20descriptor,\x20at\x20which\x20point\x20all\x20protos\x20have\x20been\ + \n\x20parsed\x20and\x20so\x20all\x20extensions\x20are\x20known.\n\n\x20E\ + xtension\x20numbers\x20for\x20custom\x20options\x20may\x20be\x20chosen\ + \x20as\x20follows:\n\x20*\x20For\x20options\x20which\x20will\x20only\x20\ + be\x20used\x20within\x20a\x20single\x20application\x20or\n\x20\x20\x20or\ + ganization,\x20or\x20for\x20experimental\x20options,\x20use\x20field\x20\ + numbers\x2050000\n\x20\x20\x20through\x2099999.\x20\x20It\x20is\x20up\ + \x20to\x20you\x20to\x20ensure\x20that\x20you\x20do\x20not\x20use\x20the\ + \n\x20\x20\x20same\x20number\x20for\x20multiple\x20options.\n\x20*\x20Fo\ + r\x20options\x20which\x20will\x20be\x20published\x20and\x20used\x20publi\ + cly\x20by\x20multiple\n\x20\x20\x20independent\x20entities,\x20e-mail\ + \x20protobuf-global-extension-registry@google.com\n\x20\x20\x20to\x20res\ + erve\x20extension\x20numbers.\x20Simply\x20provide\x20your\x20project\ + \x20name\x20(e.g.\n\x20\x20\x20Objective-C\x20plugin)\x20and\x20your\x20\ + project\x20website\x20(if\x20available)\x20--\x20there's\x20no\n\x20\x20\ + \x20need\x20to\x20explain\x20how\x20you\x20intend\x20to\x20use\x20them.\ + \x20Usually\x20you\x20only\x20need\x20one\n\x20\x20\x20extension\x20numb\ + er.\x20You\x20can\x20declare\x20multiple\x20options\x20with\x20only\x20o\ + ne\x20extension\n\x20\x20\x20number\x20by\x20putting\x20them\x20in\x20a\ + \x20sub-message.\x20See\x20the\x20Custom\x20Options\x20section\x20of\n\ + \x20\x20\x20the\x20docs\x20for\x20examples:\n\x20\x20\x20https://develop\ + ers.google.com/protocol-buffers/docs/proto#options\n\x20\x20\x20If\x20th\ + is\x20turns\x20out\x20to\x20be\x20popular,\x20a\x20web\x20service\x20wil\ + l\x20be\x20set\x20up\n\x20\x20\x20to\x20automatically\x20assign\x20optio\ + n\x20numbers.\n\n\x0b\n\x03\x04\t\x01\x12\x04\x9b\x02\x08\x13\n\xf4\x01\ + \n\x04\x04\t\x02\0\x12\x04\xa1\x02\x02#\x1a\xe5\x01\x20Sets\x20the\x20Ja\ + va\x20package\x20where\x20classes\x20generated\x20from\x20this\x20.proto\ + \x20will\x20be\n\x20placed.\x20\x20By\x20default,\x20the\x20proto\x20pac\ + kage\x20is\x20used,\x20but\x20this\x20is\x20often\n\x20inappropriate\x20\ + because\x20proto\x20packages\x20do\x20not\x20normally\x20start\x20with\ + \x20backwards\n\x20domain\x20names.\n\n\r\n\x05\x04\t\x02\0\x04\x12\x04\ + \xa1\x02\x02\n\n\r\n\x05\x04\t\x02\0\x05\x12\x04\xa1\x02\x0b\x11\n\r\n\ + \x05\x04\t\x02\0\x01\x12\x04\xa1\x02\x12\x1e\n\r\n\x05\x04\t\x02\0\x03\ + \x12\x04\xa1\x02!\"\n\xbf\x02\n\x04\x04\t\x02\x01\x12\x04\xa9\x02\x02+\ + \x1a\xb0\x02\x20If\x20set,\x20all\x20the\x20classes\x20from\x20the\x20.p\ + roto\x20file\x20are\x20wrapped\x20in\x20a\x20single\n\x20outer\x20class\ + \x20with\x20the\x20given\x20name.\x20\x20This\x20applies\x20to\x20both\ + \x20Proto1\n\x20(equivalent\x20to\x20the\x20old\x20\"--one_java_file\"\ + \x20option)\x20and\x20Proto2\x20(where\n\x20a\x20.proto\x20always\x20tra\ + nslates\x20to\x20a\x20single\x20class,\x20but\x20you\x20may\x20want\x20t\ + o\n\x20explicitly\x20choose\x20the\x20class\x20name).\n\n\r\n\x05\x04\t\ + \x02\x01\x04\x12\x04\xa9\x02\x02\n\n\r\n\x05\x04\t\x02\x01\x05\x12\x04\ + \xa9\x02\x0b\x11\n\r\n\x05\x04\t\x02\x01\x01\x12\x04\xa9\x02\x12&\n\r\n\ + \x05\x04\t\x02\x01\x03\x12\x04\xa9\x02)*\n\xa3\x03\n\x04\x04\t\x02\x02\ + \x12\x04\xb1\x02\x029\x1a\x94\x03\x20If\x20set\x20true,\x20then\x20the\ + \x20Java\x20code\x20generator\x20will\x20generate\x20a\x20separate\x20.j\ + ava\n\x20file\x20for\x20each\x20top-level\x20message,\x20enum,\x20and\ + \x20service\x20defined\x20in\x20the\x20.proto\n\x20file.\x20\x20Thus,\ + \x20these\x20types\x20will\x20*not*\x20be\x20nested\x20inside\x20the\x20\ + outer\x20class\n\x20named\x20by\x20java_outer_classname.\x20\x20However,\ + \x20the\x20outer\x20class\x20will\x20still\x20be\n\x20generated\x20to\ + \x20contain\x20the\x20file's\x20getDescriptor()\x20method\x20as\x20well\ + \x20as\x20any\n\x20top-level\x20extensions\x20defined\x20in\x20the\x20fi\ + le.\n\n\r\n\x05\x04\t\x02\x02\x04\x12\x04\xb1\x02\x02\n\n\r\n\x05\x04\t\ + \x02\x02\x05\x12\x04\xb1\x02\x0b\x0f\n\r\n\x05\x04\t\x02\x02\x01\x12\x04\ + \xb1\x02\x10#\n\r\n\x05\x04\t\x02\x02\x03\x12\x04\xb1\x02&(\n\r\n\x05\ + \x04\t\x02\x02\x08\x12\x04\xb1\x02)8\n\r\n\x05\x04\t\x02\x02\x07\x12\x04\ + \xb1\x0227\n)\n\x04\x04\t\x02\x03\x12\x04\xb4\x02\x02E\x1a\x1b\x20This\ + \x20option\x20does\x20nothing.\n\n\r\n\x05\x04\t\x02\x03\x04\x12\x04\xb4\ + \x02\x02\n\n\r\n\x05\x04\t\x02\x03\x05\x12\x04\xb4\x02\x0b\x0f\n\r\n\x05\ + \x04\t\x02\x03\x01\x12\x04\xb4\x02\x10-\n\r\n\x05\x04\t\x02\x03\x03\x12\ + \x04\xb4\x0202\n\r\n\x05\x04\t\x02\x03\x08\x12\x04\xb4\x023D\n\x0e\n\x06\ + \x04\t\x02\x03\x08\x03\x12\x04\xb4\x024C\n\xe6\x02\n\x04\x04\t\x02\x04\ + \x12\x04\xbc\x02\x02<\x1a\xd7\x02\x20If\x20set\x20true,\x20then\x20the\ + \x20Java2\x20code\x20generator\x20will\x20generate\x20code\x20that\n\x20\ + throws\x20an\x20exception\x20whenever\x20an\x20attempt\x20is\x20made\x20\ + to\x20assign\x20a\x20non-UTF-8\n\x20byte\x20sequence\x20to\x20a\x20strin\ + g\x20field.\n\x20Message\x20reflection\x20will\x20do\x20the\x20same.\n\ + \x20However,\x20an\x20extension\x20field\x20still\x20accepts\x20non-UTF-\ + 8\x20byte\x20sequences.\n\x20This\x20option\x20has\x20no\x20effect\x20on\ + \x20when\x20used\x20with\x20the\x20lite\x20runtime.\n\n\r\n\x05\x04\t\ + \x02\x04\x04\x12\x04\xbc\x02\x02\n\n\r\n\x05\x04\t\x02\x04\x05\x12\x04\ + \xbc\x02\x0b\x0f\n\r\n\x05\x04\t\x02\x04\x01\x12\x04\xbc\x02\x10&\n\r\n\ + \x05\x04\t\x02\x04\x03\x12\x04\xbc\x02)+\n\r\n\x05\x04\t\x02\x04\x08\x12\ + \x04\xbc\x02,;\n\r\n\x05\x04\t\x02\x04\x07\x12\x04\xbc\x025:\nL\n\x04\ + \x04\t\x04\0\x12\x06\xc0\x02\x02\xc5\x02\x03\x1a<\x20Generated\x20classe\ + s\x20can\x20be\x20optimized\x20for\x20speed\x20or\x20code\x20size.\n\n\r\ + \n\x05\x04\t\x04\0\x01\x12\x04\xc0\x02\x07\x13\nD\n\x06\x04\t\x04\0\x02\ + \0\x12\x04\xc1\x02\x04\x0e\"4\x20Generate\x20complete\x20code\x20for\x20\ + parsing,\x20serialization,\n\n\x0f\n\x07\x04\t\x04\0\x02\0\x01\x12\x04\ + \xc1\x02\x04\t\n\x0f\n\x07\x04\t\x04\0\x02\0\x02\x12\x04\xc1\x02\x0c\r\n\ + G\n\x06\x04\t\x04\0\x02\x01\x12\x04\xc3\x02\x04\x12\x1a\x06\x20etc.\n\"/\ + \x20Use\x20ReflectionOps\x20to\x20implement\x20these\x20methods.\n\n\x0f\ + \n\x07\x04\t\x04\0\x02\x01\x01\x12\x04\xc3\x02\x04\r\n\x0f\n\x07\x04\t\ + \x04\0\x02\x01\x02\x12\x04\xc3\x02\x10\x11\nG\n\x06\x04\t\x04\0\x02\x02\ + \x12\x04\xc4\x02\x04\x15\"7\x20Generate\x20code\x20using\x20MessageLite\ + \x20and\x20the\x20lite\x20runtime.\n\n\x0f\n\x07\x04\t\x04\0\x02\x02\x01\ + \x12\x04\xc4\x02\x04\x10\n\x0f\n\x07\x04\t\x04\0\x02\x02\x02\x12\x04\xc4\ + \x02\x13\x14\n\x0c\n\x04\x04\t\x02\x05\x12\x04\xc6\x02\x029\n\r\n\x05\ + \x04\t\x02\x05\x04\x12\x04\xc6\x02\x02\n\n\r\n\x05\x04\t\x02\x05\x06\x12\ + \x04\xc6\x02\x0b\x17\n\r\n\x05\x04\t\x02\x05\x01\x12\x04\xc6\x02\x18$\n\ + \r\n\x05\x04\t\x02\x05\x03\x12\x04\xc6\x02'(\n\r\n\x05\x04\t\x02\x05\x08\ + \x12\x04\xc6\x02)8\n\r\n\x05\x04\t\x02\x05\x07\x12\x04\xc6\x0227\n\xe2\ + \x02\n\x04\x04\t\x02\x06\x12\x04\xcd\x02\x02\"\x1a\xd3\x02\x20Sets\x20th\ + e\x20Go\x20package\x20where\x20structs\x20generated\x20from\x20this\x20.\ + proto\x20will\x20be\n\x20placed.\x20If\x20omitted,\x20the\x20Go\x20packa\ + ge\x20will\x20be\x20derived\x20from\x20the\x20following:\n\x20\x20\x20-\ + \x20The\x20basename\x20of\x20the\x20package\x20import\x20path,\x20if\x20\ + provided.\n\x20\x20\x20-\x20Otherwise,\x20the\x20package\x20statement\ + \x20in\x20the\x20.proto\x20file,\x20if\x20present.\n\x20\x20\x20-\x20Oth\ + erwise,\x20the\x20basename\x20of\x20the\x20.proto\x20file,\x20without\ + \x20extension.\n\n\r\n\x05\x04\t\x02\x06\x04\x12\x04\xcd\x02\x02\n\n\r\n\ + \x05\x04\t\x02\x06\x05\x12\x04\xcd\x02\x0b\x11\n\r\n\x05\x04\t\x02\x06\ + \x01\x12\x04\xcd\x02\x12\x1c\n\r\n\x05\x04\t\x02\x06\x03\x12\x04\xcd\x02\ + \x1f!\n\xd4\x04\n\x04\x04\t\x02\x07\x12\x04\xdb\x02\x029\x1a\xc5\x04\x20\ + Should\x20generic\x20services\x20be\x20generated\x20in\x20each\x20langua\ + ge?\x20\x20\"Generic\"\x20services\n\x20are\x20not\x20specific\x20to\x20\ + any\x20particular\x20RPC\x20system.\x20\x20They\x20are\x20generated\x20b\ + y\x20the\n\x20main\x20code\x20generators\x20in\x20each\x20language\x20(w\ + ithout\x20additional\x20plugins).\n\x20Generic\x20services\x20were\x20th\ + e\x20only\x20kind\x20of\x20service\x20generation\x20supported\x20by\n\ + \x20early\x20versions\x20of\x20google.protobuf.\n\n\x20Generic\x20servic\ + es\x20are\x20now\x20considered\x20deprecated\x20in\x20favor\x20of\x20usi\ + ng\x20plugins\n\x20that\x20generate\x20code\x20specific\x20to\x20your\ + \x20particular\x20RPC\x20system.\x20\x20Therefore,\n\x20these\x20default\ + \x20to\x20false.\x20\x20Old\x20code\x20which\x20depends\x20on\x20generic\ + \x20services\x20should\n\x20explicitly\x20set\x20them\x20to\x20true.\n\n\ + \r\n\x05\x04\t\x02\x07\x04\x12\x04\xdb\x02\x02\n\n\r\n\x05\x04\t\x02\x07\ + \x05\x12\x04\xdb\x02\x0b\x0f\n\r\n\x05\x04\t\x02\x07\x01\x12\x04\xdb\x02\ + \x10#\n\r\n\x05\x04\t\x02\x07\x03\x12\x04\xdb\x02&(\n\r\n\x05\x04\t\x02\ + \x07\x08\x12\x04\xdb\x02)8\n\r\n\x05\x04\t\x02\x07\x07\x12\x04\xdb\x0227\ + \n\x0c\n\x04\x04\t\x02\x08\x12\x04\xdc\x02\x02;\n\r\n\x05\x04\t\x02\x08\ + \x04\x12\x04\xdc\x02\x02\n\n\r\n\x05\x04\t\x02\x08\x05\x12\x04\xdc\x02\ + \x0b\x0f\n\r\n\x05\x04\t\x02\x08\x01\x12\x04\xdc\x02\x10%\n\r\n\x05\x04\ + \t\x02\x08\x03\x12\x04\xdc\x02(*\n\r\n\x05\x04\t\x02\x08\x08\x12\x04\xdc\ + \x02+:\n\r\n\x05\x04\t\x02\x08\x07\x12\x04\xdc\x0249\n\x0c\n\x04\x04\t\ + \x02\t\x12\x04\xdd\x02\x029\n\r\n\x05\x04\t\x02\t\x04\x12\x04\xdd\x02\ + \x02\n\n\r\n\x05\x04\t\x02\t\x05\x12\x04\xdd\x02\x0b\x0f\n\r\n\x05\x04\t\ + \x02\t\x01\x12\x04\xdd\x02\x10#\n\r\n\x05\x04\t\x02\t\x03\x12\x04\xdd\ + \x02&(\n\r\n\x05\x04\t\x02\t\x08\x12\x04\xdd\x02)8\n\r\n\x05\x04\t\x02\t\ + \x07\x12\x04\xdd\x0227\n\xf3\x01\n\x04\x04\t\x02\n\x12\x04\xe3\x02\x020\ + \x1a\xe4\x01\x20Is\x20this\x20file\x20deprecated?\n\x20Depending\x20on\ + \x20the\x20target\x20platform,\x20this\x20can\x20emit\x20Deprecated\x20a\ + nnotations\n\x20for\x20everything\x20in\x20the\x20file,\x20or\x20it\x20w\ + ill\x20be\x20completely\x20ignored;\x20in\x20the\x20very\n\x20least,\x20\ + this\x20is\x20a\x20formalization\x20for\x20deprecating\x20files.\n\n\r\n\ + \x05\x04\t\x02\n\x04\x12\x04\xe3\x02\x02\n\n\r\n\x05\x04\t\x02\n\x05\x12\ + \x04\xe3\x02\x0b\x0f\n\r\n\x05\x04\t\x02\n\x01\x12\x04\xe3\x02\x10\x1a\n\ + \r\n\x05\x04\t\x02\n\x03\x12\x04\xe3\x02\x1d\x1f\n\r\n\x05\x04\t\x02\n\ + \x08\x12\x04\xe3\x02\x20/\n\r\n\x05\x04\t\x02\n\x07\x12\x04\xe3\x02).\n\ + \x7f\n\x04\x04\t\x02\x0b\x12\x04\xe7\x02\x026\x1aq\x20Enables\x20the\x20\ + use\x20of\x20arenas\x20for\x20the\x20proto\x20messages\x20in\x20this\x20\ + file.\x20This\x20applies\n\x20only\x20to\x20generated\x20classes\x20for\ + \x20C++.\n\n\r\n\x05\x04\t\x02\x0b\x04\x12\x04\xe7\x02\x02\n\n\r\n\x05\ + \x04\t\x02\x0b\x05\x12\x04\xe7\x02\x0b\x0f\n\r\n\x05\x04\t\x02\x0b\x01\ + \x12\x04\xe7\x02\x10\x20\n\r\n\x05\x04\t\x02\x0b\x03\x12\x04\xe7\x02#%\n\ + \r\n\x05\x04\t\x02\x0b\x08\x12\x04\xe7\x02&5\n\r\n\x05\x04\t\x02\x0b\x07\ + \x12\x04\xe7\x02/4\n\x92\x01\n\x04\x04\t\x02\x0c\x12\x04\xec\x02\x02)\ + \x1a\x83\x01\x20Sets\x20the\x20objective\x20c\x20class\x20prefix\x20whic\ + h\x20is\x20prepended\x20to\x20all\x20objective\x20c\n\x20generated\x20cl\ + asses\x20from\x20this\x20.proto.\x20There\x20is\x20no\x20default.\n\n\r\ + \n\x05\x04\t\x02\x0c\x04\x12\x04\xec\x02\x02\n\n\r\n\x05\x04\t\x02\x0c\ + \x05\x12\x04\xec\x02\x0b\x11\n\r\n\x05\x04\t\x02\x0c\x01\x12\x04\xec\x02\ + \x12#\n\r\n\x05\x04\t\x02\x0c\x03\x12\x04\xec\x02&(\nI\n\x04\x04\t\x02\r\ + \x12\x04\xef\x02\x02(\x1a;\x20Namespace\x20for\x20generated\x20classes;\ + \x20defaults\x20to\x20the\x20package.\n\n\r\n\x05\x04\t\x02\r\x04\x12\ + \x04\xef\x02\x02\n\n\r\n\x05\x04\t\x02\r\x05\x12\x04\xef\x02\x0b\x11\n\r\ + \n\x05\x04\t\x02\r\x01\x12\x04\xef\x02\x12\"\n\r\n\x05\x04\t\x02\r\x03\ + \x12\x04\xef\x02%'\nO\n\x04\x04\t\x02\x0e\x12\x04\xf2\x02\x02:\x1aA\x20T\ + he\x20parser\x20stores\x20options\x20it\x20doesn't\x20recognize\x20here.\ + \x20See\x20above.\n\n\r\n\x05\x04\t\x02\x0e\x04\x12\x04\xf2\x02\x02\n\n\ + \r\n\x05\x04\t\x02\x0e\x06\x12\x04\xf2\x02\x0b\x1e\n\r\n\x05\x04\t\x02\ + \x0e\x01\x12\x04\xf2\x02\x1f3\n\r\n\x05\x04\t\x02\x0e\x03\x12\x04\xf2\ + \x0269\nZ\n\x03\x04\t\x05\x12\x04\xf5\x02\x02\x19\x1aM\x20Clients\x20can\ + \x20define\x20custom\x20options\x20in\x20extensions\x20of\x20this\x20mes\ + sage.\x20See\x20above.\n\n\x0c\n\x04\x04\t\x05\0\x12\x04\xf5\x02\r\x18\n\ + \r\n\x05\x04\t\x05\0\x01\x12\x04\xf5\x02\r\x11\n\r\n\x05\x04\t\x05\0\x02\ + \x12\x04\xf5\x02\x15\x18\n\x0c\n\x02\x04\n\x12\x06\xfa\x02\0\xb8\x03\x01\ + \n\x0b\n\x03\x04\n\x01\x12\x04\xfa\x02\x08\x16\n\xd8\x05\n\x04\x04\n\x02\ + \0\x12\x04\x8d\x03\x02<\x1a\xc9\x05\x20Set\x20true\x20to\x20use\x20the\ + \x20old\x20proto1\x20MessageSet\x20wire\x20format\x20for\x20extensions.\ + \n\x20This\x20is\x20provided\x20for\x20backwards-compatibility\x20with\ + \x20the\x20MessageSet\x20wire\n\x20format.\x20\x20You\x20should\x20not\ + \x20use\x20this\x20for\x20any\x20other\x20reason:\x20\x20It's\x20less\n\ + \x20efficient,\x20has\x20fewer\x20features,\x20and\x20is\x20more\x20comp\ + licated.\n\n\x20The\x20message\x20must\x20be\x20defined\x20exactly\x20as\ + \x20follows:\n\x20\x20\x20message\x20Foo\x20{\n\x20\x20\x20\x20\x20optio\ + n\x20message_set_wire_format\x20=\x20true;\n\x20\x20\x20\x20\x20extensio\ + ns\x204\x20to\x20max;\n\x20\x20\x20}\n\x20Note\x20that\x20the\x20message\ + \x20cannot\x20have\x20any\x20defined\x20fields;\x20MessageSets\x20only\n\ + \x20have\x20extensions.\n\n\x20All\x20extensions\x20of\x20your\x20type\ + \x20must\x20be\x20singular\x20messages;\x20e.g.\x20they\x20cannot\n\x20b\ + e\x20int32s,\x20enums,\x20or\x20repeated\x20messages.\n\n\x20Because\x20\ + this\x20is\x20an\x20option,\x20the\x20above\x20two\x20restrictions\x20ar\ + e\x20not\x20enforced\x20by\n\x20the\x20protocol\x20compiler.\n\n\r\n\x05\ + \x04\n\x02\0\x04\x12\x04\x8d\x03\x02\n\n\r\n\x05\x04\n\x02\0\x05\x12\x04\ + \x8d\x03\x0b\x0f\n\r\n\x05\x04\n\x02\0\x01\x12\x04\x8d\x03\x10'\n\r\n\ + \x05\x04\n\x02\0\x03\x12\x04\x8d\x03*+\n\r\n\x05\x04\n\x02\0\x08\x12\x04\ + \x8d\x03,;\n\r\n\x05\x04\n\x02\0\x07\x12\x04\x8d\x035:\n\xeb\x01\n\x04\ + \x04\n\x02\x01\x12\x04\x92\x03\x02D\x1a\xdc\x01\x20Disables\x20the\x20ge\ + neration\x20of\x20the\x20standard\x20\"descriptor()\"\x20accessor,\x20wh\ + ich\x20can\n\x20conflict\x20with\x20a\x20field\x20of\x20the\x20same\x20n\ + ame.\x20\x20This\x20is\x20meant\x20to\x20make\x20migration\n\x20from\x20\ + proto1\x20easier;\x20new\x20code\x20should\x20avoid\x20fields\x20named\ + \x20\"descriptor\".\n\n\r\n\x05\x04\n\x02\x01\x04\x12\x04\x92\x03\x02\n\ + \n\r\n\x05\x04\n\x02\x01\x05\x12\x04\x92\x03\x0b\x0f\n\r\n\x05\x04\n\x02\ + \x01\x01\x12\x04\x92\x03\x10/\n\r\n\x05\x04\n\x02\x01\x03\x12\x04\x92\ + \x0323\n\r\n\x05\x04\n\x02\x01\x08\x12\x04\x92\x034C\n\r\n\x05\x04\n\x02\ + \x01\x07\x12\x04\x92\x03=B\n\xee\x01\n\x04\x04\n\x02\x02\x12\x04\x98\x03\ + \x02/\x1a\xdf\x01\x20Is\x20this\x20message\x20deprecated?\n\x20Depending\ + \x20on\x20the\x20target\x20platform,\x20this\x20can\x20emit\x20Deprecate\ + d\x20annotations\n\x20for\x20the\x20message,\x20or\x20it\x20will\x20be\ + \x20completely\x20ignored;\x20in\x20the\x20very\x20least,\n\x20this\x20i\ + s\x20a\x20formalization\x20for\x20deprecating\x20messages.\n\n\r\n\x05\ + \x04\n\x02\x02\x04\x12\x04\x98\x03\x02\n\n\r\n\x05\x04\n\x02\x02\x05\x12\ + \x04\x98\x03\x0b\x0f\n\r\n\x05\x04\n\x02\x02\x01\x12\x04\x98\x03\x10\x1a\ + \n\r\n\x05\x04\n\x02\x02\x03\x12\x04\x98\x03\x1d\x1e\n\r\n\x05\x04\n\x02\ + \x02\x08\x12\x04\x98\x03\x1f.\n\r\n\x05\x04\n\x02\x02\x07\x12\x04\x98\ + \x03(-\n\x9e\x06\n\x04\x04\n\x02\x03\x12\x04\xaf\x03\x02\x1e\x1a\x8f\x06\ + \x20Whether\x20the\x20message\x20is\x20an\x20automatically\x20generated\ + \x20map\x20entry\x20type\x20for\x20the\n\x20maps\x20field.\n\n\x20For\ + \x20maps\x20fields:\n\x20\x20\x20\x20\x20map<KeyType,\x20ValueType>\x20m\ + ap_field\x20=\x201;\n\x20The\x20parsed\x20descriptor\x20looks\x20like:\n\ + \x20\x20\x20\x20\x20message\x20MapFieldEntry\x20{\n\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20option\x20map_entry\x20=\x20true;\n\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20optional\x20KeyType\x20key\x20=\x201;\n\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20optional\x20ValueType\x20value\x20=\x202;\n\x20\x20\ + \x20\x20\x20}\n\x20\x20\x20\x20\x20repeated\x20MapFieldEntry\x20map_fiel\ + d\x20=\x201;\n\n\x20Implementations\x20may\x20choose\x20not\x20to\x20gen\ + erate\x20the\x20map_entry=true\x20message,\x20but\n\x20use\x20a\x20nativ\ + e\x20map\x20in\x20the\x20target\x20language\x20to\x20hold\x20the\x20keys\ + \x20and\x20values.\n\x20The\x20reflection\x20APIs\x20in\x20such\x20imple\ + mentions\x20still\x20need\x20to\x20work\x20as\n\x20if\x20the\x20field\ + \x20is\x20a\x20repeated\x20message\x20field.\n\n\x20NOTE:\x20Do\x20not\ + \x20set\x20the\x20option\x20in\x20.proto\x20files.\x20Always\x20use\x20t\ + he\x20maps\x20syntax\n\x20instead.\x20The\x20option\x20should\x20only\ + \x20be\x20implicitly\x20set\x20by\x20the\x20proto\x20compiler\n\x20parse\ + r.\n\n\r\n\x05\x04\n\x02\x03\x04\x12\x04\xaf\x03\x02\n\n\r\n\x05\x04\n\ + \x02\x03\x05\x12\x04\xaf\x03\x0b\x0f\n\r\n\x05\x04\n\x02\x03\x01\x12\x04\ + \xaf\x03\x10\x19\n\r\n\x05\x04\n\x02\x03\x03\x12\x04\xaf\x03\x1c\x1d\nO\ + \n\x04\x04\n\x02\x04\x12\x04\xb2\x03\x02:\x1aA\x20The\x20parser\x20store\ + s\x20options\x20it\x20doesn't\x20recognize\x20here.\x20See\x20above.\n\n\ + \r\n\x05\x04\n\x02\x04\x04\x12\x04\xb2\x03\x02\n\n\r\n\x05\x04\n\x02\x04\ + \x06\x12\x04\xb2\x03\x0b\x1e\n\r\n\x05\x04\n\x02\x04\x01\x12\x04\xb2\x03\ + \x1f3\n\r\n\x05\x04\n\x02\x04\x03\x12\x04\xb2\x0369\nZ\n\x03\x04\n\x05\ + \x12\x04\xb5\x03\x02\x19\x1aM\x20Clients\x20can\x20define\x20custom\x20o\ + ptions\x20in\x20extensions\x20of\x20this\x20message.\x20See\x20above.\n\ + \n\x0c\n\x04\x04\n\x05\0\x12\x04\xb5\x03\r\x18\n\r\n\x05\x04\n\x05\0\x01\ + \x12\x04\xb5\x03\r\x11\n\r\n\x05\x04\n\x05\0\x02\x12\x04\xb5\x03\x15\x18\ + \n\x0c\n\x02\x04\x0b\x12\x06\xba\x03\0\x93\x04\x01\n\x0b\n\x03\x04\x0b\ + \x01\x12\x04\xba\x03\x08\x14\n\xa3\x02\n\x04\x04\x0b\x02\0\x12\x04\xbf\ + \x03\x02.\x1a\x94\x02\x20The\x20ctype\x20option\x20instructs\x20the\x20C\ + ++\x20code\x20generator\x20to\x20use\x20a\x20different\n\x20representati\ + on\x20of\x20the\x20field\x20than\x20it\x20normally\x20would.\x20\x20See\ + \x20the\x20specific\n\x20options\x20below.\x20\x20This\x20option\x20is\ + \x20not\x20yet\x20implemented\x20in\x20the\x20open\x20source\n\x20releas\ + e\x20--\x20sorry,\x20we'll\x20try\x20to\x20include\x20it\x20in\x20a\x20f\ + uture\x20version!\n\n\r\n\x05\x04\x0b\x02\0\x04\x12\x04\xbf\x03\x02\n\n\ + \r\n\x05\x04\x0b\x02\0\x06\x12\x04\xbf\x03\x0b\x10\n\r\n\x05\x04\x0b\x02\ + \0\x01\x12\x04\xbf\x03\x11\x16\n\r\n\x05\x04\x0b\x02\0\x03\x12\x04\xbf\ + \x03\x19\x1a\n\r\n\x05\x04\x0b\x02\0\x08\x12\x04\xbf\x03\x1b-\n\r\n\x05\ + \x04\x0b\x02\0\x07\x12\x04\xbf\x03&,\n\x0e\n\x04\x04\x0b\x04\0\x12\x06\ + \xc0\x03\x02\xc7\x03\x03\n\r\n\x05\x04\x0b\x04\0\x01\x12\x04\xc0\x03\x07\ + \x0c\n\x1f\n\x06\x04\x0b\x04\0\x02\0\x12\x04\xc2\x03\x04\x0f\x1a\x0f\x20\ + Default\x20mode.\n\n\x0f\n\x07\x04\x0b\x04\0\x02\0\x01\x12\x04\xc2\x03\ + \x04\n\n\x0f\n\x07\x04\x0b\x04\0\x02\0\x02\x12\x04\xc2\x03\r\x0e\n\x0e\n\ + \x06\x04\x0b\x04\0\x02\x01\x12\x04\xc4\x03\x04\r\n\x0f\n\x07\x04\x0b\x04\ + \0\x02\x01\x01\x12\x04\xc4\x03\x04\x08\n\x0f\n\x07\x04\x0b\x04\0\x02\x01\ + \x02\x12\x04\xc4\x03\x0b\x0c\n\x0e\n\x06\x04\x0b\x04\0\x02\x02\x12\x04\ + \xc6\x03\x04\x15\n\x0f\n\x07\x04\x0b\x04\0\x02\x02\x01\x12\x04\xc6\x03\ + \x04\x10\n\x0f\n\x07\x04\x0b\x04\0\x02\x02\x02\x12\x04\xc6\x03\x13\x14\n\ + \xda\x02\n\x04\x04\x0b\x02\x01\x12\x04\xcd\x03\x02\x1b\x1a\xcb\x02\x20Th\ + e\x20packed\x20option\x20can\x20be\x20enabled\x20for\x20repeated\x20prim\ + itive\x20fields\x20to\x20enable\n\x20a\x20more\x20efficient\x20represent\ + ation\x20on\x20the\x20wire.\x20Rather\x20than\x20repeatedly\n\x20writing\ + \x20the\x20tag\x20and\x20type\x20for\x20each\x20element,\x20the\x20entir\ + e\x20array\x20is\x20encoded\x20as\n\x20a\x20single\x20length-delimited\ + \x20blob.\x20In\x20proto3,\x20only\x20explicit\x20setting\x20it\x20to\n\ + \x20false\x20will\x20avoid\x20using\x20packed\x20encoding.\n\n\r\n\x05\ + \x04\x0b\x02\x01\x04\x12\x04\xcd\x03\x02\n\n\r\n\x05\x04\x0b\x02\x01\x05\ + \x12\x04\xcd\x03\x0b\x0f\n\r\n\x05\x04\x0b\x02\x01\x01\x12\x04\xcd\x03\ + \x10\x16\n\r\n\x05\x04\x0b\x02\x01\x03\x12\x04\xcd\x03\x19\x1a\n\xe4\x04\ + \n\x04\x04\x0b\x02\x02\x12\x04\xd8\x03\x023\x1a\xd5\x04\x20The\x20jstype\ + \x20option\x20determines\x20the\x20JavaScript\x20type\x20used\x20for\x20\ + values\x20of\x20the\n\x20field.\x20\x20The\x20option\x20is\x20permitted\ + \x20only\x20for\x2064\x20bit\x20integral\x20and\x20fixed\x20types\n\x20(\ + int64,\x20uint64,\x20sint64,\x20fixed64,\x20sfixed64).\x20\x20By\x20defa\ + ult\x20these\x20types\x20are\n\x20represented\x20as\x20JavaScript\x20str\ + ings.\x20\x20This\x20avoids\x20loss\x20of\x20precision\x20that\x20can\n\ + \x20happen\x20when\x20a\x20large\x20value\x20is\x20converted\x20to\x20a\ + \x20floating\x20point\x20JavaScript\n\x20numbers.\x20\x20Specifying\x20J\ + S_NUMBER\x20for\x20the\x20jstype\x20causes\x20the\x20generated\n\x20Java\ + Script\x20code\x20to\x20use\x20the\x20JavaScript\x20\"number\"\x20type\ + \x20instead\x20of\x20strings.\n\x20This\x20option\x20is\x20an\x20enum\ + \x20to\x20permit\x20additional\x20types\x20to\x20be\x20added,\n\x20e.g.\ + \x20goog.math.Integer.\n\n\r\n\x05\x04\x0b\x02\x02\x04\x12\x04\xd8\x03\ + \x02\n\n\r\n\x05\x04\x0b\x02\x02\x06\x12\x04\xd8\x03\x0b\x11\n\r\n\x05\ + \x04\x0b\x02\x02\x01\x12\x04\xd8\x03\x12\x18\n\r\n\x05\x04\x0b\x02\x02\ + \x03\x12\x04\xd8\x03\x1b\x1c\n\r\n\x05\x04\x0b\x02\x02\x08\x12\x04\xd8\ + \x03\x1d2\n\r\n\x05\x04\x0b\x02\x02\x07\x12\x04\xd8\x03(1\n\x0e\n\x04\ + \x04\x0b\x04\x01\x12\x06\xd9\x03\x02\xe2\x03\x03\n\r\n\x05\x04\x0b\x04\ + \x01\x01\x12\x04\xd9\x03\x07\r\n'\n\x06\x04\x0b\x04\x01\x02\0\x12\x04\ + \xdb\x03\x04\x12\x1a\x17\x20Use\x20the\x20default\x20type.\n\n\x0f\n\x07\ + \x04\x0b\x04\x01\x02\0\x01\x12\x04\xdb\x03\x04\r\n\x0f\n\x07\x04\x0b\x04\ + \x01\x02\0\x02\x12\x04\xdb\x03\x10\x11\n)\n\x06\x04\x0b\x04\x01\x02\x01\ + \x12\x04\xde\x03\x04\x12\x1a\x19\x20Use\x20JavaScript\x20strings.\n\n\ + \x0f\n\x07\x04\x0b\x04\x01\x02\x01\x01\x12\x04\xde\x03\x04\r\n\x0f\n\x07\ + \x04\x0b\x04\x01\x02\x01\x02\x12\x04\xde\x03\x10\x11\n)\n\x06\x04\x0b\ + \x04\x01\x02\x02\x12\x04\xe1\x03\x04\x12\x1a\x19\x20Use\x20JavaScript\ + \x20numbers.\n\n\x0f\n\x07\x04\x0b\x04\x01\x02\x02\x01\x12\x04\xe1\x03\ + \x04\r\n\x0f\n\x07\x04\x0b\x04\x01\x02\x02\x02\x12\x04\xe1\x03\x10\x11\n\ + \xef\x0c\n\x04\x04\x0b\x02\x03\x12\x04\x80\x04\x02)\x1a\xe0\x0c\x20Shoul\ + d\x20this\x20field\x20be\x20parsed\x20lazily?\x20\x20Lazy\x20applies\x20\ + only\x20to\x20message-type\n\x20fields.\x20\x20It\x20means\x20that\x20wh\ + en\x20the\x20outer\x20message\x20is\x20initially\x20parsed,\x20the\n\x20\ + inner\x20message's\x20contents\x20will\x20not\x20be\x20parsed\x20but\x20\ + instead\x20stored\x20in\x20encoded\n\x20form.\x20\x20The\x20inner\x20mes\ + sage\x20will\x20actually\x20be\x20parsed\x20when\x20it\x20is\x20first\ + \x20accessed.\n\n\x20This\x20is\x20only\x20a\x20hint.\x20\x20Implementat\ + ions\x20are\x20free\x20to\x20choose\x20whether\x20to\x20use\n\x20eager\ + \x20or\x20lazy\x20parsing\x20regardless\x20of\x20the\x20value\x20of\x20t\ + his\x20option.\x20\x20However,\n\x20setting\x20this\x20option\x20true\ + \x20suggests\x20that\x20the\x20protocol\x20author\x20believes\x20that\n\ + \x20using\x20lazy\x20parsing\x20on\x20this\x20field\x20is\x20worth\x20th\ + e\x20additional\x20bookkeeping\n\x20overhead\x20typically\x20needed\x20t\ + o\x20implement\x20it.\n\n\x20This\x20option\x20does\x20not\x20affect\x20\ + the\x20public\x20interface\x20of\x20any\x20generated\x20code;\n\x20all\ + \x20method\x20signatures\x20remain\x20the\x20same.\x20\x20Furthermore,\ + \x20thread-safety\x20of\x20the\n\x20interface\x20is\x20not\x20affected\ + \x20by\x20this\x20option;\x20const\x20methods\x20remain\x20safe\x20to\n\ + \x20call\x20from\x20multiple\x20threads\x20concurrently,\x20while\x20non\ + -const\x20methods\x20continue\n\x20to\x20require\x20exclusive\x20access.\ + \n\n\n\x20Note\x20that\x20implementations\x20may\x20choose\x20not\x20to\ + \x20check\x20required\x20fields\x20within\n\x20a\x20lazy\x20sub-message.\ + \x20\x20That\x20is,\x20calling\x20IsInitialized()\x20on\x20the\x20outer\ + \x20message\n\x20may\x20return\x20true\x20even\x20if\x20the\x20inner\x20\ + message\x20has\x20missing\x20required\x20fields.\n\x20This\x20is\x20nece\ + ssary\x20because\x20otherwise\x20the\x20inner\x20message\x20would\x20hav\ + e\x20to\x20be\n\x20parsed\x20in\x20order\x20to\x20perform\x20the\x20chec\ + k,\x20defeating\x20the\x20purpose\x20of\x20lazy\n\x20parsing.\x20\x20An\ + \x20implementation\x20which\x20chooses\x20not\x20to\x20check\x20required\ + \x20fields\n\x20must\x20be\x20consistent\x20about\x20it.\x20\x20That\x20\ + is,\x20for\x20any\x20particular\x20sub-message,\x20the\n\x20implementati\ + on\x20must\x20either\x20*always*\x20check\x20its\x20required\x20fields,\ + \x20or\x20*never*\n\x20check\x20its\x20required\x20fields,\x20regardless\ + \x20of\x20whether\x20or\x20not\x20the\x20message\x20has\n\x20been\x20par\ + sed.\n\n\r\n\x05\x04\x0b\x02\x03\x04\x12\x04\x80\x04\x02\n\n\r\n\x05\x04\ + \x0b\x02\x03\x05\x12\x04\x80\x04\x0b\x0f\n\r\n\x05\x04\x0b\x02\x03\x01\ + \x12\x04\x80\x04\x10\x14\n\r\n\x05\x04\x0b\x02\x03\x03\x12\x04\x80\x04\ + \x17\x18\n\r\n\x05\x04\x0b\x02\x03\x08\x12\x04\x80\x04\x19(\n\r\n\x05\ + \x04\x0b\x02\x03\x07\x12\x04\x80\x04\"'\n\xe8\x01\n\x04\x04\x0b\x02\x04\ + \x12\x04\x86\x04\x02/\x1a\xd9\x01\x20Is\x20this\x20field\x20deprecated?\ + \n\x20Depending\x20on\x20the\x20target\x20platform,\x20this\x20can\x20em\ + it\x20Deprecated\x20annotations\n\x20for\x20accessors,\x20or\x20it\x20wi\ + ll\x20be\x20completely\x20ignored;\x20in\x20the\x20very\x20least,\x20thi\ + s\n\x20is\x20a\x20formalization\x20for\x20deprecating\x20fields.\n\n\r\n\ + \x05\x04\x0b\x02\x04\x04\x12\x04\x86\x04\x02\n\n\r\n\x05\x04\x0b\x02\x04\ + \x05\x12\x04\x86\x04\x0b\x0f\n\r\n\x05\x04\x0b\x02\x04\x01\x12\x04\x86\ + \x04\x10\x1a\n\r\n\x05\x04\x0b\x02\x04\x03\x12\x04\x86\x04\x1d\x1e\n\r\n\ + \x05\x04\x0b\x02\x04\x08\x12\x04\x86\x04\x1f.\n\r\n\x05\x04\x0b\x02\x04\ + \x07\x12\x04\x86\x04(-\n?\n\x04\x04\x0b\x02\x05\x12\x04\x89\x04\x02*\x1a\ + 1\x20For\x20Google-internal\x20migration\x20only.\x20Do\x20not\x20use.\n\ + \n\r\n\x05\x04\x0b\x02\x05\x04\x12\x04\x89\x04\x02\n\n\r\n\x05\x04\x0b\ + \x02\x05\x05\x12\x04\x89\x04\x0b\x0f\n\r\n\x05\x04\x0b\x02\x05\x01\x12\ + \x04\x89\x04\x10\x14\n\r\n\x05\x04\x0b\x02\x05\x03\x12\x04\x89\x04\x17\ + \x19\n\r\n\x05\x04\x0b\x02\x05\x08\x12\x04\x89\x04\x1a)\n\r\n\x05\x04\ + \x0b\x02\x05\x07\x12\x04\x89\x04#(\nO\n\x04\x04\x0b\x02\x06\x12\x04\x8d\ + \x04\x02:\x1aA\x20The\x20parser\x20stores\x20options\x20it\x20doesn't\ + \x20recognize\x20here.\x20See\x20above.\n\n\r\n\x05\x04\x0b\x02\x06\x04\ + \x12\x04\x8d\x04\x02\n\n\r\n\x05\x04\x0b\x02\x06\x06\x12\x04\x8d\x04\x0b\ + \x1e\n\r\n\x05\x04\x0b\x02\x06\x01\x12\x04\x8d\x04\x1f3\n\r\n\x05\x04\ + \x0b\x02\x06\x03\x12\x04\x8d\x0469\nZ\n\x03\x04\x0b\x05\x12\x04\x90\x04\ + \x02\x19\x1aM\x20Clients\x20can\x20define\x20custom\x20options\x20in\x20\ + extensions\x20of\x20this\x20message.\x20See\x20above.\n\n\x0c\n\x04\x04\ + \x0b\x05\0\x12\x04\x90\x04\r\x18\n\r\n\x05\x04\x0b\x05\0\x01\x12\x04\x90\ + \x04\r\x11\n\r\n\x05\x04\x0b\x05\0\x02\x12\x04\x90\x04\x15\x18\n\x0c\n\ + \x02\x04\x0c\x12\x06\x95\x04\0\x9b\x04\x01\n\x0b\n\x03\x04\x0c\x01\x12\ + \x04\x95\x04\x08\x14\nO\n\x04\x04\x0c\x02\0\x12\x04\x97\x04\x02:\x1aA\ + \x20The\x20parser\x20stores\x20options\x20it\x20doesn't\x20recognize\x20\ + here.\x20See\x20above.\n\n\r\n\x05\x04\x0c\x02\0\x04\x12\x04\x97\x04\x02\ + \n\n\r\n\x05\x04\x0c\x02\0\x06\x12\x04\x97\x04\x0b\x1e\n\r\n\x05\x04\x0c\ + \x02\0\x01\x12\x04\x97\x04\x1f3\n\r\n\x05\x04\x0c\x02\0\x03\x12\x04\x97\ + \x0469\nZ\n\x03\x04\x0c\x05\x12\x04\x9a\x04\x02\x19\x1aM\x20Clients\x20c\ + an\x20define\x20custom\x20options\x20in\x20extensions\x20of\x20this\x20m\ + essage.\x20See\x20above.\n\n\x0c\n\x04\x04\x0c\x05\0\x12\x04\x9a\x04\r\ + \x18\n\r\n\x05\x04\x0c\x05\0\x01\x12\x04\x9a\x04\r\x11\n\r\n\x05\x04\x0c\ + \x05\0\x02\x12\x04\x9a\x04\x15\x18\n\x0c\n\x02\x04\r\x12\x06\x9d\x04\0\ + \xae\x04\x01\n\x0b\n\x03\x04\r\x01\x12\x04\x9d\x04\x08\x13\n`\n\x04\x04\ + \r\x02\0\x12\x04\xa1\x04\x02\x20\x1aR\x20Set\x20this\x20option\x20to\x20\ + true\x20to\x20allow\x20mapping\x20different\x20tag\x20names\x20to\x20the\ + \x20same\n\x20value.\n\n\r\n\x05\x04\r\x02\0\x04\x12\x04\xa1\x04\x02\n\n\ + \r\n\x05\x04\r\x02\0\x05\x12\x04\xa1\x04\x0b\x0f\n\r\n\x05\x04\r\x02\0\ + \x01\x12\x04\xa1\x04\x10\x1b\n\r\n\x05\x04\r\x02\0\x03\x12\x04\xa1\x04\ + \x1e\x1f\n\xe5\x01\n\x04\x04\r\x02\x01\x12\x04\xa7\x04\x02/\x1a\xd6\x01\ + \x20Is\x20this\x20enum\x20deprecated?\n\x20Depending\x20on\x20the\x20tar\ + get\x20platform,\x20this\x20can\x20emit\x20Deprecated\x20annotations\n\ + \x20for\x20the\x20enum,\x20or\x20it\x20will\x20be\x20completely\x20ignor\ + ed;\x20in\x20the\x20very\x20least,\x20this\n\x20is\x20a\x20formalization\ + \x20for\x20deprecating\x20enums.\n\n\r\n\x05\x04\r\x02\x01\x04\x12\x04\ + \xa7\x04\x02\n\n\r\n\x05\x04\r\x02\x01\x05\x12\x04\xa7\x04\x0b\x0f\n\r\n\ + \x05\x04\r\x02\x01\x01\x12\x04\xa7\x04\x10\x1a\n\r\n\x05\x04\r\x02\x01\ + \x03\x12\x04\xa7\x04\x1d\x1e\n\r\n\x05\x04\r\x02\x01\x08\x12\x04\xa7\x04\ + \x1f.\n\r\n\x05\x04\r\x02\x01\x07\x12\x04\xa7\x04(-\nO\n\x04\x04\r\x02\ + \x02\x12\x04\xaa\x04\x02:\x1aA\x20The\x20parser\x20stores\x20options\x20\ + it\x20doesn't\x20recognize\x20here.\x20See\x20above.\n\n\r\n\x05\x04\r\ + \x02\x02\x04\x12\x04\xaa\x04\x02\n\n\r\n\x05\x04\r\x02\x02\x06\x12\x04\ + \xaa\x04\x0b\x1e\n\r\n\x05\x04\r\x02\x02\x01\x12\x04\xaa\x04\x1f3\n\r\n\ + \x05\x04\r\x02\x02\x03\x12\x04\xaa\x0469\nZ\n\x03\x04\r\x05\x12\x04\xad\ + \x04\x02\x19\x1aM\x20Clients\x20can\x20define\x20custom\x20options\x20in\ + \x20extensions\x20of\x20this\x20message.\x20See\x20above.\n\n\x0c\n\x04\ + \x04\r\x05\0\x12\x04\xad\x04\r\x18\n\r\n\x05\x04\r\x05\0\x01\x12\x04\xad\ + \x04\r\x11\n\r\n\x05\x04\r\x05\0\x02\x12\x04\xad\x04\x15\x18\n\x0c\n\x02\ + \x04\x0e\x12\x06\xb0\x04\0\xbc\x04\x01\n\x0b\n\x03\x04\x0e\x01\x12\x04\ + \xb0\x04\x08\x18\n\xf7\x01\n\x04\x04\x0e\x02\0\x12\x04\xb5\x04\x02/\x1a\ + \xe8\x01\x20Is\x20this\x20enum\x20value\x20deprecated?\n\x20Depending\ + \x20on\x20the\x20target\x20platform,\x20this\x20can\x20emit\x20Deprecate\ + d\x20annotations\n\x20for\x20the\x20enum\x20value,\x20or\x20it\x20will\ + \x20be\x20completely\x20ignored;\x20in\x20the\x20very\x20least,\n\x20thi\ + s\x20is\x20a\x20formalization\x20for\x20deprecating\x20enum\x20values.\n\ + \n\r\n\x05\x04\x0e\x02\0\x04\x12\x04\xb5\x04\x02\n\n\r\n\x05\x04\x0e\x02\ + \0\x05\x12\x04\xb5\x04\x0b\x0f\n\r\n\x05\x04\x0e\x02\0\x01\x12\x04\xb5\ + \x04\x10\x1a\n\r\n\x05\x04\x0e\x02\0\x03\x12\x04\xb5\x04\x1d\x1e\n\r\n\ + \x05\x04\x0e\x02\0\x08\x12\x04\xb5\x04\x1f.\n\r\n\x05\x04\x0e\x02\0\x07\ + \x12\x04\xb5\x04(-\nO\n\x04\x04\x0e\x02\x01\x12\x04\xb8\x04\x02:\x1aA\ + \x20The\x20parser\x20stores\x20options\x20it\x20doesn't\x20recognize\x20\ + here.\x20See\x20above.\n\n\r\n\x05\x04\x0e\x02\x01\x04\x12\x04\xb8\x04\ + \x02\n\n\r\n\x05\x04\x0e\x02\x01\x06\x12\x04\xb8\x04\x0b\x1e\n\r\n\x05\ + \x04\x0e\x02\x01\x01\x12\x04\xb8\x04\x1f3\n\r\n\x05\x04\x0e\x02\x01\x03\ + \x12\x04\xb8\x0469\nZ\n\x03\x04\x0e\x05\x12\x04\xbb\x04\x02\x19\x1aM\x20\ + Clients\x20can\x20define\x20custom\x20options\x20in\x20extensions\x20of\ + \x20this\x20message.\x20See\x20above.\n\n\x0c\n\x04\x04\x0e\x05\0\x12\ + \x04\xbb\x04\r\x18\n\r\n\x05\x04\x0e\x05\0\x01\x12\x04\xbb\x04\r\x11\n\r\ + \n\x05\x04\x0e\x05\0\x02\x12\x04\xbb\x04\x15\x18\n\x0c\n\x02\x04\x0f\x12\ + \x06\xbe\x04\0\xd0\x04\x01\n\x0b\n\x03\x04\x0f\x01\x12\x04\xbe\x04\x08\ + \x16\n\xd9\x03\n\x04\x04\x0f\x02\0\x12\x04\xc9\x04\x020\x1a\xdf\x01\x20I\ + s\x20this\x20service\x20deprecated?\n\x20Depending\x20on\x20the\x20targe\ + t\x20platform,\x20this\x20can\x20emit\x20Deprecated\x20annotations\n\x20\ + for\x20the\x20service,\x20or\x20it\x20will\x20be\x20completely\x20ignore\ + d;\x20in\x20the\x20very\x20least,\n\x20this\x20is\x20a\x20formalization\ + \x20for\x20deprecating\x20services.\n2\xe8\x01\x20Note:\x20\x20Field\x20\ + numbers\x201\x20through\x2032\x20are\x20reserved\x20for\x20Google's\x20i\ + nternal\x20RPC\n\x20\x20\x20framework.\x20\x20We\x20apologize\x20for\x20\ + hoarding\x20these\x20numbers\x20to\x20ourselves,\x20but\n\x20\x20\x20we\ + \x20were\x20already\x20using\x20them\x20long\x20before\x20we\x20decided\ + \x20to\x20release\x20Protocol\n\x20\x20\x20Buffers.\n\n\r\n\x05\x04\x0f\ + \x02\0\x04\x12\x04\xc9\x04\x02\n\n\r\n\x05\x04\x0f\x02\0\x05\x12\x04\xc9\ + \x04\x0b\x0f\n\r\n\x05\x04\x0f\x02\0\x01\x12\x04\xc9\x04\x10\x1a\n\r\n\ + \x05\x04\x0f\x02\0\x03\x12\x04\xc9\x04\x1d\x1f\n\r\n\x05\x04\x0f\x02\0\ + \x08\x12\x04\xc9\x04\x20/\n\r\n\x05\x04\x0f\x02\0\x07\x12\x04\xc9\x04).\ + \nO\n\x04\x04\x0f\x02\x01\x12\x04\xcc\x04\x02:\x1aA\x20The\x20parser\x20\ + stores\x20options\x20it\x20doesn't\x20recognize\x20here.\x20See\x20above\ + .\n\n\r\n\x05\x04\x0f\x02\x01\x04\x12\x04\xcc\x04\x02\n\n\r\n\x05\x04\ + \x0f\x02\x01\x06\x12\x04\xcc\x04\x0b\x1e\n\r\n\x05\x04\x0f\x02\x01\x01\ + \x12\x04\xcc\x04\x1f3\n\r\n\x05\x04\x0f\x02\x01\x03\x12\x04\xcc\x0469\nZ\ + \n\x03\x04\x0f\x05\x12\x04\xcf\x04\x02\x19\x1aM\x20Clients\x20can\x20def\ + ine\x20custom\x20options\x20in\x20extensions\x20of\x20this\x20message.\ + \x20See\x20above.\n\n\x0c\n\x04\x04\x0f\x05\0\x12\x04\xcf\x04\r\x18\n\r\ + \n\x05\x04\x0f\x05\0\x01\x12\x04\xcf\x04\r\x11\n\r\n\x05\x04\x0f\x05\0\ + \x02\x12\x04\xcf\x04\x15\x18\n\x0c\n\x02\x04\x10\x12\x06\xd2\x04\0\xe4\ + \x04\x01\n\x0b\n\x03\x04\x10\x01\x12\x04\xd2\x04\x08\x15\n\xd6\x03\n\x04\ + \x04\x10\x02\0\x12\x04\xdd\x04\x020\x1a\xdc\x01\x20Is\x20this\x20method\ + \x20deprecated?\n\x20Depending\x20on\x20the\x20target\x20platform,\x20th\ + is\x20can\x20emit\x20Deprecated\x20annotations\n\x20for\x20the\x20method\ + ,\x20or\x20it\x20will\x20be\x20completely\x20ignored;\x20in\x20the\x20ve\ + ry\x20least,\n\x20this\x20is\x20a\x20formalization\x20for\x20deprecating\ + \x20methods.\n2\xe8\x01\x20Note:\x20\x20Field\x20numbers\x201\x20through\ + \x2032\x20are\x20reserved\x20for\x20Google's\x20internal\x20RPC\n\x20\ + \x20\x20framework.\x20\x20We\x20apologize\x20for\x20hoarding\x20these\ + \x20numbers\x20to\x20ourselves,\x20but\n\x20\x20\x20we\x20were\x20alread\ + y\x20using\x20them\x20long\x20before\x20we\x20decided\x20to\x20release\ + \x20Protocol\n\x20\x20\x20Buffers.\n\n\r\n\x05\x04\x10\x02\0\x04\x12\x04\ + \xdd\x04\x02\n\n\r\n\x05\x04\x10\x02\0\x05\x12\x04\xdd\x04\x0b\x0f\n\r\n\ + \x05\x04\x10\x02\0\x01\x12\x04\xdd\x04\x10\x1a\n\r\n\x05\x04\x10\x02\0\ + \x03\x12\x04\xdd\x04\x1d\x1f\n\r\n\x05\x04\x10\x02\0\x08\x12\x04\xdd\x04\ + \x20/\n\r\n\x05\x04\x10\x02\0\x07\x12\x04\xdd\x04).\nO\n\x04\x04\x10\x02\ + \x01\x12\x04\xe0\x04\x02:\x1aA\x20The\x20parser\x20stores\x20options\x20\ + it\x20doesn't\x20recognize\x20here.\x20See\x20above.\n\n\r\n\x05\x04\x10\ + \x02\x01\x04\x12\x04\xe0\x04\x02\n\n\r\n\x05\x04\x10\x02\x01\x06\x12\x04\ + \xe0\x04\x0b\x1e\n\r\n\x05\x04\x10\x02\x01\x01\x12\x04\xe0\x04\x1f3\n\r\ + \n\x05\x04\x10\x02\x01\x03\x12\x04\xe0\x0469\nZ\n\x03\x04\x10\x05\x12\ + \x04\xe3\x04\x02\x19\x1aM\x20Clients\x20can\x20define\x20custom\x20optio\ + ns\x20in\x20extensions\x20of\x20this\x20message.\x20See\x20above.\n\n\ + \x0c\n\x04\x04\x10\x05\0\x12\x04\xe3\x04\r\x18\n\r\n\x05\x04\x10\x05\0\ + \x01\x12\x04\xe3\x04\r\x11\n\r\n\x05\x04\x10\x05\0\x02\x12\x04\xe3\x04\ + \x15\x18\n\x8b\x03\n\x02\x04\x11\x12\x06\xed\x04\0\x81\x05\x01\x1a\xfc\ + \x02\x20A\x20message\x20representing\x20a\x20option\x20the\x20parser\x20\ + does\x20not\x20recognize.\x20This\x20only\n\x20appears\x20in\x20options\ + \x20protos\x20created\x20by\x20the\x20compiler::Parser\x20class.\n\x20De\ + scriptorPool\x20resolves\x20these\x20when\x20building\x20Descriptor\x20o\ + bjects.\x20Therefore,\n\x20options\x20protos\x20in\x20descriptor\x20obje\ + cts\x20(e.g.\x20returned\x20by\x20Descriptor::options(),\n\x20or\x20prod\ + uced\x20by\x20Descriptor::CopyTo())\x20will\x20never\x20have\x20Uninterp\ + retedOptions\n\x20in\x20them.\n\n\x0b\n\x03\x04\x11\x01\x12\x04\xed\x04\ + \x08\x1b\n\xcb\x02\n\x04\x04\x11\x03\0\x12\x06\xf3\x04\x02\xf6\x04\x03\ + \x1a\xba\x02\x20The\x20name\x20of\x20the\x20uninterpreted\x20option.\x20\ + \x20Each\x20string\x20represents\x20a\x20segment\x20in\n\x20a\x20dot-sep\ + arated\x20name.\x20\x20is_extension\x20is\x20true\x20iff\x20a\x20segment\ + \x20represents\x20an\n\x20extension\x20(denoted\x20with\x20parentheses\ + \x20in\x20options\x20specs\x20in\x20.proto\x20files).\n\x20E.g.,{\x20[\"\ + foo\",\x20false],\x20[\"bar.baz\",\x20true],\x20[\"qux\",\x20false]\x20}\ + \x20represents\n\x20\"foo.(bar.baz).qux\".\n\n\r\n\x05\x04\x11\x03\0\x01\ + \x12\x04\xf3\x04\n\x12\n\x0e\n\x06\x04\x11\x03\0\x02\0\x12\x04\xf4\x04\ + \x04\"\n\x0f\n\x07\x04\x11\x03\0\x02\0\x04\x12\x04\xf4\x04\x04\x0c\n\x0f\ + \n\x07\x04\x11\x03\0\x02\0\x05\x12\x04\xf4\x04\r\x13\n\x0f\n\x07\x04\x11\ + \x03\0\x02\0\x01\x12\x04\xf4\x04\x14\x1d\n\x0f\n\x07\x04\x11\x03\0\x02\0\ + \x03\x12\x04\xf4\x04\x20!\n\x0e\n\x06\x04\x11\x03\0\x02\x01\x12\x04\xf5\ + \x04\x04#\n\x0f\n\x07\x04\x11\x03\0\x02\x01\x04\x12\x04\xf5\x04\x04\x0c\ + \n\x0f\n\x07\x04\x11\x03\0\x02\x01\x05\x12\x04\xf5\x04\r\x11\n\x0f\n\x07\ + \x04\x11\x03\0\x02\x01\x01\x12\x04\xf5\x04\x12\x1e\n\x0f\n\x07\x04\x11\ + \x03\0\x02\x01\x03\x12\x04\xf5\x04!\"\n\x0c\n\x04\x04\x11\x02\0\x12\x04\ + \xf7\x04\x02\x1d\n\r\n\x05\x04\x11\x02\0\x04\x12\x04\xf7\x04\x02\n\n\r\n\ + \x05\x04\x11\x02\0\x06\x12\x04\xf7\x04\x0b\x13\n\r\n\x05\x04\x11\x02\0\ + \x01\x12\x04\xf7\x04\x14\x18\n\r\n\x05\x04\x11\x02\0\x03\x12\x04\xf7\x04\ + \x1b\x1c\n\x9c\x01\n\x04\x04\x11\x02\x01\x12\x04\xfb\x04\x02'\x1a\x8d\ + \x01\x20The\x20value\x20of\x20the\x20uninterpreted\x20option,\x20in\x20w\ + hatever\x20type\x20the\x20tokenizer\n\x20identified\x20it\x20as\x20durin\ + g\x20parsing.\x20Exactly\x20one\x20of\x20these\x20should\x20be\x20set.\n\ + \n\r\n\x05\x04\x11\x02\x01\x04\x12\x04\xfb\x04\x02\n\n\r\n\x05\x04\x11\ + \x02\x01\x05\x12\x04\xfb\x04\x0b\x11\n\r\n\x05\x04\x11\x02\x01\x01\x12\ + \x04\xfb\x04\x12\"\n\r\n\x05\x04\x11\x02\x01\x03\x12\x04\xfb\x04%&\n\x0c\ + \n\x04\x04\x11\x02\x02\x12\x04\xfc\x04\x02)\n\r\n\x05\x04\x11\x02\x02\ + \x04\x12\x04\xfc\x04\x02\n\n\r\n\x05\x04\x11\x02\x02\x05\x12\x04\xfc\x04\ + \x0b\x11\n\r\n\x05\x04\x11\x02\x02\x01\x12\x04\xfc\x04\x12$\n\r\n\x05\ + \x04\x11\x02\x02\x03\x12\x04\xfc\x04'(\n\x0c\n\x04\x04\x11\x02\x03\x12\ + \x04\xfd\x04\x02(\n\r\n\x05\x04\x11\x02\x03\x04\x12\x04\xfd\x04\x02\n\n\ + \r\n\x05\x04\x11\x02\x03\x05\x12\x04\xfd\x04\x0b\x10\n\r\n\x05\x04\x11\ + \x02\x03\x01\x12\x04\xfd\x04\x11#\n\r\n\x05\x04\x11\x02\x03\x03\x12\x04\ + \xfd\x04&'\n\x0c\n\x04\x04\x11\x02\x04\x12\x04\xfe\x04\x02#\n\r\n\x05\ + \x04\x11\x02\x04\x04\x12\x04\xfe\x04\x02\n\n\r\n\x05\x04\x11\x02\x04\x05\ + \x12\x04\xfe\x04\x0b\x11\n\r\n\x05\x04\x11\x02\x04\x01\x12\x04\xfe\x04\ + \x12\x1e\n\r\n\x05\x04\x11\x02\x04\x03\x12\x04\xfe\x04!\"\n\x0c\n\x04\ + \x04\x11\x02\x05\x12\x04\xff\x04\x02\"\n\r\n\x05\x04\x11\x02\x05\x04\x12\ + \x04\xff\x04\x02\n\n\r\n\x05\x04\x11\x02\x05\x05\x12\x04\xff\x04\x0b\x10\ + \n\r\n\x05\x04\x11\x02\x05\x01\x12\x04\xff\x04\x11\x1d\n\r\n\x05\x04\x11\ + \x02\x05\x03\x12\x04\xff\x04\x20!\n\x0c\n\x04\x04\x11\x02\x06\x12\x04\ + \x80\x05\x02&\n\r\n\x05\x04\x11\x02\x06\x04\x12\x04\x80\x05\x02\n\n\r\n\ + \x05\x04\x11\x02\x06\x05\x12\x04\x80\x05\x0b\x11\n\r\n\x05\x04\x11\x02\ + \x06\x01\x12\x04\x80\x05\x12!\n\r\n\x05\x04\x11\x02\x06\x03\x12\x04\x80\ + \x05$%\n\xda\x01\n\x02\x04\x12\x12\x06\x88\x05\0\x89\x06\x01\x1aj\x20Enc\ + apsulates\x20information\x20about\x20the\x20original\x20source\x20file\ + \x20from\x20which\x20a\n\x20FileDescriptorProto\x20was\x20generated.\n2`\ + \x20===================================================================\ + \n\x20Optional\x20source\x20code\x20info\n\n\x0b\n\x03\x04\x12\x01\x12\ + \x04\x88\x05\x08\x16\n\x82\x11\n\x04\x04\x12\x02\0\x12\x04\xb4\x05\x02!\ + \x1a\xf3\x10\x20A\x20Location\x20identifies\x20a\x20piece\x20of\x20sourc\ + e\x20code\x20in\x20a\x20.proto\x20file\x20which\n\x20corresponds\x20to\ + \x20a\x20particular\x20definition.\x20\x20This\x20information\x20is\x20i\ + ntended\n\x20to\x20be\x20useful\x20to\x20IDEs,\x20code\x20indexers,\x20d\ + ocumentation\x20generators,\x20and\x20similar\n\x20tools.\n\n\x20For\x20\ + example,\x20say\x20we\x20have\x20a\x20file\x20like:\n\x20\x20\x20message\ + \x20Foo\x20{\n\x20\x20\x20\x20\x20optional\x20string\x20foo\x20=\x201;\n\ + \x20\x20\x20}\n\x20Let's\x20look\x20at\x20just\x20the\x20field\x20defini\ + tion:\n\x20\x20\x20optional\x20string\x20foo\x20=\x201;\n\x20\x20\x20^\ + \x20\x20\x20\x20\x20\x20\x20^^\x20\x20\x20\x20\x20^^\x20\x20^\x20\x20^^^\ + \n\x20\x20\x20a\x20\x20\x20\x20\x20\x20\x20bc\x20\x20\x20\x20\x20de\x20\ + \x20f\x20\x20ghi\n\x20We\x20have\x20the\x20following\x20locations:\n\x20\ + \x20\x20span\x20\x20\x20path\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20represents\n\x20\x20\x20[a,i)\x20\x20[\x204,\x200,\x202,\ + \x200\x20]\x20\x20\x20\x20\x20The\x20whole\x20field\x20definition.\n\x20\ + \x20\x20[a,b)\x20\x20[\x204,\x200,\x202,\x200,\x204\x20]\x20\x20The\x20l\ + abel\x20(optional).\n\x20\x20\x20[c,d)\x20\x20[\x204,\x200,\x202,\x200,\ + \x205\x20]\x20\x20The\x20type\x20(string).\n\x20\x20\x20[e,f)\x20\x20[\ + \x204,\x200,\x202,\x200,\x201\x20]\x20\x20The\x20name\x20(foo).\n\x20\ + \x20\x20[g,h)\x20\x20[\x204,\x200,\x202,\x200,\x203\x20]\x20\x20The\x20n\ + umber\x20(1).\n\n\x20Notes:\n\x20-\x20A\x20location\x20may\x20refer\x20t\ + o\x20a\x20repeated\x20field\x20itself\x20(i.e.\x20not\x20to\x20any\n\x20\ + \x20\x20particular\x20index\x20within\x20it).\x20\x20This\x20is\x20used\ + \x20whenever\x20a\x20set\x20of\x20elements\x20are\n\x20\x20\x20logically\ + \x20enclosed\x20in\x20a\x20single\x20code\x20segment.\x20\x20For\x20exam\ + ple,\x20an\x20entire\n\x20\x20\x20extend\x20block\x20(possibly\x20contai\ + ning\x20multiple\x20extension\x20definitions)\x20will\n\x20\x20\x20have\ + \x20an\x20outer\x20location\x20whose\x20path\x20refers\x20to\x20the\x20\ + \"extensions\"\x20repeated\n\x20\x20\x20field\x20without\x20an\x20index.\ + \n\x20-\x20Multiple\x20locations\x20may\x20have\x20the\x20same\x20path.\ + \x20\x20This\x20happens\x20when\x20a\x20single\n\x20\x20\x20logical\x20d\ + eclaration\x20is\x20spread\x20out\x20across\x20multiple\x20places.\x20\ + \x20The\x20most\n\x20\x20\x20obvious\x20example\x20is\x20the\x20\"extend\ + \"\x20block\x20again\x20--\x20there\x20may\x20be\x20multiple\n\x20\x20\ + \x20extend\x20blocks\x20in\x20the\x20same\x20scope,\x20each\x20of\x20whi\ + ch\x20will\x20have\x20the\x20same\x20path.\n\x20-\x20A\x20location's\x20\ + span\x20is\x20not\x20always\x20a\x20subset\x20of\x20its\x20parent's\x20s\ + pan.\x20\x20For\n\x20\x20\x20example,\x20the\x20\"extendee\"\x20of\x20an\ + \x20extension\x20declaration\x20appears\x20at\x20the\n\x20\x20\x20beginn\ + ing\x20of\x20the\x20\"extend\"\x20block\x20and\x20is\x20shared\x20by\x20\ + all\x20extensions\x20within\n\x20\x20\x20the\x20block.\n\x20-\x20Just\ + \x20because\x20a\x20location's\x20span\x20is\x20a\x20subset\x20of\x20som\ + e\x20other\x20location's\x20span\n\x20\x20\x20does\x20not\x20mean\x20tha\ + t\x20it\x20is\x20a\x20descendent.\x20\x20For\x20example,\x20a\x20\"group\ + \"\x20defines\n\x20\x20\x20both\x20a\x20type\x20and\x20a\x20field\x20in\ + \x20a\x20single\x20declaration.\x20\x20Thus,\x20the\x20locations\n\x20\ + \x20\x20corresponding\x20to\x20the\x20type\x20and\x20field\x20and\x20the\ + ir\x20components\x20will\x20overlap.\n\x20-\x20Code\x20which\x20tries\ + \x20to\x20interpret\x20locations\x20should\x20probably\x20be\x20designed\ + \x20to\n\x20\x20\x20ignore\x20those\x20that\x20it\x20doesn't\x20understa\ + nd,\x20as\x20more\x20types\x20of\x20locations\x20could\n\x20\x20\x20be\ + \x20recorded\x20in\x20the\x20future.\n\n\r\n\x05\x04\x12\x02\0\x04\x12\ + \x04\xb4\x05\x02\n\n\r\n\x05\x04\x12\x02\0\x06\x12\x04\xb4\x05\x0b\x13\n\ + \r\n\x05\x04\x12\x02\0\x01\x12\x04\xb4\x05\x14\x1c\n\r\n\x05\x04\x12\x02\ + \0\x03\x12\x04\xb4\x05\x1f\x20\n\x0e\n\x04\x04\x12\x03\0\x12\x06\xb5\x05\ + \x02\x88\x06\x03\n\r\n\x05\x04\x12\x03\0\x01\x12\x04\xb5\x05\n\x12\n\x83\ + \x07\n\x06\x04\x12\x03\0\x02\0\x12\x04\xcd\x05\x04*\x1a\xf2\x06\x20Ident\ + ifies\x20which\x20part\x20of\x20the\x20FileDescriptorProto\x20was\x20def\ + ined\x20at\x20this\n\x20location.\n\n\x20Each\x20element\x20is\x20a\x20f\ + ield\x20number\x20or\x20an\x20index.\x20\x20They\x20form\x20a\x20path\ + \x20from\n\x20the\x20root\x20FileDescriptorProto\x20to\x20the\x20place\ + \x20where\x20the\x20definition.\x20\x20For\n\x20example,\x20this\x20path\ + :\n\x20\x20\x20[\x204,\x203,\x202,\x207,\x201\x20]\n\x20refers\x20to:\n\ + \x20\x20\x20file.message_type(3)\x20\x20//\x204,\x203\n\x20\x20\x20\x20\ + \x20\x20\x20.field(7)\x20\x20\x20\x20\x20\x20\x20\x20\x20//\x202,\x207\n\ + \x20\x20\x20\x20\x20\x20\x20.name()\x20\x20\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20//\x201\n\x20This\x20is\x20because\x20FileDescriptorProto.messag\ + e_type\x20has\x20field\x20number\x204:\n\x20\x20\x20repeated\x20Descript\ + orProto\x20message_type\x20=\x204;\n\x20and\x20DescriptorProto.field\x20\ + has\x20field\x20number\x202:\n\x20\x20\x20repeated\x20FieldDescriptorPro\ + to\x20field\x20=\x202;\n\x20and\x20FieldDescriptorProto.name\x20has\x20f\ + ield\x20number\x201:\n\x20\x20\x20optional\x20string\x20name\x20=\x201;\ + \n\n\x20Thus,\x20the\x20above\x20path\x20gives\x20the\x20location\x20of\ + \x20a\x20field\x20name.\x20\x20If\x20we\x20removed\n\x20the\x20last\x20e\ + lement:\n\x20\x20\x20[\x204,\x203,\x202,\x207\x20]\n\x20this\x20path\x20\ + refers\x20to\x20the\x20whole\x20field\x20declaration\x20(from\x20the\x20\ + beginning\n\x20of\x20the\x20label\x20to\x20the\x20terminating\x20semicol\ + on).\n\n\x0f\n\x07\x04\x12\x03\0\x02\0\x04\x12\x04\xcd\x05\x04\x0c\n\x0f\ + \n\x07\x04\x12\x03\0\x02\0\x05\x12\x04\xcd\x05\r\x12\n\x0f\n\x07\x04\x12\ + \x03\0\x02\0\x01\x12\x04\xcd\x05\x13\x17\n\x0f\n\x07\x04\x12\x03\0\x02\0\ + \x03\x12\x04\xcd\x05\x1a\x1b\n\x0f\n\x07\x04\x12\x03\0\x02\0\x08\x12\x04\ + \xcd\x05\x1c)\n\x10\n\x08\x04\x12\x03\0\x02\0\x08\x02\x12\x04\xcd\x05\ + \x1d(\n\xd2\x02\n\x06\x04\x12\x03\0\x02\x01\x12\x04\xd4\x05\x04*\x1a\xc1\ + \x02\x20Always\x20has\x20exactly\x20three\x20or\x20four\x20elements:\x20\ + start\x20line,\x20start\x20column,\n\x20end\x20line\x20(optional,\x20oth\ + erwise\x20assumed\x20same\x20as\x20start\x20line),\x20end\x20column.\n\ + \x20These\x20are\x20packed\x20into\x20a\x20single\x20field\x20for\x20eff\ + iciency.\x20\x20Note\x20that\x20line\n\x20and\x20column\x20numbers\x20ar\ + e\x20zero-based\x20--\x20typically\x20you\x20will\x20want\x20to\x20add\n\ + \x201\x20to\x20each\x20before\x20displaying\x20to\x20a\x20user.\n\n\x0f\ + \n\x07\x04\x12\x03\0\x02\x01\x04\x12\x04\xd4\x05\x04\x0c\n\x0f\n\x07\x04\ + \x12\x03\0\x02\x01\x05\x12\x04\xd4\x05\r\x12\n\x0f\n\x07\x04\x12\x03\0\ + \x02\x01\x01\x12\x04\xd4\x05\x13\x17\n\x0f\n\x07\x04\x12\x03\0\x02\x01\ + \x03\x12\x04\xd4\x05\x1a\x1b\n\x0f\n\x07\x04\x12\x03\0\x02\x01\x08\x12\ + \x04\xd4\x05\x1c)\n\x10\n\x08\x04\x12\x03\0\x02\x01\x08\x02\x12\x04\xd4\ + \x05\x1d(\n\xa5\x0c\n\x06\x04\x12\x03\0\x02\x02\x12\x04\x85\x06\x04)\x1a\ + \x94\x0c\x20If\x20this\x20SourceCodeInfo\x20represents\x20a\x20complete\ + \x20declaration,\x20these\x20are\x20any\n\x20comments\x20appearing\x20be\ + fore\x20and\x20after\x20the\x20declaration\x20which\x20appear\x20to\x20b\ + e\n\x20attached\x20to\x20the\x20declaration.\n\n\x20A\x20series\x20of\ + \x20line\x20comments\x20appearing\x20on\x20consecutive\x20lines,\x20with\ + \x20no\x20other\n\x20tokens\x20appearing\x20on\x20those\x20lines,\x20wil\ + l\x20be\x20treated\x20as\x20a\x20single\x20comment.\n\n\x20leading_detac\ + hed_comments\x20will\x20keep\x20paragraphs\x20of\x20comments\x20that\x20\ + appear\n\x20before\x20(but\x20not\x20connected\x20to)\x20the\x20current\ + \x20element.\x20Each\x20paragraph,\n\x20separated\x20by\x20empty\x20line\ + s,\x20will\x20be\x20one\x20comment\x20element\x20in\x20the\x20repeated\n\ + \x20field.\n\n\x20Only\x20the\x20comment\x20content\x20is\x20provided;\ + \x20comment\x20markers\x20(e.g.\x20//)\x20are\n\x20stripped\x20out.\x20\ + \x20For\x20block\x20comments,\x20leading\x20whitespace\x20and\x20an\x20a\ + sterisk\n\x20will\x20be\x20stripped\x20from\x20the\x20beginning\x20of\ + \x20each\x20line\x20other\x20than\x20the\x20first.\n\x20Newlines\x20are\ + \x20included\x20in\x20the\x20output.\n\n\x20Examples:\n\n\x20\x20\x20opt\ + ional\x20int32\x20foo\x20=\x201;\x20\x20//\x20Comment\x20attached\x20to\ + \x20foo.\n\x20\x20\x20//\x20Comment\x20attached\x20to\x20bar.\n\x20\x20\ + \x20optional\x20int32\x20bar\x20=\x202;\n\n\x20\x20\x20optional\x20strin\ + g\x20baz\x20=\x203;\n\x20\x20\x20//\x20Comment\x20attached\x20to\x20baz.\ + \n\x20\x20\x20//\x20Another\x20line\x20attached\x20to\x20baz.\n\n\x20\ + \x20\x20//\x20Comment\x20attached\x20to\x20qux.\n\x20\x20\x20//\n\x20\ + \x20\x20//\x20Another\x20line\x20attached\x20to\x20qux.\n\x20\x20\x20opt\ + ional\x20double\x20qux\x20=\x204;\n\n\x20\x20\x20//\x20Detached\x20comme\ + nt\x20for\x20corge.\x20This\x20is\x20not\x20leading\x20or\x20trailing\ + \x20comments\n\x20\x20\x20//\x20to\x20qux\x20or\x20corge\x20because\x20t\ + here\x20are\x20blank\x20lines\x20separating\x20it\x20from\n\x20\x20\x20/\ + /\x20both.\n\n\x20\x20\x20//\x20Detached\x20comment\x20for\x20corge\x20p\ + aragraph\x202.\n\n\x20\x20\x20optional\x20string\x20corge\x20=\x205;\n\ + \x20\x20\x20/*\x20Block\x20comment\x20attached\n\x20\x20\x20\x20*\x20to\ + \x20corge.\x20\x20Leading\x20asterisks\n\x20\x20\x20\x20*\x20will\x20be\ + \x20removed.\x20*/\n\x20\x20\x20/*\x20Block\x20comment\x20attached\x20to\ + \n\x20\x20\x20\x20*\x20grault.\x20*/\n\x20\x20\x20optional\x20int32\x20g\ + rault\x20=\x206;\n\n\x20\x20\x20//\x20ignored\x20detached\x20comments.\n\ + \n\x0f\n\x07\x04\x12\x03\0\x02\x02\x04\x12\x04\x85\x06\x04\x0c\n\x0f\n\ + \x07\x04\x12\x03\0\x02\x02\x05\x12\x04\x85\x06\r\x13\n\x0f\n\x07\x04\x12\ + \x03\0\x02\x02\x01\x12\x04\x85\x06\x14$\n\x0f\n\x07\x04\x12\x03\0\x02\ + \x02\x03\x12\x04\x85\x06'(\n\x0e\n\x06\x04\x12\x03\0\x02\x03\x12\x04\x86\ + \x06\x04*\n\x0f\n\x07\x04\x12\x03\0\x02\x03\x04\x12\x04\x86\x06\x04\x0c\ + \n\x0f\n\x07\x04\x12\x03\0\x02\x03\x05\x12\x04\x86\x06\r\x13\n\x0f\n\x07\ + \x04\x12\x03\0\x02\x03\x01\x12\x04\x86\x06\x14%\n\x0f\n\x07\x04\x12\x03\ + \0\x02\x03\x03\x12\x04\x86\x06()\n\x0e\n\x06\x04\x12\x03\0\x02\x04\x12\ + \x04\x87\x06\x042\n\x0f\n\x07\x04\x12\x03\0\x02\x04\x04\x12\x04\x87\x06\ + \x04\x0c\n\x0f\n\x07\x04\x12\x03\0\x02\x04\x05\x12\x04\x87\x06\r\x13\n\ + \x0f\n\x07\x04\x12\x03\0\x02\x04\x01\x12\x04\x87\x06\x14-\n\x0f\n\x07\ + \x04\x12\x03\0\x02\x04\x03\x12\x04\x87\x0601\n\xee\x01\n\x02\x04\x13\x12\ + \x06\x8e\x06\0\xa3\x06\x01\x1a\xdf\x01\x20Describes\x20the\x20relationsh\ + ip\x20between\x20generated\x20code\x20and\x20its\x20original\x20source\n\ + \x20file.\x20A\x20GeneratedCodeInfo\x20message\x20is\x20associated\x20wi\ + th\x20only\x20one\x20generated\n\x20source\x20file,\x20but\x20may\x20con\ + tain\x20references\x20to\x20different\x20source\x20.proto\x20files.\n\n\ + \x0b\n\x03\x04\x13\x01\x12\x04\x8e\x06\x08\x19\nx\n\x04\x04\x13\x02\0\ + \x12\x04\x91\x06\x02%\x1aj\x20An\x20Annotation\x20connects\x20some\x20sp\ + an\x20of\x20text\x20in\x20generated\x20code\x20to\x20an\x20element\n\x20\ + of\x20its\x20generating\x20.proto\x20file.\n\n\r\n\x05\x04\x13\x02\0\x04\ + \x12\x04\x91\x06\x02\n\n\r\n\x05\x04\x13\x02\0\x06\x12\x04\x91\x06\x0b\ + \x15\n\r\n\x05\x04\x13\x02\0\x01\x12\x04\x91\x06\x16\x20\n\r\n\x05\x04\ + \x13\x02\0\x03\x12\x04\x91\x06#$\n\x0e\n\x04\x04\x13\x03\0\x12\x06\x92\ + \x06\x02\xa2\x06\x03\n\r\n\x05\x04\x13\x03\0\x01\x12\x04\x92\x06\n\x14\n\ + \x8f\x01\n\x06\x04\x13\x03\0\x02\0\x12\x04\x95\x06\x04*\x1a\x7f\x20Ident\ + ifies\x20the\x20element\x20in\x20the\x20original\x20source\x20.proto\x20\ + file.\x20This\x20field\n\x20is\x20formatted\x20the\x20same\x20as\x20Sour\ + ceCodeInfo.Location.path.\n\n\x0f\n\x07\x04\x13\x03\0\x02\0\x04\x12\x04\ + \x95\x06\x04\x0c\n\x0f\n\x07\x04\x13\x03\0\x02\0\x05\x12\x04\x95\x06\r\ + \x12\n\x0f\n\x07\x04\x13\x03\0\x02\0\x01\x12\x04\x95\x06\x13\x17\n\x0f\n\ + \x07\x04\x13\x03\0\x02\0\x03\x12\x04\x95\x06\x1a\x1b\n\x0f\n\x07\x04\x13\ + \x03\0\x02\0\x08\x12\x04\x95\x06\x1c)\n\x10\n\x08\x04\x13\x03\0\x02\0\ + \x08\x02\x12\x04\x95\x06\x1d(\nO\n\x06\x04\x13\x03\0\x02\x01\x12\x04\x98\ + \x06\x04$\x1a?\x20Identifies\x20the\x20filesystem\x20path\x20to\x20the\ + \x20original\x20source\x20.proto.\n\n\x0f\n\x07\x04\x13\x03\0\x02\x01\ + \x04\x12\x04\x98\x06\x04\x0c\n\x0f\n\x07\x04\x13\x03\0\x02\x01\x05\x12\ + \x04\x98\x06\r\x13\n\x0f\n\x07\x04\x13\x03\0\x02\x01\x01\x12\x04\x98\x06\ + \x14\x1f\n\x0f\n\x07\x04\x13\x03\0\x02\x01\x03\x12\x04\x98\x06\"#\nw\n\ + \x06\x04\x13\x03\0\x02\x02\x12\x04\x9c\x06\x04\x1d\x1ag\x20Identifies\ + \x20the\x20starting\x20offset\x20in\x20bytes\x20in\x20the\x20generated\ + \x20code\n\x20that\x20relates\x20to\x20the\x20identified\x20object.\n\n\ + \x0f\n\x07\x04\x13\x03\0\x02\x02\x04\x12\x04\x9c\x06\x04\x0c\n\x0f\n\x07\ + \x04\x13\x03\0\x02\x02\x05\x12\x04\x9c\x06\r\x12\n\x0f\n\x07\x04\x13\x03\ + \0\x02\x02\x01\x12\x04\x9c\x06\x13\x18\n\x0f\n\x07\x04\x13\x03\0\x02\x02\ + \x03\x12\x04\x9c\x06\x1b\x1c\n\xdb\x01\n\x06\x04\x13\x03\0\x02\x03\x12\ + \x04\xa1\x06\x04\x1b\x1a\xca\x01\x20Identifies\x20the\x20ending\x20offse\ + t\x20in\x20bytes\x20in\x20the\x20generated\x20code\x20that\n\x20relates\ + \x20to\x20the\x20identified\x20offset.\x20The\x20end\x20offset\x20should\ + \x20be\x20one\x20past\n\x20the\x20last\x20relevant\x20byte\x20(so\x20the\ + \x20length\x20of\x20the\x20text\x20=\x20end\x20-\x20begin).\n\n\x0f\n\ + \x07\x04\x13\x03\0\x02\x03\x04\x12\x04\xa1\x06\x04\x0c\n\x0f\n\x07\x04\ + \x13\x03\0\x02\x03\x05\x12\x04\xa1\x06\r\x12\n\x0f\n\x07\x04\x13\x03\0\ + \x02\x03\x01\x12\x04\xa1\x06\x13\x16\n\x0f\n\x07\x04\x13\x03\0\x02\x03\ + \x03\x12\x04\xa1\x06\x19\x1a\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/src/descriptorx.rs b/src/descriptorx.rs new file mode 100644 index 0000000..033aa2a --- /dev/null +++ b/src/descriptorx.rs @@ -0,0 +1,657 @@ +// Should not be a part of public API +#![doc(hidden)] + +use descriptor::DescriptorProto; +use descriptor::EnumDescriptorProto; +use descriptor::EnumValueDescriptorProto; +use descriptor::FieldDescriptorProto; +/// utilities to work with descriptor +use descriptor::FileDescriptorProto; +use descriptor::OneofDescriptorProto; + +use rust; +use strx; + +// Copy-pasted from libsyntax. +fn ident_start(c: char) -> bool { + (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' +} + +// Copy-pasted from libsyntax. +fn ident_continue(c: char) -> bool { + (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' +} + +pub fn proto_path_to_rust_mod(path: &str) -> String { + let without_dir = strx::remove_to(path, '/'); + let without_suffix = strx::remove_suffix(without_dir, ".proto"); + + let name = without_suffix + .chars() + .enumerate() + .map(|(i, c)| { + let valid = if i == 0 { + ident_start(c) + } else { + ident_continue(c) + }; + if valid { + c + } else { + '_' + } + }) + .collect::<String>(); + + let name = if rust::is_rust_keyword(&name) { + format!("{}_pb", name) + } else { + name + }; + name +} + +pub struct RootScope<'a> { + pub file_descriptors: &'a [FileDescriptorProto], +} + +impl<'a> RootScope<'a> { + fn packages(&'a self) -> Vec<FileScope<'a>> { + self.file_descriptors + .iter() + .map(|fd| FileScope { + file_descriptor: fd, + }) + .collect() + } + + // find enum by fully qualified name + pub fn find_enum(&'a self, fqn: &str) -> EnumWithScope<'a> { + match self.find_message_or_enum(fqn) { + MessageOrEnumWithScope::Enum(e) => e, + _ => panic!("not an enum: {}", fqn), + } + } + + // find message by fully qualified name + pub fn find_message(&'a self, fqn: &str) -> MessageWithScope<'a> { + match self.find_message_or_enum(fqn) { + MessageOrEnumWithScope::Message(m) => m, + _ => panic!("not a message: {}", fqn), + } + } + + // find message or enum by fully qualified name + pub fn find_message_or_enum(&'a self, fqn: &str) -> MessageOrEnumWithScope<'a> { + assert!(fqn.starts_with("."), "name must start with dot: {}", fqn); + let fqn1 = &fqn[1..]; + self.packages() + .into_iter() + .flat_map(|p| { + (if p.get_package().is_empty() { + p.find_message_or_enum(fqn1) + } else if fqn1.starts_with(&(p.get_package().to_string() + ".")) { + let remaining = &fqn1[(p.get_package().len() + 1)..]; + p.find_message_or_enum(remaining) + } else { + None + }) + .into_iter() + }) + .next() + .expect(&format!("enum not found by name: {}", fqn)) + } +} + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum Syntax { + PROTO2, + PROTO3, +} + +impl Syntax { + pub fn parse(s: &str) -> Self { + match s { + "" | "proto2" => Syntax::PROTO2, + "proto3" => Syntax::PROTO3, + _ => panic!("unsupported syntax value: {:?}", s), + } + } +} + +#[derive(Clone)] +pub struct FileScope<'a> { + pub file_descriptor: &'a FileDescriptorProto, +} + +impl<'a> FileScope<'a> { + fn get_package(&self) -> &'a str { + self.file_descriptor.get_package() + } + + pub fn syntax(&self) -> Syntax { + Syntax::parse(self.file_descriptor.get_syntax()) + } + + pub fn to_scope(&self) -> Scope<'a> { + Scope { + file_scope: self.clone(), + path: Vec::new(), + } + } + + fn find_message_or_enum(&self, name: &str) -> Option<MessageOrEnumWithScope<'a>> { + assert!(!name.starts_with(".")); + self.find_messages_and_enums() + .into_iter() + .filter(|e| e.name_to_package() == name) + .next() + } + + // find all enums in given file descriptor + pub fn find_enums(&self) -> Vec<EnumWithScope<'a>> { + let mut r = Vec::new(); + + self.to_scope().walk_scopes(|scope| { + r.extend(scope.get_enums()); + }); + + r + } + + // find all messages in given file descriptor + pub fn find_messages(&self) -> Vec<MessageWithScope<'a>> { + let mut r = Vec::new(); + + self.to_scope().walk_scopes(|scope| { + r.extend(scope.get_messages()); + }); + + r + } + + // find all messages and enums in given file descriptor + pub fn find_messages_and_enums(&self) -> Vec<MessageOrEnumWithScope<'a>> { + let mut r = Vec::new(); + + self.to_scope().walk_scopes(|scope| { + r.extend(scope.get_messages_and_enums()); + }); + + r + } +} + +#[derive(Clone)] +pub struct Scope<'a> { + pub file_scope: FileScope<'a>, + pub path: Vec<&'a DescriptorProto>, +} + +impl<'a> Scope<'a> { + pub fn get_file_descriptor(&self) -> &'a FileDescriptorProto { + self.file_scope.file_descriptor + } + + // get message descriptors in this scope + fn get_message_descriptors(&self) -> &'a [DescriptorProto] { + if self.path.is_empty() { + self.file_scope.file_descriptor.get_message_type() + } else { + self.path.last().unwrap().get_nested_type() + } + } + + // get enum descriptors in this scope + fn get_enum_descriptors(&self) -> &'a [EnumDescriptorProto] { + if self.path.is_empty() { + self.file_scope.file_descriptor.get_enum_type() + } else { + self.path.last().unwrap().get_enum_type() + } + } + + // get messages with attached scopes in this scope + pub fn get_messages(&self) -> Vec<MessageWithScope<'a>> { + self.get_message_descriptors() + .iter() + .map(|m| MessageWithScope { + scope: self.clone(), + message: m, + }) + .collect() + } + + // get enums with attached scopes in this scope + pub fn get_enums(&self) -> Vec<EnumWithScope<'a>> { + self.get_enum_descriptors() + .iter() + .map(|e| EnumWithScope { + scope: self.clone(), + en: e, + }) + .collect() + } + + // get messages and enums with attached scopes in this scope + pub fn get_messages_and_enums(&self) -> Vec<MessageOrEnumWithScope<'a>> { + self.get_messages() + .into_iter() + .map(|m| MessageOrEnumWithScope::Message(m)) + .chain( + self.get_enums() + .into_iter() + .map(|m| MessageOrEnumWithScope::Enum(m)), + ) + .collect() + } + + // nested scopes, i. e. scopes of nested messages + fn nested_scopes(&self) -> Vec<Scope<'a>> { + self.get_message_descriptors() + .iter() + .map(|m| { + let mut nested = self.clone(); + nested.path.push(m); + nested + }) + .collect() + } + + fn walk_scopes_impl<F: FnMut(&Scope<'a>)>(&self, callback: &mut F) { + (*callback)(self); + + for nested in self.nested_scopes() { + nested.walk_scopes_impl(callback); + } + } + + // apply callback for this scope and all nested scopes + fn walk_scopes<F>(&self, mut callback: F) + where + F: FnMut(&Scope<'a>), + { + self.walk_scopes_impl(&mut callback); + } + + pub fn prefix(&self) -> String { + if self.path.is_empty() { + "".to_string() + } else { + let v: Vec<&'a str> = self.path.iter().map(|m| m.get_name()).collect(); + let mut r = v.join("."); + r.push_str("."); + r + } + } + + // rust type name prefix for this scope + pub fn rust_prefix(&self) -> String { + self.prefix().replace(".", "_") + } +} + +pub trait WithScope<'a> { + fn get_scope(&self) -> &Scope<'a>; + + fn get_file_descriptor(&self) -> &'a FileDescriptorProto { + self.get_scope().get_file_descriptor() + } + + // message or enum name + fn get_name(&self) -> &'a str; + + fn escape_prefix(&self) -> &'static str; + + fn name_to_package(&self) -> String { + let mut r = self.get_scope().prefix(); + r.push_str(self.get_name()); + r + } + + /// Return absolute name starting with dot + fn name_absolute(&self) -> String { + let mut r = String::new(); + r.push_str("."); + let package = self.get_file_descriptor().get_package(); + if !package.is_empty() { + r.push_str(package); + r.push_str("."); + } + r.push_str(&self.name_to_package()); + r + } + + // rust type name of this descriptor + fn rust_name(&self) -> String { + let mut r = self.get_scope().rust_prefix(); + // Only escape if prefix is not empty + if r.is_empty() && rust::is_rust_keyword(self.get_name()) { + r.push_str(self.escape_prefix()); + } + r.push_str(self.get_name()); + r + } + + // fully-qualified name of this type + fn rust_fq_name(&self) -> String { + format!( + "{}::{}", + proto_path_to_rust_mod(self.get_scope().get_file_descriptor().get_name()), + self.rust_name() + ) + } +} + +#[derive(Clone)] +pub struct MessageWithScope<'a> { + pub scope: Scope<'a>, + pub message: &'a DescriptorProto, +} + +impl<'a> WithScope<'a> for MessageWithScope<'a> { + fn get_scope(&self) -> &Scope<'a> { + &self.scope + } + + fn escape_prefix(&self) -> &'static str { + "message_" + } + + fn get_name(&self) -> &'a str { + self.message.get_name() + } +} + +impl<'a> MessageWithScope<'a> { + pub fn into_scope(mut self) -> Scope<'a> { + self.scope.path.push(self.message); + self.scope + } + + pub fn to_scope(&self) -> Scope<'a> { + self.clone().into_scope() + } + + pub fn fields(&self) -> Vec<FieldWithContext<'a>> { + self.message + .get_field() + .iter() + .map(|f| FieldWithContext { + field: f, + message: self.clone(), + }) + .collect() + } + + pub fn oneofs(&self) -> Vec<OneofWithContext<'a>> { + self.message + .get_oneof_decl() + .iter() + .enumerate() + .map(|(index, oneof)| OneofWithContext { + message: self.clone(), + oneof: &oneof, + index: index as u32, + }) + .collect() + } + + pub fn oneof_by_index(&self, index: u32) -> OneofWithContext<'a> { + self.oneofs().swap_remove(index as usize) + } + + /// Pair of (key, value) if this message is map entry + pub fn map_entry(&'a self) -> Option<(FieldWithContext<'a>, FieldWithContext<'a>)> { + if self.message.get_options().get_map_entry() { + let key = self + .fields() + .into_iter() + .find(|f| f.field.get_number() == 1) + .unwrap(); + let value = self + .fields() + .into_iter() + .find(|f| f.field.get_number() == 2) + .unwrap(); + Some((key, value)) + } else { + None + } + } +} + +#[derive(Clone)] +pub struct EnumWithScope<'a> { + pub scope: Scope<'a>, + pub en: &'a EnumDescriptorProto, +} + +impl<'a> EnumWithScope<'a> { + // enum values + pub fn values(&'a self) -> &'a [EnumValueDescriptorProto] { + self.en.get_value() + } + + // find enum value by name + pub fn value_by_name(&'a self, name: &str) -> &'a EnumValueDescriptorProto { + self.en + .get_value() + .into_iter() + .find(|v| v.get_name() == name) + .unwrap() + } +} + +pub trait EnumValueDescriptorEx { + fn rust_name(&self) -> String; +} + +impl EnumValueDescriptorEx for EnumValueDescriptorProto { + fn rust_name(&self) -> String { + let mut r = String::new(); + if rust::is_rust_keyword(self.get_name()) { + r.push_str("value_"); + } + r.push_str(self.get_name()); + r + } +} + +impl<'a> WithScope<'a> for EnumWithScope<'a> { + fn get_scope(&self) -> &Scope<'a> { + &self.scope + } + + fn escape_prefix(&self) -> &'static str { + "enum_" + } + + fn get_name(&self) -> &'a str { + self.en.get_name() + } +} + +pub enum MessageOrEnumWithScope<'a> { + Message(MessageWithScope<'a>), + Enum(EnumWithScope<'a>), +} + +impl<'a> WithScope<'a> for MessageOrEnumWithScope<'a> { + fn get_scope(&self) -> &Scope<'a> { + match self { + &MessageOrEnumWithScope::Message(ref m) => m.get_scope(), + &MessageOrEnumWithScope::Enum(ref e) => e.get_scope(), + } + } + + fn escape_prefix(&self) -> &'static str { + match self { + &MessageOrEnumWithScope::Message(ref m) => m.escape_prefix(), + &MessageOrEnumWithScope::Enum(ref e) => e.escape_prefix(), + } + } + + fn get_name(&self) -> &'a str { + match self { + &MessageOrEnumWithScope::Message(ref m) => m.get_name(), + &MessageOrEnumWithScope::Enum(ref e) => e.get_name(), + } + } +} + +pub trait FieldDescriptorProtoExt { + fn rust_name(&self) -> String; +} + +impl FieldDescriptorProtoExt for FieldDescriptorProto { + fn rust_name(&self) -> String { + if rust::is_rust_keyword(self.get_name()) { + format!("field_{}", self.get_name()) + } else { + self.get_name().to_string() + } + } +} + +#[derive(Clone)] +pub struct FieldWithContext<'a> { + pub field: &'a FieldDescriptorProto, + pub message: MessageWithScope<'a>, +} + +impl<'a> FieldWithContext<'a> { + #[doc(hidden)] + pub fn is_oneof(&self) -> bool { + self.field.has_oneof_index() + } + + pub fn oneof(&self) -> Option<OneofWithContext<'a>> { + if self.is_oneof() { + Some( + self.message + .oneof_by_index(self.field.get_oneof_index() as u32), + ) + } else { + None + } + } + + pub fn number(&self) -> u32 { + self.field.get_number() as u32 + } + + /// Shortcut + pub fn name(&self) -> &str { + self.field.get_name() + } + + // field name in generated code + #[deprecated] + pub fn rust_name(&self) -> String { + self.field.rust_name() + } + + // From field to file root + pub fn containing_messages(&self) -> Vec<&'a DescriptorProto> { + let mut r = Vec::new(); + r.push(self.message.message); + r.extend(self.message.scope.path.iter().rev()); + r + } +} + +#[derive(Clone)] +pub struct OneofVariantWithContext<'a> { + pub oneof: &'a OneofWithContext<'a>, + pub field: &'a FieldDescriptorProto, +} + +#[derive(Clone)] +pub struct OneofWithContext<'a> { + pub oneof: &'a OneofDescriptorProto, + pub index: u32, + pub message: MessageWithScope<'a>, +} + +impl<'a> OneofWithContext<'a> { + /// Oneof rust name + pub fn name(&'a self) -> &'a str { + match self.oneof.get_name() { + "type" => "field_type", + "box" => "field_box", + x => x, + } + } + + /// rust type name of enum + pub fn rust_name(&self) -> String { + format!( + "{}_oneof_{}", + self.message.rust_name(), + self.oneof.get_name() + ) + } + + /// Oneof variants + pub fn variants(&'a self) -> Vec<OneofVariantWithContext<'a>> { + self.message + .fields() + .iter() + .filter(|f| f.field.has_oneof_index() && f.field.get_oneof_index() == self.index as i32) + .map(|f| OneofVariantWithContext { + oneof: self, + field: &f.field, + }) + .collect() + } +} + +/// Find message by rust type name +pub fn find_message_by_rust_name<'a>( + fd: &'a FileDescriptorProto, + rust_name: &str, +) -> MessageWithScope<'a> { + FileScope { + file_descriptor: fd, + } + .find_messages() + .into_iter() + .find(|m| m.rust_name() == rust_name) + .unwrap() +} + +/// Find enum by rust type name +pub fn find_enum_by_rust_name<'a>( + fd: &'a FileDescriptorProto, + rust_name: &str, +) -> EnumWithScope<'a> { + FileScope { + file_descriptor: fd, + } + .find_enums() + .into_iter() + .find(|e| e.rust_name() == rust_name) + .unwrap() +} + +#[cfg(test)] +mod test { + + use super::proto_path_to_rust_mod; + + #[test] + fn test_mod_path_proto_ext() { + assert_eq!("proto", proto_path_to_rust_mod("proto.proto")); + } + + #[test] + fn test_mod_path_unknown_ext() { + assert_eq!("proto_proto3", proto_path_to_rust_mod("proto.proto3")); + } + + #[test] + fn test_mod_path_empty_ext() { + assert_eq!("proto", proto_path_to_rust_mod("proto")); + } +} diff --git a/src/enums.rs b/src/enums.rs new file mode 100644 index 0000000..1c2a62e --- /dev/null +++ b/src/enums.rs @@ -0,0 +1,32 @@ +use reflect::EnumDescriptor; +use reflect::EnumValueDescriptor; + +/// Trait implemented by all protobuf enum types. +pub trait ProtobufEnum: Eq + Sized + Copy + 'static { + /// Get enum `i32` value. + fn value(&self) -> i32; + + /// Try to create an enum from `i32` value. + /// Return `None` if value is unknown. + fn from_i32(v: i32) -> Option<Self>; + + /// Get all enum values for enum type. + fn values() -> &'static [Self] { + panic!(); + } + + /// Get enum value descriptor. + fn descriptor(&self) -> &'static EnumValueDescriptor { + self.enum_descriptor().value_by_number(self.value()) + } + + /// Get enum descriptor. + fn enum_descriptor(&self) -> &'static EnumDescriptor { + Self::enum_descriptor_static() + } + + /// Get enum descriptor by type. + fn enum_descriptor_static() -> &'static EnumDescriptor { + panic!(); + } +} diff --git a/src/error.rs b/src/error.rs new file mode 100644 index 0000000..8039baf --- /dev/null +++ b/src/error.rs @@ -0,0 +1,151 @@ +//! Protobuf error type + +use std::error::Error; +use std::fmt; +use std::io; +use std::str; + +use wire_format::WireType; + +/// `Result` alias for `ProtobufError` +pub type ProtobufResult<T> = Result<T, ProtobufError>; + +/// Enum values added here for diagnostic purposes. +/// Users should not depend on specific values. +#[derive(Debug)] +pub enum WireError { + /// Could not read complete message because stream is EOF + UnexpectedEof, + /// Wrong wire type for given field + UnexpectedWireType(WireType), + /// Incorrect tag value + IncorrectTag(u32), + /// Malformed map field + IncompleteMap, + /// Malformed varint + IncorrectVarint, + /// String is not valid UTD-8 + Utf8Error, + /// Enum value is unknown + InvalidEnumValue(i32), + /// Message is too nested + OverRecursionLimit, + /// Could not read complete message because stream is EOF + TruncatedMessage, + /// Other error + Other, +} + +impl fmt::Display for WireError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + WireError::Utf8Error => write!(f, "invalid UTF-8 sequence"), + WireError::UnexpectedWireType(..) => write!(f, "unexpected wire type"), + WireError::InvalidEnumValue(..) => write!(f, "invalid enum value"), + WireError::IncorrectTag(..) => write!(f, "incorrect tag"), + WireError::IncorrectVarint => write!(f, "incorrect varint"), + WireError::IncompleteMap => write!(f, "incomplete map"), + WireError::UnexpectedEof => write!(f, "unexpected EOF"), + WireError::OverRecursionLimit => write!(f, "over recursion limit"), + WireError::TruncatedMessage => write!(f, "truncated message"), + WireError::Other => write!(f, "other error"), + } + } +} + +/// Generic protobuf error +#[derive(Debug)] +pub enum ProtobufError { + /// I/O error when reading or writing + IoError(io::Error), + /// Malformed input + WireError(WireError), + /// Protocol contains a string which is not valid UTF-8 string + Utf8(str::Utf8Error), + /// Not all required fields set + MessageNotInitialized { + /// Message name + message: &'static str, + }, +} + +impl ProtobufError { + /// Create message not initialized error. + #[doc(hidden)] + pub fn message_not_initialized(message: &'static str) -> ProtobufError { + ProtobufError::MessageNotInitialized { message: message } + } +} + +impl fmt::Display for ProtobufError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + // not sure that cause should be included in message + &ProtobufError::IoError(ref e) => write!(f, "IO error: {}", e), + &ProtobufError::WireError(ref e) => fmt::Display::fmt(e, f), + &ProtobufError::Utf8(ref e) => write!(f, "{}", e), + &ProtobufError::MessageNotInitialized { .. } => write!(f, "not all message fields set"), + } + } +} + +impl Error for ProtobufError { + #[allow(deprecated)] // call to `description` + fn description(&self) -> &str { + match self { + // not sure that cause should be included in message + &ProtobufError::IoError(ref e) => e.description(), + &ProtobufError::WireError(ref e) => match *e { + WireError::Utf8Error => "invalid UTF-8 sequence", + WireError::UnexpectedWireType(..) => "unexpected wire type", + WireError::InvalidEnumValue(..) => "invalid enum value", + WireError::IncorrectTag(..) => "incorrect tag", + WireError::IncorrectVarint => "incorrect varint", + WireError::IncompleteMap => "incomplete map", + WireError::UnexpectedEof => "unexpected EOF", + WireError::OverRecursionLimit => "over recursion limit", + WireError::TruncatedMessage => "truncated message", + WireError::Other => "other error", + }, + &ProtobufError::Utf8(ref e) => &e.description(), + &ProtobufError::MessageNotInitialized { .. } => "not all message fields set", + } + } + + fn cause(&self) -> Option<&Error> { + match self { + &ProtobufError::IoError(ref e) => Some(e), + &ProtobufError::Utf8(ref e) => Some(e), + &ProtobufError::WireError(..) => None, + &ProtobufError::MessageNotInitialized { .. } => None, + } + } +} + +impl From<io::Error> for ProtobufError { + fn from(err: io::Error) -> Self { + ProtobufError::IoError(err) + } +} + +impl From<str::Utf8Error> for ProtobufError { + fn from(err: str::Utf8Error) -> Self { + ProtobufError::Utf8(err) + } +} + +impl From<ProtobufError> for io::Error { + fn from(err: ProtobufError) -> Self { + match err { + ProtobufError::IoError(e) => e, + ProtobufError::WireError(e) => { + io::Error::new(io::ErrorKind::InvalidData, ProtobufError::WireError(e)) + } + ProtobufError::MessageNotInitialized { message: msg } => io::Error::new( + io::ErrorKind::InvalidInput, + ProtobufError::MessageNotInitialized { message: msg }, + ), + e => io::Error::new(io::ErrorKind::Other, Box::new(e)), + } + } +} diff --git a/src/ext.rs b/src/ext.rs new file mode 100644 index 0000000..70b7439 --- /dev/null +++ b/src/ext.rs @@ -0,0 +1,47 @@ +//! Utilities to support "extension" fields. +//! +//! Extensions are [described in the official protobuf documentation][exts]. +//! +//! [exts]: https://developers.google.com/protocol-buffers/docs/proto#extensions + +use std::marker::PhantomData; + +use core::Message; +use types::ProtobufType; + +/// Optional ext field +pub struct ExtFieldOptional<M: Message, T: ProtobufType> { + /// Extension field number + pub field_number: u32, + /// Marker + // TODO: hide + pub phantom: PhantomData<(M, T)>, +} + +/// Repeated ext field +pub struct ExtFieldRepeated<M: Message, T: ProtobufType> { + /// Extension field number + pub field_number: u32, + /// Extension field number + // TODO: hide + pub phantom: PhantomData<(M, T)>, +} + +impl<M: Message, T: ProtobufType> ExtFieldOptional<M, T> { + /// Get a copy of value from a message. + /// + /// Extension data is stored in [`UnknownFields`](crate::UnknownFields). + pub fn get(&self, m: &M) -> Option<T::Value> { + m.get_unknown_fields() + .get(self.field_number) + .and_then(T::get_from_unknown) + } +} + +impl<M: Message, T: ProtobufType> ExtFieldRepeated<M, T> { + /// Get a copy of value from a message (**not implemented**). + pub fn get(&self, _m: &M) -> Vec<T::Value> { + // TODO + unimplemented!() + } +} diff --git a/src/lazy.rs b/src/lazy.rs new file mode 100644 index 0000000..b57d9f9 --- /dev/null +++ b/src/lazy.rs @@ -0,0 +1,105 @@ +//! Lazily initialized data. +//! Used in generated code. + +use std::mem; +use std::sync; + +/// Lasily initialized data. +pub struct Lazy<T> { + #[doc(hidden)] + pub lock: sync::Once, + #[doc(hidden)] + pub ptr: *const T, +} + +impl<T> Lazy<T> { + /// Uninitialized `Lazy` object. + /// + /// The initializer is added in rust-protobuf 2.11, for compatibility with + /// previously generated code, existing fields are kept public. + pub const INIT: Lazy<T> = Lazy { + lock: sync::Once::new(), + ptr: 0 as *const T, + }; + + /// Get lazy field value, initialize it with given function if not yet. + pub fn get<F>(&'static mut self, init: F) -> &'static T + where + F: FnOnce() -> T, + { + // ~ decouple the lifetimes of 'self' and 'self.lock' such we + // can initialize self.ptr in the call_once closure (note: we + // do have to initialize self.ptr in the closure to guarantee + // the ptr is valid for all calling threads at any point in + // time) + let lock: &sync::Once = unsafe { mem::transmute(&self.lock) }; + lock.call_once(|| unsafe { + self.ptr = mem::transmute(Box::new(init())); + }); + unsafe { &*self.ptr } + } +} + +/// Used to initialize `lock` field in `Lazy` struct. +#[deprecated( + since = "2.11", + note = "Regenerate .proto files to use safer initializer" +)] +pub const ONCE_INIT: sync::Once = sync::Once::new(); + +#[cfg(test)] +mod test { + use super::Lazy; + use std::sync::atomic::AtomicIsize; + use std::sync::atomic::Ordering; + use std::sync::Arc; + use std::sync::Barrier; + use std::thread; + + #[test] + fn many_threads_calling_get() { + const N_THREADS: usize = 32; + const N_ITERS_IN_THREAD: usize = 32; + const N_ITERS: usize = 16; + + static mut LAZY: Lazy<String> = Lazy::INIT; + static CALL_COUNT: AtomicIsize = AtomicIsize::new(0); + + let value = "Hello, world!".to_owned(); + + for _ in 0..N_ITERS { + // Reset mutable state. + unsafe { + LAZY = Lazy::INIT; + } + CALL_COUNT.store(0, Ordering::SeqCst); + + // Create a bunch of threads, all calling .get() at the same time. + let mut threads = vec![]; + let barrier = Arc::new(Barrier::new(N_THREADS)); + + for _ in 0..N_THREADS { + let cloned_value_thread = value.clone(); + let cloned_barrier = barrier.clone(); + threads.push(thread::spawn(move || { + // Ensure all threads start at once to maximise contention. + cloned_barrier.wait(); + for _ in 0..N_ITERS_IN_THREAD { + assert_eq!(&cloned_value_thread, unsafe { + LAZY.get(|| { + CALL_COUNT.fetch_add(1, Ordering::SeqCst); + cloned_value_thread.clone() + }) + }); + } + })); + } + + for thread in threads { + thread.join().unwrap(); + } + + assert_eq!(CALL_COUNT.load(Ordering::SeqCst), 1); + } + } +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..515bba8 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,126 @@ +//! Library to read and write protocol buffers data. + +#![deny(missing_docs)] +#![deny(intra_doc_link_resolution_failure)] +// Because we need compat with Rust 1.26 +#![allow(bare_trait_objects)] + +#[cfg(feature = "bytes")] +extern crate bytes; +#[cfg(feature = "with-serde")] +extern crate serde; +#[macro_use] +#[cfg(feature = "with-serde")] +extern crate serde_derive; +pub use cached_size::CachedSize; +#[cfg(feature = "bytes")] +pub use chars::Chars; +pub use clear::Clear; +pub use core::parse_from_bytes; +#[cfg(feature = "bytes")] +pub use core::parse_from_carllerche_bytes; +pub use core::parse_from_reader; +#[allow(deprecated)] +pub use core::parse_length_delimited_from; +#[allow(deprecated)] +pub use core::parse_length_delimited_from_bytes; +#[allow(deprecated)] +pub use core::parse_length_delimited_from_reader; +pub use core::Message; +pub use enums::ProtobufEnum; +pub use error::ProtobufError; +pub use error::ProtobufResult; +pub use repeated::RepeatedField; +pub use singular::SingularField; +pub use singular::SingularPtrField; +pub use stream::wire_format; +pub use stream::CodedInputStream; +pub use stream::CodedOutputStream; +pub use unknown::UnknownFields; +pub use unknown::UnknownFieldsIter; +pub use unknown::UnknownValue; +pub use unknown::UnknownValueRef; +pub use unknown::UnknownValues; +pub use unknown::UnknownValuesIter; + +// generated +pub mod descriptor; +pub mod plugin; +pub mod rustproto; + +mod any; + +mod clear; +pub mod compiler_plugin; +mod core; +mod enums; +pub mod error; +pub mod ext; +pub mod lazy; +pub mod reflect; +mod repeated; +pub mod rt; +mod singular; +pub mod stream; +pub mod text_format; +pub mod types; +pub mod well_known_types; + +// used by test +#[cfg(test)] +#[path = "../../protobuf-test-common/src/hex.rs"] +mod hex; + +// used by rust-grpc +pub mod descriptorx; + +mod cached_size; +#[cfg(feature = "bytes")] +mod chars; +#[doc(hidden)] // used by codegen +pub mod rust; +mod strx; +mod unknown; +mod varint; +mod zigzag; + +mod misc; + +mod buf_read_iter; + +// so `use protobuf::*` could work in mod descriptor and well_known_types +mod protobuf { + pub use cached_size::CachedSize; + pub use clear::Clear; + pub use core::*; + pub use descriptor; + pub use descriptorx; + pub use enums::ProtobufEnum; + pub use error::*; + pub use ext; + pub use lazy; + pub use reflect; + pub use repeated::RepeatedField; + pub use rt; + pub use singular::SingularField; + pub use singular::SingularPtrField; + pub use stream::*; + pub use text_format; + pub use types; + pub use unknown::UnknownFields; + pub use unknown::UnknownFieldsIter; + pub use unknown::UnknownValue; + pub use unknown::UnknownValueRef; + pub use unknown::UnknownValues; + pub use unknown::UnknownValuesIter; + pub use well_known_types; +} + +/// This symbol is in generated `version.rs`, include here for IDE +#[cfg(never)] +pub const VERSION: &str = ""; +/// This symbol is in generated `version.rs`, include here for IDE +#[cfg(never)] +#[doc(hidden)] +pub const VERSION_IDENT: &str = ""; +include!("../out/version.rs"); diff --git a/src/misc.rs b/src/misc.rs new file mode 100644 index 0000000..d923d58 --- /dev/null +++ b/src/misc.rs @@ -0,0 +1,37 @@ +use std::mem; +use std::slice; + +/// Slice from `vec[vec.len()..vec.capacity()]` +pub unsafe fn remaining_capacity_as_slice_mut<A>(vec: &mut Vec<A>) -> &mut [A] { + slice::from_raw_parts_mut( + vec.as_mut_slice().as_mut_ptr().offset(vec.len() as isize), + vec.capacity() - vec.len(), + ) +} + +pub unsafe fn remove_lifetime_mut<A: ?Sized>(a: &mut A) -> &'static mut A { + mem::transmute(a) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn test_remaining_capacity_as_slice_mut() { + let mut v = Vec::with_capacity(5); + v.push(10); + v.push(11); + v.push(12); + unsafe { + { + let s = remaining_capacity_as_slice_mut(&mut v); + assert_eq!(2, s.len()); + s[0] = 13; + s[1] = 14; + } + v.set_len(5); + } + assert_eq!(vec![10, 11, 12, 13, 14], v); + } +} diff --git a/src/plugin.rs b/src/plugin.rs new file mode 100644 index 0000000..ec24a8f --- /dev/null +++ b/src/plugin.rs @@ -0,0 +1,998 @@ +// This file is generated by rust-protobuf 2.14.0-pre. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/protobuf/compiler/plugin.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct CodeGeneratorRequest { + // message fields + file_to_generate: ::protobuf::RepeatedField<::std::string::String>, + parameter: ::protobuf::SingularField<::std::string::String>, + proto_file: ::protobuf::RepeatedField<::protobuf::descriptor::FileDescriptorProto>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CodeGeneratorRequest { + fn default() -> &'a CodeGeneratorRequest { + <CodeGeneratorRequest as ::protobuf::Message>::default_instance() + } +} + +impl CodeGeneratorRequest { + pub fn new() -> CodeGeneratorRequest { + ::std::default::Default::default() + } + + // repeated string file_to_generate = 1; + + + pub fn get_file_to_generate(&self) -> &[::std::string::String] { + &self.file_to_generate + } + pub fn clear_file_to_generate(&mut self) { + self.file_to_generate.clear(); + } + + // Param is passed by value, moved + pub fn set_file_to_generate(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.file_to_generate = v; + } + + // Mutable pointer to the field. + pub fn mut_file_to_generate(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.file_to_generate + } + + // Take field + pub fn take_file_to_generate(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.file_to_generate, ::protobuf::RepeatedField::new()) + } + + // optional string parameter = 2; + + + pub fn get_parameter(&self) -> &str { + match self.parameter.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_parameter(&mut self) { + self.parameter.clear(); + } + + pub fn has_parameter(&self) -> bool { + self.parameter.is_some() + } + + // Param is passed by value, moved + pub fn set_parameter(&mut self, v: ::std::string::String) { + self.parameter = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parameter(&mut self) -> &mut ::std::string::String { + if self.parameter.is_none() { + self.parameter.set_default(); + } + self.parameter.as_mut().unwrap() + } + + // Take field + pub fn take_parameter(&mut self) -> ::std::string::String { + self.parameter.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // repeated .google.protobuf.FileDescriptorProto proto_file = 15; + + + pub fn get_proto_file(&self) -> &[::protobuf::descriptor::FileDescriptorProto] { + &self.proto_file + } + pub fn clear_proto_file(&mut self) { + self.proto_file.clear(); + } + + // Param is passed by value, moved + pub fn set_proto_file(&mut self, v: ::protobuf::RepeatedField<::protobuf::descriptor::FileDescriptorProto>) { + self.proto_file = v; + } + + // Mutable pointer to the field. + pub fn mut_proto_file(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::descriptor::FileDescriptorProto> { + &mut self.proto_file + } + + // Take field + pub fn take_proto_file(&mut self) -> ::protobuf::RepeatedField<::protobuf::descriptor::FileDescriptorProto> { + ::std::mem::replace(&mut self.proto_file, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for CodeGeneratorRequest { + fn is_initialized(&self) -> bool { + for v in &self.proto_file { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.file_to_generate)?; + }, + 2 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.parameter)?; + }, + 15 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.proto_file)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.file_to_generate { + my_size += ::protobuf::rt::string_size(1, &value); + }; + if let Some(ref v) = self.parameter.as_ref() { + my_size += ::protobuf::rt::string_size(2, &v); + } + for value in &self.proto_file { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + for v in &self.file_to_generate { + os.write_string(1, &v)?; + }; + if let Some(ref v) = self.parameter.as_ref() { + os.write_string(2, &v)?; + } + for v in &self.proto_file { + os.write_tag(15, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CodeGeneratorRequest { + CodeGeneratorRequest::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "file_to_generate", + |m: &CodeGeneratorRequest| { &m.file_to_generate }, + |m: &mut CodeGeneratorRequest| { &mut m.file_to_generate }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "parameter", + |m: &CodeGeneratorRequest| { &m.parameter }, + |m: &mut CodeGeneratorRequest| { &mut m.parameter }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::descriptor::FileDescriptorProto>>( + "proto_file", + |m: &CodeGeneratorRequest| { &m.proto_file }, + |m: &mut CodeGeneratorRequest| { &mut m.proto_file }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorRequest>( + "CodeGeneratorRequest", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CodeGeneratorRequest { + static mut instance: ::protobuf::lazy::Lazy<CodeGeneratorRequest> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(CodeGeneratorRequest::new) + } + } +} + +impl ::protobuf::Clear for CodeGeneratorRequest { + fn clear(&mut self) { + self.file_to_generate.clear(); + self.parameter.clear(); + self.proto_file.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CodeGeneratorRequest { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CodeGeneratorRequest { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct CodeGeneratorResponse { + // message fields + error: ::protobuf::SingularField<::std::string::String>, + file: ::protobuf::RepeatedField<CodeGeneratorResponse_File>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CodeGeneratorResponse { + fn default() -> &'a CodeGeneratorResponse { + <CodeGeneratorResponse as ::protobuf::Message>::default_instance() + } +} + +impl CodeGeneratorResponse { + pub fn new() -> CodeGeneratorResponse { + ::std::default::Default::default() + } + + // optional string error = 1; + + + pub fn get_error(&self) -> &str { + match self.error.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_error(&mut self) { + self.error.clear(); + } + + pub fn has_error(&self) -> bool { + self.error.is_some() + } + + // Param is passed by value, moved + pub fn set_error(&mut self, v: ::std::string::String) { + self.error = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_error(&mut self) -> &mut ::std::string::String { + if self.error.is_none() { + self.error.set_default(); + } + self.error.as_mut().unwrap() + } + + // Take field + pub fn take_error(&mut self) -> ::std::string::String { + self.error.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15; + + + pub fn get_file(&self) -> &[CodeGeneratorResponse_File] { + &self.file + } + pub fn clear_file(&mut self) { + self.file.clear(); + } + + // Param is passed by value, moved + pub fn set_file(&mut self, v: ::protobuf::RepeatedField<CodeGeneratorResponse_File>) { + self.file = v; + } + + // Mutable pointer to the field. + pub fn mut_file(&mut self) -> &mut ::protobuf::RepeatedField<CodeGeneratorResponse_File> { + &mut self.file + } + + // Take field + pub fn take_file(&mut self) -> ::protobuf::RepeatedField<CodeGeneratorResponse_File> { + ::std::mem::replace(&mut self.file, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for CodeGeneratorResponse { + fn is_initialized(&self) -> bool { + for v in &self.file { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.error)?; + }, + 15 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.file)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.error.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + for value in &self.file { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.error.as_ref() { + os.write_string(1, &v)?; + } + for v in &self.file { + os.write_tag(15, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CodeGeneratorResponse { + CodeGeneratorResponse::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "error", + |m: &CodeGeneratorResponse| { &m.error }, + |m: &mut CodeGeneratorResponse| { &mut m.error }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CodeGeneratorResponse_File>>( + "file", + |m: &CodeGeneratorResponse| { &m.file }, + |m: &mut CodeGeneratorResponse| { &mut m.file }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorResponse>( + "CodeGeneratorResponse", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CodeGeneratorResponse { + static mut instance: ::protobuf::lazy::Lazy<CodeGeneratorResponse> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(CodeGeneratorResponse::new) + } + } +} + +impl ::protobuf::Clear for CodeGeneratorResponse { + fn clear(&mut self) { + self.error.clear(); + self.file.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CodeGeneratorResponse { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CodeGeneratorResponse { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct CodeGeneratorResponse_File { + // message fields + name: ::protobuf::SingularField<::std::string::String>, + insertion_point: ::protobuf::SingularField<::std::string::String>, + content: ::protobuf::SingularField<::std::string::String>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a CodeGeneratorResponse_File { + fn default() -> &'a CodeGeneratorResponse_File { + <CodeGeneratorResponse_File as ::protobuf::Message>::default_instance() + } +} + +impl CodeGeneratorResponse_File { + pub fn new() -> CodeGeneratorResponse_File { + ::std::default::Default::default() + } + + // optional string name = 1; + + + pub fn get_name(&self) -> &str { + match self.name.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + 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 = ::protobuf::SingularField::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.set_default(); + } + 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 insertion_point = 2; + + + pub fn get_insertion_point(&self) -> &str { + match self.insertion_point.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_insertion_point(&mut self) { + self.insertion_point.clear(); + } + + pub fn has_insertion_point(&self) -> bool { + self.insertion_point.is_some() + } + + // Param is passed by value, moved + pub fn set_insertion_point(&mut self, v: ::std::string::String) { + self.insertion_point = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_insertion_point(&mut self) -> &mut ::std::string::String { + if self.insertion_point.is_none() { + self.insertion_point.set_default(); + } + self.insertion_point.as_mut().unwrap() + } + + // Take field + pub fn take_insertion_point(&mut self) -> ::std::string::String { + self.insertion_point.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional string content = 15; + + + pub fn get_content(&self) -> &str { + match self.content.as_ref() { + Some(v) => &v, + None => "", + } + } + pub fn clear_content(&mut self) { + self.content.clear(); + } + + pub fn has_content(&self) -> bool { + self.content.is_some() + } + + // Param is passed by value, moved + pub fn set_content(&mut self, v: ::std::string::String) { + self.content = ::protobuf::SingularField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_content(&mut self) -> &mut ::std::string::String { + if self.content.is_none() { + self.content.set_default(); + } + self.content.as_mut().unwrap() + } + + // Take field + pub fn take_content(&mut self) -> ::std::string::String { + self.content.take().unwrap_or_else(|| ::std::string::String::new()) + } +} + +impl ::protobuf::Message for CodeGeneratorResponse_File { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.insertion_point)?; + }, + 15 => { + ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.content)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let Some(ref v) = self.name.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(ref v) = self.insertion_point.as_ref() { + my_size += ::protobuf::rt::string_size(2, &v); + } + if let Some(ref v) = self.content.as_ref() { + my_size += ::protobuf::rt::string_size(15, &v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let Some(ref v) = self.name.as_ref() { + os.write_string(1, &v)?; + } + if let Some(ref v) = self.insertion_point.as_ref() { + os.write_string(2, &v)?; + } + if let Some(ref v) = self.content.as_ref() { + os.write_string(15, &v)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> CodeGeneratorResponse_File { + CodeGeneratorResponse_File::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &CodeGeneratorResponse_File| { &m.name }, + |m: &mut CodeGeneratorResponse_File| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "insertion_point", + |m: &CodeGeneratorResponse_File| { &m.insertion_point }, + |m: &mut CodeGeneratorResponse_File| { &mut m.insertion_point }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "content", + |m: &CodeGeneratorResponse_File| { &m.content }, + |m: &mut CodeGeneratorResponse_File| { &mut m.content }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorResponse_File>( + "CodeGeneratorResponse.File", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static CodeGeneratorResponse_File { + static mut instance: ::protobuf::lazy::Lazy<CodeGeneratorResponse_File> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(CodeGeneratorResponse_File::new) + } + } +} + +impl ::protobuf::Clear for CodeGeneratorResponse_File { + fn clear(&mut self) { + self.name.clear(); + self.insertion_point.clear(); + self.content.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for CodeGeneratorResponse_File { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for CodeGeneratorResponse_File { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n%google/protobuf/compiler/plugin.proto\x12\x18google.protobuf.compiler\ + \x1a\x20google/protobuf/descriptor.proto\"\xa3\x01\n\x14CodeGeneratorReq\ + uest\x12(\n\x10file_to_generate\x18\x01\x20\x03(\tR\x0efileToGenerate\ + \x12\x1c\n\tparameter\x18\x02\x20\x01(\tR\tparameter\x12C\n\nproto_file\ + \x18\x0f\x20\x03(\x0b2$.google.protobuf.FileDescriptorProtoR\tprotoFile\ + \"\xd6\x01\n\x15CodeGeneratorResponse\x12\x14\n\x05error\x18\x01\x20\x01\ + (\tR\x05error\x12H\n\x04file\x18\x0f\x20\x03(\x0b24.google.protobuf.comp\ + iler.CodeGeneratorResponse.FileR\x04file\x1a]\n\x04File\x12\x12\n\x04nam\ + e\x18\x01\x20\x01(\tR\x04name\x12'\n\x0finsertion_point\x18\x02\x20\x01(\ + \tR\x0einsertionPoint\x12\x18\n\x07content\x18\x0f\x20\x01(\tR\x07conten\ + tB7\n\x1ccom.google.protobuf.compilerB\x0cPluginProtosZ\tplugin_goJ\xd29\ + \n\x07\x12\x05.\0\x95\x01\x01\n\xca\x11\n\x01\x0c\x12\x03.\0\x122\xc1\ + \x0c\x20Protocol\x20Buffers\x20-\x20Google's\x20data\x20interchange\x20f\ + ormat\n\x20Copyright\x202008\x20Google\x20Inc.\x20\x20All\x20rights\x20r\ + eserved.\n\x20https://developers.google.com/protocol-buffers/\n\n\x20Red\ + istribution\x20and\x20use\x20in\x20source\x20and\x20binary\x20forms,\x20\ + with\x20or\x20without\n\x20modification,\x20are\x20permitted\x20provided\ + \x20that\x20the\x20following\x20conditions\x20are\n\x20met:\n\n\x20\x20\ + \x20\x20\x20*\x20Redistributions\x20of\x20source\x20code\x20must\x20reta\ + in\x20the\x20above\x20copyright\n\x20notice,\x20this\x20list\x20of\x20co\ + nditions\x20and\x20the\x20following\x20disclaimer.\n\x20\x20\x20\x20\x20\ + *\x20Redistributions\x20in\x20binary\x20form\x20must\x20reproduce\x20the\ + \x20above\n\x20copyright\x20notice,\x20this\x20list\x20of\x20conditions\ + \x20and\x20the\x20following\x20disclaimer\n\x20in\x20the\x20documentatio\ + n\x20and/or\x20other\x20materials\x20provided\x20with\x20the\n\x20distri\ + bution.\n\x20\x20\x20\x20\x20*\x20Neither\x20the\x20name\x20of\x20Google\ + \x20Inc.\x20nor\x20the\x20names\x20of\x20its\n\x20contributors\x20may\ + \x20be\x20used\x20to\x20endorse\x20or\x20promote\x20products\x20derived\ + \x20from\n\x20this\x20software\x20without\x20specific\x20prior\x20writte\ + n\x20permission.\n\n\x20THIS\x20SOFTWARE\x20IS\x20PROVIDED\x20BY\x20THE\ + \x20COPYRIGHT\x20HOLDERS\x20AND\x20CONTRIBUTORS\n\x20\"AS\x20IS\"\x20AND\ + \x20ANY\x20EXPRESS\x20OR\x20IMPLIED\x20WARRANTIES,\x20INCLUDING,\x20BUT\ + \x20NOT\n\x20LIMITED\x20TO,\x20THE\x20IMPLIED\x20WARRANTIES\x20OF\x20MER\ + CHANTABILITY\x20AND\x20FITNESS\x20FOR\n\x20A\x20PARTICULAR\x20PURPOSE\ + \x20ARE\x20DISCLAIMED.\x20IN\x20NO\x20EVENT\x20SHALL\x20THE\x20COPYRIGHT\ + \n\x20OWNER\x20OR\x20CONTRIBUTORS\x20BE\x20LIABLE\x20FOR\x20ANY\x20DIREC\ + T,\x20INDIRECT,\x20INCIDENTAL,\n\x20SPECIAL,\x20EXEMPLARY,\x20OR\x20CONS\ + EQUENTIAL\x20DAMAGES\x20(INCLUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\ + \x20PROCUREMENT\x20OF\x20SUBSTITUTE\x20GOODS\x20OR\x20SERVICES;\x20LOSS\ + \x20OF\x20USE,\n\x20DATA,\x20OR\x20PROFITS;\x20OR\x20BUSINESS\x20INTERRU\ + PTION)\x20HOWEVER\x20CAUSED\x20AND\x20ON\x20ANY\n\x20THEORY\x20OF\x20LIA\ + BILITY,\x20WHETHER\x20IN\x20CONTRACT,\x20STRICT\x20LIABILITY,\x20OR\x20T\ + ORT\n\x20(INCLUDING\x20NEGLIGENCE\x20OR\x20OTHERWISE)\x20ARISING\x20IN\ + \x20ANY\x20WAY\x20OUT\x20OF\x20THE\x20USE\n\x20OF\x20THIS\x20SOFTWARE,\ + \x20EVEN\x20IF\x20ADVISED\x20OF\x20THE\x20POSSIBILITY\x20OF\x20SUCH\x20D\ + AMAGE.\n2\xfb\x04\x20Author:\x20kenton@google.com\x20(Kenton\x20Varda)\n\ + \n\x20WARNING:\x20\x20The\x20plugin\x20interface\x20is\x20currently\x20E\ + XPERIMENTAL\x20and\x20is\x20subject\x20to\n\x20\x20\x20change.\n\n\x20pr\ + otoc\x20(aka\x20the\x20Protocol\x20Compiler)\x20can\x20be\x20extended\ + \x20via\x20plugins.\x20\x20A\x20plugin\x20is\n\x20just\x20a\x20program\ + \x20that\x20reads\x20a\x20CodeGeneratorRequest\x20from\x20stdin\x20and\ + \x20writes\x20a\n\x20CodeGeneratorResponse\x20to\x20stdout.\n\n\x20Plugi\ + ns\x20written\x20using\x20C++\x20can\x20use\x20google/protobuf/compiler/\ + plugin.h\x20instead\n\x20of\x20dealing\x20with\x20the\x20raw\x20protocol\ + \x20defined\x20here.\n\n\x20A\x20plugin\x20executable\x20needs\x20only\ + \x20to\x20be\x20placed\x20somewhere\x20in\x20the\x20path.\x20\x20The\n\ + \x20plugin\x20should\x20be\x20named\x20\"protoc-gen-$NAME\",\x20and\x20w\ + ill\x20then\x20be\x20used\x20when\x20the\n\x20flag\x20\"--${NAME}_out\"\ + \x20is\x20passed\x20to\x20protoc.\n\n\x08\n\x01\x02\x12\x03/\0!\n\x08\n\ + \x01\x08\x12\x030\05\n\t\n\x02\x08\x01\x12\x030\05\n\x08\n\x01\x08\x12\ + \x031\0-\n\t\n\x02\x08\x08\x12\x031\0-\n\x08\n\x01\x08\x12\x033\0\x20\n\ + \t\n\x02\x08\x0b\x12\x033\0\x20\n\t\n\x02\x03\0\x12\x035\0*\nO\n\x02\x04\ + \0\x12\x048\0M\x01\x1aC\x20An\x20encoded\x20CodeGeneratorRequest\x20is\ + \x20written\x20to\x20the\x20plugin's\x20stdin.\n\n\n\n\x03\x04\0\x01\x12\ + \x038\x08\x1c\n\xd1\x01\n\x04\x04\0\x02\0\x12\x03<\x02'\x1a\xc3\x01\x20T\ + he\x20.proto\x20files\x20that\x20were\x20explicitly\x20listed\x20on\x20t\ + he\x20command-line.\x20\x20The\n\x20code\x20generator\x20should\x20gener\ + ate\x20code\x20only\x20for\x20these\x20files.\x20\x20Each\x20file's\n\ + \x20descriptor\x20will\x20be\x20included\x20in\x20proto_file,\x20below.\ + \n\n\x0c\n\x05\x04\0\x02\0\x04\x12\x03<\x02\n\n\x0c\n\x05\x04\0\x02\0\ + \x05\x12\x03<\x0b\x11\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03<\x12\"\n\x0c\n\ + \x05\x04\0\x02\0\x03\x12\x03<%&\nB\n\x04\x04\0\x02\x01\x12\x03?\x02\x20\ + \x1a5\x20The\x20generator\x20parameter\x20passed\x20on\x20the\x20command\ + -line.\n\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x03?\x02\n\n\x0c\n\x05\x04\0\ + \x02\x01\x05\x12\x03?\x0b\x11\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03?\x12\ + \x1b\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03?\x1e\x1f\n\xa9\x05\n\x04\x04\ + \0\x02\x02\x12\x03L\x02/\x1a\x9b\x05\x20FileDescriptorProtos\x20for\x20a\ + ll\x20files\x20in\x20files_to_generate\x20and\x20everything\n\x20they\ + \x20import.\x20\x20The\x20files\x20will\x20appear\x20in\x20topological\ + \x20order,\x20so\x20each\x20file\n\x20appears\x20before\x20any\x20file\ + \x20that\x20imports\x20it.\n\n\x20protoc\x20guarantees\x20that\x20all\ + \x20proto_files\x20will\x20be\x20written\x20after\n\x20the\x20fields\x20\ + above,\x20even\x20though\x20this\x20is\x20not\x20technically\x20guarante\ + ed\x20by\x20the\n\x20protobuf\x20wire\x20format.\x20\x20This\x20theoreti\ + cally\x20could\x20allow\x20a\x20plugin\x20to\x20stream\n\x20in\x20the\ + \x20FileDescriptorProtos\x20and\x20handle\x20them\x20one\x20by\x20one\ + \x20rather\x20than\x20read\n\x20the\x20entire\x20set\x20into\x20memory\ + \x20at\x20once.\x20\x20However,\x20as\x20of\x20this\x20writing,\x20this\ + \n\x20is\x20not\x20similarly\x20optimized\x20on\x20protoc's\x20end\x20--\ + \x20it\x20will\x20store\x20all\x20fields\x20in\n\x20memory\x20at\x20once\ + \x20before\x20sending\x20them\x20to\x20the\x20plugin.\n\n\x0c\n\x05\x04\ + \0\x02\x02\x04\x12\x03L\x02\n\n\x0c\n\x05\x04\0\x02\x02\x06\x12\x03L\x0b\ + \x1e\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03L\x1f)\n\x0c\n\x05\x04\0\x02\ + \x02\x03\x12\x03L,.\nL\n\x02\x04\x01\x12\x05P\0\x95\x01\x01\x1a?\x20The\ + \x20plugin\x20writes\x20an\x20encoded\x20CodeGeneratorResponse\x20to\x20\ + stdout.\n\n\n\n\x03\x04\x01\x01\x12\x03P\x08\x1d\n\xed\x03\n\x04\x04\x01\ + \x02\0\x12\x03Y\x02\x1c\x1a\xdf\x03\x20Error\x20message.\x20\x20If\x20no\ + n-empty,\x20code\x20generation\x20failed.\x20\x20The\x20plugin\x20proces\ + s\n\x20should\x20exit\x20with\x20status\x20code\x20zero\x20even\x20if\ + \x20it\x20reports\x20an\x20error\x20in\x20this\x20way.\n\n\x20This\x20sh\ + ould\x20be\x20used\x20to\x20indicate\x20errors\x20in\x20.proto\x20files\ + \x20which\x20prevent\x20the\n\x20code\x20generator\x20from\x20generating\ + \x20correct\x20code.\x20\x20Errors\x20which\x20indicate\x20a\n\x20proble\ + m\x20in\x20protoc\x20itself\x20--\x20such\x20as\x20the\x20input\x20CodeG\ + eneratorRequest\x20being\n\x20unparseable\x20--\x20should\x20be\x20repor\ + ted\x20by\x20writing\x20a\x20message\x20to\x20stderr\x20and\n\x20exiting\ + \x20with\x20a\x20non-zero\x20status\x20code.\n\n\x0c\n\x05\x04\x01\x02\0\ + \x04\x12\x03Y\x02\n\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03Y\x0b\x11\n\x0c\ + \n\x05\x04\x01\x02\0\x01\x12\x03Y\x12\x17\n\x0c\n\x05\x04\x01\x02\0\x03\ + \x12\x03Y\x1a\x1b\n4\n\x04\x04\x01\x03\0\x12\x05\\\x02\x93\x01\x03\x1a%\ + \x20Represents\x20a\x20single\x20generated\x20file.\n\n\x0c\n\x05\x04\ + \x01\x03\0\x01\x12\x03\\\n\x0e\n\xad\x05\n\x06\x04\x01\x03\0\x02\0\x12\ + \x03h\x04\x1d\x1a\x9d\x05\x20The\x20file\x20name,\x20relative\x20to\x20t\ + he\x20output\x20directory.\x20\x20The\x20name\x20must\x20not\n\x20contai\ + n\x20\".\"\x20or\x20\"..\"\x20components\x20and\x20must\x20be\x20relativ\ + e,\x20not\x20be\x20absolute\x20(so,\n\x20the\x20file\x20cannot\x20lie\ + \x20outside\x20the\x20output\x20directory).\x20\x20\"/\"\x20must\x20be\ + \x20used\x20as\n\x20the\x20path\x20separator,\x20not\x20\"\\\".\n\n\x20I\ + f\x20the\x20name\x20is\x20omitted,\x20the\x20content\x20will\x20be\x20ap\ + pended\x20to\x20the\x20previous\n\x20file.\x20\x20This\x20allows\x20the\ + \x20generator\x20to\x20break\x20large\x20files\x20into\x20small\x20chunk\ + s,\n\x20and\x20allows\x20the\x20generated\x20text\x20to\x20be\x20streame\ + d\x20back\x20to\x20protoc\x20so\x20that\x20large\n\x20files\x20need\x20n\ + ot\x20reside\x20completely\x20in\x20memory\x20at\x20one\x20time.\x20\x20\ + Note\x20that\x20as\x20of\n\x20this\x20writing\x20protoc\x20does\x20not\ + \x20optimize\x20for\x20this\x20--\x20it\x20will\x20read\x20the\x20entire\ + \n\x20CodeGeneratorResponse\x20before\x20writing\x20files\x20to\x20disk.\ + \n\n\x0e\n\x07\x04\x01\x03\0\x02\0\x04\x12\x03h\x04\x0c\n\x0e\n\x07\x04\ + \x01\x03\0\x02\0\x05\x12\x03h\r\x13\n\x0e\n\x07\x04\x01\x03\0\x02\0\x01\ + \x12\x03h\x14\x18\n\x0e\n\x07\x04\x01\x03\0\x02\0\x03\x12\x03h\x1b\x1c\n\ + \xae\x10\n\x06\x04\x01\x03\0\x02\x01\x12\x04\x8f\x01\x04(\x1a\x9d\x10\ + \x20If\x20non-empty,\x20indicates\x20that\x20the\x20named\x20file\x20sho\ + uld\x20already\x20exist,\x20and\x20the\n\x20content\x20here\x20is\x20to\ + \x20be\x20inserted\x20into\x20that\x20file\x20at\x20a\x20defined\x20inse\ + rtion\n\x20point.\x20\x20This\x20feature\x20allows\x20a\x20code\x20gener\ + ator\x20to\x20extend\x20the\x20output\n\x20produced\x20by\x20another\x20\ + code\x20generator.\x20\x20The\x20original\x20generator\x20may\x20provide\ + \n\x20insertion\x20points\x20by\x20placing\x20special\x20annotations\x20\ + in\x20the\x20file\x20that\x20look\n\x20like:\n\x20\x20\x20@@protoc_inser\ + tion_point(NAME)\n\x20The\x20annotation\x20can\x20have\x20arbitrary\x20t\ + ext\x20before\x20and\x20after\x20it\x20on\x20the\x20line,\n\x20which\x20\ + allows\x20it\x20to\x20be\x20placed\x20in\x20a\x20comment.\x20\x20NAME\ + \x20should\x20be\x20replaced\x20with\n\x20an\x20identifier\x20naming\x20\ + the\x20point\x20--\x20this\x20is\x20what\x20other\x20generators\x20will\ + \x20use\n\x20as\x20the\x20insertion_point.\x20\x20Code\x20inserted\x20at\ + \x20this\x20point\x20will\x20be\x20placed\n\x20immediately\x20above\x20t\ + he\x20line\x20containing\x20the\x20insertion\x20point\x20(thus\x20multip\ + le\n\x20insertions\x20to\x20the\x20same\x20point\x20will\x20come\x20out\ + \x20in\x20the\x20order\x20they\x20were\x20added).\n\x20The\x20double-@\ + \x20is\x20intended\x20to\x20make\x20it\x20unlikely\x20that\x20the\x20gen\ + erated\x20code\n\x20could\x20contain\x20things\x20that\x20look\x20like\ + \x20insertion\x20points\x20by\x20accident.\n\n\x20For\x20example,\x20the\ + \x20C++\x20code\x20generator\x20places\x20the\x20following\x20line\x20in\ + \x20the\n\x20.pb.h\x20files\x20that\x20it\x20generates:\n\x20\x20\x20//\ + \x20@@protoc_insertion_point(namespace_scope)\n\x20This\x20line\x20appea\ + rs\x20within\x20the\x20scope\x20of\x20the\x20file's\x20package\x20namesp\ + ace,\x20but\n\x20outside\x20of\x20any\x20particular\x20class.\x20\x20Ano\ + ther\x20plugin\x20can\x20then\x20specify\x20the\n\x20insertion_point\x20\ + \"namespace_scope\"\x20to\x20generate\x20additional\x20classes\x20or\n\ + \x20other\x20declarations\x20that\x20should\x20be\x20placed\x20in\x20thi\ + s\x20scope.\n\n\x20Note\x20that\x20if\x20the\x20line\x20containing\x20th\ + e\x20insertion\x20point\x20begins\x20with\n\x20whitespace,\x20the\x20sam\ + e\x20whitespace\x20will\x20be\x20added\x20to\x20every\x20line\x20of\x20t\ + he\n\x20inserted\x20text.\x20\x20This\x20is\x20useful\x20for\x20language\ + s\x20like\x20Python,\x20where\n\x20indentation\x20matters.\x20\x20In\x20\ + these\x20languages,\x20the\x20insertion\x20point\x20comment\n\x20should\ + \x20be\x20indented\x20the\x20same\x20amount\x20as\x20any\x20inserted\x20\ + code\x20will\x20need\x20to\x20be\n\x20in\x20order\x20to\x20work\x20corre\ + ctly\x20in\x20that\x20context.\n\n\x20The\x20code\x20generator\x20that\ + \x20generates\x20the\x20initial\x20file\x20and\x20the\x20one\x20which\n\ + \x20inserts\x20into\x20it\x20must\x20both\x20run\x20as\x20part\x20of\x20\ + a\x20single\x20invocation\x20of\x20protoc.\n\x20Code\x20generators\x20ar\ + e\x20executed\x20in\x20the\x20order\x20in\x20which\x20they\x20appear\x20\ + on\x20the\n\x20command\x20line.\n\n\x20If\x20|insertion_point|\x20is\x20\ + present,\x20|name|\x20must\x20also\x20be\x20present.\n\n\x0f\n\x07\x04\ + \x01\x03\0\x02\x01\x04\x12\x04\x8f\x01\x04\x0c\n\x0f\n\x07\x04\x01\x03\0\ + \x02\x01\x05\x12\x04\x8f\x01\r\x13\n\x0f\n\x07\x04\x01\x03\0\x02\x01\x01\ + \x12\x04\x8f\x01\x14#\n\x0f\n\x07\x04\x01\x03\0\x02\x01\x03\x12\x04\x8f\ + \x01&'\n$\n\x06\x04\x01\x03\0\x02\x02\x12\x04\x92\x01\x04!\x1a\x14\x20Th\ + e\x20file\x20contents.\n\n\x0f\n\x07\x04\x01\x03\0\x02\x02\x04\x12\x04\ + \x92\x01\x04\x0c\n\x0f\n\x07\x04\x01\x03\0\x02\x02\x05\x12\x04\x92\x01\r\ + \x13\n\x0f\n\x07\x04\x01\x03\0\x02\x02\x01\x12\x04\x92\x01\x14\x1b\n\x0f\ + \n\x07\x04\x01\x03\0\x02\x02\x03\x12\x04\x92\x01\x1e\x20\n\x0c\n\x04\x04\ + \x01\x02\x01\x12\x04\x94\x01\x02\x1a\n\r\n\x05\x04\x01\x02\x01\x04\x12\ + \x04\x94\x01\x02\n\n\r\n\x05\x04\x01\x02\x01\x06\x12\x04\x94\x01\x0b\x0f\ + \n\r\n\x05\x04\x01\x02\x01\x01\x12\x04\x94\x01\x10\x14\n\r\n\x05\x04\x01\ + \x02\x01\x03\x12\x04\x94\x01\x17\x19\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/src/reflect/accessor.rs b/src/reflect/accessor.rs new file mode 100644 index 0000000..8a586b2 --- /dev/null +++ b/src/reflect/accessor.rs @@ -0,0 +1,789 @@ +#![doc(hidden)] + +use std::collections::HashMap; +use std::fmt; +use std::hash::Hash; + +use core::message_down_cast; +use core::Message; +use enums::ProtobufEnum; +use reflect::EnumValueDescriptor; +use types::*; + +use repeated::RepeatedField; +use singular::SingularField; +use singular::SingularPtrField; + +use super::map::ReflectMap; +use super::optional::ReflectOptional; +use super::repeated::ReflectRepeated; +use super::repeated::ReflectRepeatedEnum; +use super::repeated::ReflectRepeatedMessage; +use super::value::ProtobufValue; +use super::value::ReflectValueRef; +use super::ReflectFieldRef; + +/// this trait should not be used directly, use `FieldDescriptor` instead +pub trait FieldAccessor { + fn name_generic(&self) -> &'static str; + fn has_field_generic(&self, m: &Message) -> bool; + fn len_field_generic(&self, m: &Message) -> usize; + // TODO: should it return default value or panic on unset field? + fn get_message_generic<'a>(&self, m: &'a Message) -> &'a Message; + fn get_enum_generic(&self, m: &Message) -> &'static EnumValueDescriptor; + fn get_str_generic<'a>(&self, m: &'a Message) -> &'a str; + fn get_bytes_generic<'a>(&self, m: &'a Message) -> &'a [u8]; + fn get_u32_generic(&self, m: &Message) -> u32; + fn get_u64_generic(&self, m: &Message) -> u64; + fn get_i32_generic(&self, m: &Message) -> i32; + fn get_i64_generic(&self, m: &Message) -> i64; + fn get_bool_generic(&self, m: &Message) -> bool; + fn get_f32_generic(&self, m: &Message) -> f32; + fn get_f64_generic(&self, m: &Message) -> f64; + + fn get_reflect<'a>(&self, m: &'a Message) -> ReflectFieldRef<'a>; +} + +trait GetSingularMessage<M> { + fn get_message<'a>(&self, m: &'a M) -> &'a Message; +} + +struct GetSingularMessageImpl<M, N> { + get: for<'a> fn(&'a M) -> &'a N, +} + +impl<M: Message, N: Message + 'static> GetSingularMessage<M> for GetSingularMessageImpl<M, N> { + fn get_message<'a>(&self, m: &'a M) -> &'a Message { + (self.get)(m) + } +} + +trait GetSingularEnum<M> { + fn get_enum(&self, m: &M) -> &'static EnumValueDescriptor; +} + +struct GetSingularEnumImpl<M, E> { + get: fn(&M) -> E, +} + +impl<M: Message, E: ProtobufEnum> GetSingularEnum<M> for GetSingularEnumImpl<M, E> { + fn get_enum(&self, m: &M) -> &'static EnumValueDescriptor { + (self.get)(m).descriptor() + } +} + +trait GetRepeatedMessage<M> { + fn len_field(&self, m: &M) -> usize; + fn get_message_item<'a>(&self, m: &'a M, index: usize) -> &'a Message; + fn reflect_repeated_message<'a>(&self, m: &'a M) -> Box<ReflectRepeatedMessage<'a> + 'a>; +} + +trait GetRepeatedEnum<M: Message + 'static> { + fn len_field(&self, m: &M) -> usize; + fn get_enum_item(&self, m: &M, index: usize) -> &'static EnumValueDescriptor; + fn reflect_repeated_enum<'a>(&self, m: &'a M) -> Box<ReflectRepeatedEnum<'a> + 'a>; +} + +trait GetSetCopyFns<M> { + fn get_field<'a>(&self, m: &'a M) -> ReflectValueRef<'a>; +} + +struct GetSetCopyFnsImpl<M, V: ProtobufValue + Copy> { + get: fn(&M) -> V, + _set: fn(&mut M, V), +} + +impl<M, V: ProtobufValue + Copy> GetSetCopyFns<M> for GetSetCopyFnsImpl<M, V> { + fn get_field<'a>(&self, m: &'a M) -> ReflectValueRef<'a> { + (&(self.get)(m) as &ProtobufValue).as_ref_copy() + } +} + +enum SingularGetSet<M> { + Copy(Box<GetSetCopyFns<M>>), + String(for<'a> fn(&'a M) -> &'a str, fn(&mut M, String)), + Bytes(for<'a> fn(&'a M) -> &'a [u8], fn(&mut M, Vec<u8>)), + Enum(Box<GetSingularEnum<M> + 'static>), + Message(Box<GetSingularMessage<M> + 'static>), +} + +impl<M: Message + 'static> SingularGetSet<M> { + fn get_ref<'a>(&self, m: &'a M) -> ReflectValueRef<'a> { + match self { + &SingularGetSet::Copy(ref copy) => copy.get_field(m), + &SingularGetSet::String(get, _) => ReflectValueRef::String(get(m)), + &SingularGetSet::Bytes(get, _) => ReflectValueRef::Bytes(get(m)), + &SingularGetSet::Enum(ref get) => ReflectValueRef::Enum(get.get_enum(m)), + &SingularGetSet::Message(ref get) => ReflectValueRef::Message(get.get_message(m)), + } + } +} + +trait FieldAccessor2<M, R: ?Sized> +where + M: Message + 'static, +{ + fn get_field<'a>(&self, &'a M) -> &'a R; + fn mut_field<'a>(&self, &'a mut M) -> &'a mut R; +} + +struct MessageGetMut<M, L> +where + M: Message + 'static, +{ + get_field: for<'a> fn(&'a M) -> &'a L, + mut_field: for<'a> fn(&'a mut M) -> &'a mut L, +} + +enum FieldAccessorFunctions<M> { + // up to 1.0.24 optional or required + SingularHasGetSet { + has: fn(&M) -> bool, + get_set: SingularGetSet<M>, + }, + // protobuf 3 simple field + Simple(Box<FieldAccessor2<M, ProtobufValue>>), + // optional, required or message + Optional(Box<FieldAccessor2<M, ReflectOptional>>), + // repeated + Repeated(Box<FieldAccessor2<M, ReflectRepeated>>), + // protobuf 3 map + Map(Box<FieldAccessor2<M, ReflectMap>>), +} + +impl<M> fmt::Debug for FieldAccessorFunctions<M> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + &FieldAccessorFunctions::SingularHasGetSet { .. } => { + write!(f, "SingularHasGetSet {{ .. }}") + } + &FieldAccessorFunctions::Simple(..) => write!(f, "Simple(..)"), + &FieldAccessorFunctions::Optional(..) => write!(f, "Optional(..)"), + &FieldAccessorFunctions::Repeated(..) => write!(f, "Repeated(..)"), + &FieldAccessorFunctions::Map(..) => write!(f, "Map(..)"), + } + } +} + +struct FieldAccessorImpl<M> { + name: &'static str, + fns: FieldAccessorFunctions<M>, +} + +impl<M: Message> FieldAccessorImpl<M> { + fn get_value_option<'a>(&self, m: &'a M) -> Option<ReflectValueRef<'a>> { + match self.fns { + FieldAccessorFunctions::Repeated(..) | FieldAccessorFunctions::Map(..) => { + panic!("repeated") + } + FieldAccessorFunctions::Simple(ref a) => Some(a.get_field(m).as_ref()), + FieldAccessorFunctions::Optional(ref a) => { + a.get_field(m).to_option().map(|v| v.as_ref()) + } + FieldAccessorFunctions::SingularHasGetSet { + ref has, + ref get_set, + } => { + if !has(m) { + None + } else { + Some(get_set.get_ref(m)) + } + } + } + } +} + +impl<M: Message + 'static> FieldAccessor for FieldAccessorImpl<M> { + fn name_generic(&self) -> &'static str { + self.name + } + + fn has_field_generic(&self, m: &Message) -> bool { + match self.fns { + FieldAccessorFunctions::SingularHasGetSet { has, .. } => has(message_down_cast(m)), + FieldAccessorFunctions::Optional(ref a) => { + a.get_field(message_down_cast(m)).to_option().is_some() + } + FieldAccessorFunctions::Simple(ref a) => { + a.get_field(message_down_cast(m)).is_non_zero() + } + FieldAccessorFunctions::Map(..) | FieldAccessorFunctions::Repeated(..) => { + panic!("has_xxx is not implemented for repeated"); + } + } + } + + fn len_field_generic(&self, m: &Message) -> usize { + match self.fns { + FieldAccessorFunctions::Repeated(ref a) => a.get_field(message_down_cast(m)).len(), + FieldAccessorFunctions::Map(ref a) => a.get_field(message_down_cast(m)).len(), + FieldAccessorFunctions::Simple(..) + | FieldAccessorFunctions::SingularHasGetSet { .. } + | FieldAccessorFunctions::Optional(..) => { + panic!("not a repeated field"); + } + } + } + + fn get_message_generic<'a>(&self, m: &'a Message) -> &'a Message { + match self.fns { + FieldAccessorFunctions::SingularHasGetSet { + get_set: SingularGetSet::Message(ref get), + .. + } => get.get_message(message_down_cast(m)), + FieldAccessorFunctions::Optional(ref t) => { + match t + .get_field(message_down_cast(m)) + .to_option() + .expect("field unset") + .as_ref() + { + ReflectValueRef::Message(m) => m, + _ => panic!("not a message"), + } + } + ref fns => panic!("unknown accessor type: {:?}", fns), + } + } + + fn get_enum_generic(&self, m: &Message) -> &'static EnumValueDescriptor { + match self.fns { + FieldAccessorFunctions::SingularHasGetSet { + get_set: SingularGetSet::Enum(ref get), + .. + } => get.get_enum(message_down_cast(m)), + _ => panic!(), + } + } + + fn get_str_generic<'a>(&self, m: &'a Message) -> &'a str { + match self.get_value_option(message_down_cast(m)) { + Some(ReflectValueRef::String(v)) => v, + Some(_) => panic!("wrong type"), + None => "", // TODO: check type + } + } + + fn get_bytes_generic<'a>(&self, m: &'a Message) -> &'a [u8] { + match self.get_value_option(message_down_cast(m)) { + Some(ReflectValueRef::Bytes(v)) => v, + Some(_) => panic!("wrong type"), + None => b"", // TODO: check type + } + } + + fn get_u32_generic(&self, m: &Message) -> u32 { + match self.get_value_option(message_down_cast(m)) { + Some(ReflectValueRef::U32(v)) => v, + Some(_) => panic!("wrong type"), + None => 0, // TODO: check type + } + } + + fn get_u64_generic(&self, m: &Message) -> u64 { + match self.get_value_option(message_down_cast(m)) { + Some(ReflectValueRef::U64(v)) => v, + Some(_) => panic!("wrong type"), + None => 0, // TODO: check type + } + } + + fn get_i32_generic(&self, m: &Message) -> i32 { + match self.get_value_option(message_down_cast(m)) { + Some(ReflectValueRef::I32(v)) => v, + Some(_) => panic!("wrong type"), + None => 0, // TODO: check type + } + } + + fn get_i64_generic(&self, m: &Message) -> i64 { + match self.get_value_option(message_down_cast(m)) { + Some(ReflectValueRef::I64(v)) => v, + Some(_) => panic!("wrong type"), + None => 0, // TODO: check type + } + } + + fn get_f32_generic(&self, m: &Message) -> f32 { + match self.get_value_option(message_down_cast(m)) { + Some(ReflectValueRef::F32(v)) => v, + Some(_) => panic!("wrong type"), + None => 0.0, // TODO: check type + } + } + + fn get_f64_generic(&self, m: &Message) -> f64 { + match self.get_value_option(message_down_cast(m)) { + Some(ReflectValueRef::F64(v)) => v, + Some(_) => panic!("wrong type"), + None => 0.0, // TODO: check type + } + } + + fn get_bool_generic(&self, m: &Message) -> bool { + match self.get_value_option(message_down_cast(m)) { + Some(ReflectValueRef::Bool(v)) => v, + Some(_) => panic!("wrong type"), + None => false, // TODO: check type + } + } + + fn get_reflect<'a>(&self, m: &'a Message) -> ReflectFieldRef<'a> { + match self.fns { + FieldAccessorFunctions::Repeated(ref accessor2) => { + ReflectFieldRef::Repeated(accessor2.get_field(message_down_cast(m))) + } + FieldAccessorFunctions::Map(ref accessor2) => { + ReflectFieldRef::Map(accessor2.get_field(message_down_cast(m))) + } + FieldAccessorFunctions::Optional(ref accessor2) => ReflectFieldRef::Optional( + accessor2 + .get_field(message_down_cast(m)) + .to_option() + .map(|v| v.as_ref()), + ), + FieldAccessorFunctions::Simple(ref accessor2) => ReflectFieldRef::Optional({ + let v = accessor2.get_field(message_down_cast(m)); + if v.is_non_zero() { + Some(v.as_ref()) + } else { + None + } + }), + FieldAccessorFunctions::SingularHasGetSet { + ref has, + ref get_set, + } => ReflectFieldRef::Optional(if has(message_down_cast(m)) { + Some(get_set.get_ref(message_down_cast(m))) + } else { + None + }), + } + } +} + +// singular + +fn set_panic<A, B>(_: &mut A, _: B) { + panic!() +} + +// TODO: make_singular_xxx_accessor are used only for oneof fields +// oneof codegen should be changed + +pub fn make_singular_u32_accessor<M: Message + 'static>( + name: &'static str, + has: fn(&M) -> bool, + get: fn(&M) -> u32, +) -> Box<FieldAccessor + 'static> { + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::SingularHasGetSet { + has: has, + get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl { + get: get, + _set: set_panic, + })), + }, + }) +} + +pub fn make_singular_i32_accessor<M: Message + 'static>( + name: &'static str, + has: fn(&M) -> bool, + get: fn(&M) -> i32, +) -> Box<FieldAccessor + 'static> { + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::SingularHasGetSet { + has: has, + get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl { + get: get, + _set: set_panic, + })), + }, + }) +} + +pub fn make_singular_u64_accessor<M: Message + 'static>( + name: &'static str, + has: fn(&M) -> bool, + get: fn(&M) -> u64, +) -> Box<FieldAccessor + 'static> { + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::SingularHasGetSet { + has: has, + get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl { + get: get, + _set: set_panic, + })), + }, + }) +} + +pub fn make_singular_i64_accessor<M: Message + 'static>( + name: &'static str, + has: fn(&M) -> bool, + get: fn(&M) -> i64, +) -> Box<FieldAccessor + 'static> { + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::SingularHasGetSet { + has: has, + get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl { + get: get, + _set: set_panic, + })), + }, + }) +} + +pub fn make_singular_f32_accessor<M: Message + 'static>( + name: &'static str, + has: fn(&M) -> bool, + get: fn(&M) -> f32, +) -> Box<FieldAccessor + 'static> { + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::SingularHasGetSet { + has: has, + get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl { + get: get, + _set: set_panic, + })), + }, + }) +} + +pub fn make_singular_f64_accessor<M: Message + 'static>( + name: &'static str, + has: fn(&M) -> bool, + get: fn(&M) -> f64, +) -> Box<FieldAccessor + 'static> { + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::SingularHasGetSet { + has: has, + get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl { + get: get, + _set: set_panic, + })), + }, + }) +} + +pub fn make_singular_bool_accessor<M: Message + 'static>( + name: &'static str, + has: fn(&M) -> bool, + get: fn(&M) -> bool, +) -> Box<FieldAccessor + 'static> { + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::SingularHasGetSet { + has: has, + get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl { + get: get, + _set: set_panic, + })), + }, + }) +} + +pub fn make_singular_enum_accessor<M: Message + 'static, E: ProtobufEnum + 'static>( + name: &'static str, + has: fn(&M) -> bool, + get: fn(&M) -> E, +) -> Box<FieldAccessor + 'static> { + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::SingularHasGetSet { + has: has, + get_set: SingularGetSet::Enum(Box::new(GetSingularEnumImpl { get: get })), + }, + }) +} + +pub fn make_singular_string_accessor<M: Message + 'static>( + name: &'static str, + has: fn(&M) -> bool, + get: for<'a> fn(&'a M) -> &'a str, +) -> Box<FieldAccessor + 'static> { + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::SingularHasGetSet { + has: has, + get_set: SingularGetSet::String(get, set_panic), + }, + }) +} + +pub fn make_singular_bytes_accessor<M: Message + 'static>( + name: &'static str, + has: fn(&M) -> bool, + get: for<'a> fn(&'a M) -> &'a [u8], +) -> Box<FieldAccessor + 'static> { + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::SingularHasGetSet { + has: has, + get_set: SingularGetSet::Bytes(get, set_panic), + }, + }) +} + +pub fn make_singular_message_accessor<M: Message + 'static, F: Message + 'static>( + name: &'static str, + has: fn(&M) -> bool, + get: for<'a> fn(&'a M) -> &'a F, +) -> Box<FieldAccessor + 'static> { + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::SingularHasGetSet { + has: has, + get_set: SingularGetSet::Message(Box::new(GetSingularMessageImpl { get: get })), + }, + }) +} + +// repeated + +impl<M, V> FieldAccessor2<M, ReflectRepeated> for MessageGetMut<M, Vec<V>> +where + M: Message + 'static, + V: ProtobufValue + 'static, +{ + fn get_field<'a>(&self, m: &'a M) -> &'a ReflectRepeated { + (self.get_field)(m) as &ReflectRepeated + } + + fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ReflectRepeated { + (self.mut_field)(m) as &mut ReflectRepeated + } +} + +pub fn make_vec_accessor<M, V>( + name: &'static str, + get_vec: for<'a> fn(&'a M) -> &'a Vec<V::Value>, + mut_vec: for<'a> fn(&'a mut M) -> &'a mut Vec<V::Value>, +) -> Box<FieldAccessor + 'static> +where + M: Message + 'static, + V: ProtobufType + 'static, +{ + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::Repeated(Box::new(MessageGetMut::<M, Vec<V::Value>> { + get_field: get_vec, + mut_field: mut_vec, + })), + }) +} + +impl<M, V> FieldAccessor2<M, ReflectRepeated> for MessageGetMut<M, RepeatedField<V>> +where + M: Message + 'static, + V: ProtobufValue + 'static, +{ + fn get_field<'a>(&self, m: &'a M) -> &'a ReflectRepeated { + (self.get_field)(m) as &ReflectRepeated + } + + fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ReflectRepeated { + (self.mut_field)(m) as &mut ReflectRepeated + } +} + +pub fn make_repeated_field_accessor<M, V>( + name: &'static str, + get_vec: for<'a> fn(&'a M) -> &'a RepeatedField<V::Value>, + mut_vec: for<'a> fn(&'a mut M) -> &'a mut RepeatedField<V::Value>, +) -> Box<FieldAccessor + 'static> +where + M: Message + 'static, + V: ProtobufType + 'static, +{ + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::Repeated(Box::new(MessageGetMut::< + M, + RepeatedField<V::Value>, + > { + get_field: get_vec, + mut_field: mut_vec, + })), + }) +} + +impl<M, V> FieldAccessor2<M, ReflectOptional> for MessageGetMut<M, Option<V>> +where + M: Message + 'static, + V: ProtobufValue + Clone + 'static, +{ + fn get_field<'a>(&self, m: &'a M) -> &'a ReflectOptional { + (self.get_field)(m) as &ReflectOptional + } + + fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ReflectOptional { + (self.mut_field)(m) as &mut ReflectOptional + } +} + +pub fn make_option_accessor<M, V>( + name: &'static str, + get_field: for<'a> fn(&'a M) -> &'a Option<V::Value>, + mut_field: for<'a> fn(&'a mut M) -> &'a mut Option<V::Value>, +) -> Box<FieldAccessor + 'static> +where + M: Message + 'static, + V: ProtobufType + 'static, +{ + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::Optional(Box::new(MessageGetMut::<M, Option<V::Value>> { + get_field: get_field, + mut_field: mut_field, + })), + }) +} + +impl<M, V> FieldAccessor2<M, ReflectOptional> for MessageGetMut<M, SingularField<V>> +where + M: Message + 'static, + V: ProtobufValue + Clone + 'static, +{ + fn get_field<'a>(&self, m: &'a M) -> &'a ReflectOptional { + (self.get_field)(m) as &ReflectOptional + } + + fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ReflectOptional { + (self.mut_field)(m) as &mut ReflectOptional + } +} + +pub fn make_singular_field_accessor<M, V>( + name: &'static str, + get_field: for<'a> fn(&'a M) -> &'a SingularField<V::Value>, + mut_field: for<'a> fn(&'a mut M) -> &'a mut SingularField<V::Value>, +) -> Box<FieldAccessor + 'static> +where + M: Message + 'static, + V: ProtobufType + 'static, +{ + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::Optional(Box::new(MessageGetMut::< + M, + SingularField<V::Value>, + > { + get_field: get_field, + mut_field: mut_field, + })), + }) +} + +impl<M, V> FieldAccessor2<M, ReflectOptional> for MessageGetMut<M, SingularPtrField<V>> +where + M: Message + 'static, + V: ProtobufValue + Clone + 'static, +{ + fn get_field<'a>(&self, m: &'a M) -> &'a ReflectOptional { + (self.get_field)(m) as &ReflectOptional + } + + fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ReflectOptional { + (self.mut_field)(m) as &mut ReflectOptional + } +} + +pub fn make_singular_ptr_field_accessor<M, V>( + name: &'static str, + get_field: for<'a> fn(&'a M) -> &'a SingularPtrField<V::Value>, + mut_field: for<'a> fn(&'a mut M) -> &'a mut SingularPtrField<V::Value>, +) -> Box<FieldAccessor + 'static> +where + M: Message + 'static, + V: ProtobufType + 'static, +{ + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::Optional(Box::new(MessageGetMut::< + M, + SingularPtrField<V::Value>, + > { + get_field: get_field, + mut_field: mut_field, + })), + }) +} + +impl<M, V> FieldAccessor2<M, ProtobufValue> for MessageGetMut<M, V> +where + M: Message + 'static, + V: ProtobufValue + Clone + 'static, +{ + fn get_field<'a>(&self, m: &'a M) -> &'a ProtobufValue { + (self.get_field)(m) as &ProtobufValue + } + + fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ProtobufValue { + (self.mut_field)(m) as &mut ProtobufValue + } +} + +pub fn make_simple_field_accessor<M, V>( + name: &'static str, + get_field: for<'a> fn(&'a M) -> &'a V::Value, + mut_field: for<'a> fn(&'a mut M) -> &'a mut V::Value, +) -> Box<FieldAccessor + 'static> +where + M: Message + 'static, + V: ProtobufType + 'static, +{ + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::Simple(Box::new(MessageGetMut::<M, V::Value> { + get_field: get_field, + mut_field: mut_field, + })), + }) +} + +impl<M, K, V> FieldAccessor2<M, ReflectMap> for MessageGetMut<M, HashMap<K, V>> +where + M: Message + 'static, + K: ProtobufValue + 'static, + V: ProtobufValue + 'static, + K: Hash + Eq, +{ + fn get_field<'a>(&self, m: &'a M) -> &'a ReflectMap { + (self.get_field)(m) as &ReflectMap + } + + fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ReflectMap { + (self.mut_field)(m) as &mut ReflectMap + } +} + +pub fn make_map_accessor<M, K, V>( + name: &'static str, + get_field: for<'a> fn(&'a M) -> &'a HashMap<K::Value, V::Value>, + mut_field: for<'a> fn(&'a mut M) -> &'a mut HashMap<K::Value, V::Value>, +) -> Box<FieldAccessor + 'static> +where + M: Message + 'static, + K: ProtobufType + 'static, + V: ProtobufType + 'static, + <K as ProtobufType>::Value: Hash + Eq, +{ + Box::new(FieldAccessorImpl { + name: name, + fns: FieldAccessorFunctions::Map(Box::new( + MessageGetMut::<M, HashMap<K::Value, V::Value>> { + get_field: get_field, + mut_field: mut_field, + }, + )), + }) +} diff --git a/src/reflect/enums.rs b/src/reflect/enums.rs new file mode 100644 index 0000000..e4ba4f6 --- /dev/null +++ b/src/reflect/enums.rs @@ -0,0 +1,127 @@ +use descriptor::EnumDescriptorProto; +use descriptor::EnumValueDescriptorProto; +use descriptor::FileDescriptorProto; +use descriptorx::find_enum_by_rust_name; +use reflect::find_message_or_enum::find_message_or_enum; +use reflect::find_message_or_enum::MessageOrEnum; +use std::collections::HashMap; +use ProtobufEnum; + +/// Description for enum variant. +/// +/// Used in reflection. +#[derive(Clone, Debug)] +pub struct EnumValueDescriptor { + proto: &'static EnumValueDescriptorProto, +} + +impl Copy for EnumValueDescriptor {} + +impl EnumValueDescriptor { + /// Name of enum variant as specified in proto file + pub fn name(&self) -> &'static str { + self.proto.get_name() + } + + /// `i32` value of the enum variant + pub fn value(&self) -> i32 { + self.proto.get_number() + } +} + +/// Dynamic representation of enum type. +/// +/// Can be used in reflective operations. +pub struct EnumDescriptor { + proto: &'static EnumDescriptorProto, + values: Vec<EnumValueDescriptor>, + + index_by_name: HashMap<String, usize>, + index_by_number: HashMap<i32, usize>, +} + +impl EnumDescriptor { + /// Enum name as given in `.proto` file + pub fn name(&self) -> &'static str { + self.proto.get_name() + } + + /// `EnumDescriptor` for enum type + pub fn for_type<E: ProtobufEnum>() -> &'static EnumDescriptor { + E::enum_descriptor_static() + } + + /// Create new enum descriptor. + /// + /// This function is called by generated code, and should not be called manually. + #[deprecated( + since = "2.12", + note = "Please regenerate .rs files from .proto files to use newer APIs" + )] + pub fn new(rust_name: &'static str, file: &'static FileDescriptorProto) -> EnumDescriptor { + let proto = find_enum_by_rust_name(file, rust_name); + let mut index_by_name = HashMap::new(); + let mut index_by_number = HashMap::new(); + for (i, v) in proto.en.get_value().iter().enumerate() { + index_by_number.insert(v.get_number(), i); + index_by_name.insert(v.get_name().to_string(), i); + } + EnumDescriptor { + proto: proto.en, + values: proto + .en + .get_value() + .iter() + .map(|v| EnumValueDescriptor { proto: v }) + .collect(), + index_by_name: index_by_name, + index_by_number: index_by_number, + } + } + + /// Create new enum descriptor. + /// + /// This function is called by generated code, and should not be called manually. + pub fn new_pb_name<E>( + name_in_file: &'static str, + file: &'static FileDescriptorProto, + ) -> EnumDescriptor + where + E: ProtobufEnum, + { + let (_path_to_package, proto) = match find_message_or_enum(file, name_in_file) { + (path_to_package, MessageOrEnum::Enum(e)) => (path_to_package, e), + (_, MessageOrEnum::Message(_)) => panic!("not an enum"), + }; + + let mut index_by_name = HashMap::new(); + let mut index_by_number = HashMap::new(); + for (i, v) in proto.get_value().iter().enumerate() { + index_by_number.insert(v.get_number(), i); + index_by_name.insert(v.get_name().to_string(), i); + } + EnumDescriptor { + proto, + values: proto + .get_value() + .iter() + .map(|v| EnumValueDescriptor { proto: v }) + .collect(), + index_by_name: index_by_name, + index_by_number: index_by_number, + } + } + + /// Find enum value by name + pub fn value_by_name<'a>(&'a self, name: &str) -> &'a EnumValueDescriptor { + // TODO: clone is weird + let &index = self.index_by_name.get(&name.to_string()).unwrap(); + &self.values[index] + } + + /// Find enum value by number + pub fn value_by_number<'a>(&'a self, number: i32) -> &'a EnumValueDescriptor { + let &index = self.index_by_number.get(&number).unwrap(); + &self.values[index] + } +} diff --git a/src/reflect/field.rs b/src/reflect/field.rs new file mode 100644 index 0000000..ecac510 --- /dev/null +++ b/src/reflect/field.rs @@ -0,0 +1,191 @@ +use descriptor::{FieldDescriptorProto, FieldDescriptorProto_Label}; +use reflect::accessor::FieldAccessor; +use reflect::map::ReflectMap; +use reflect::repeated::ReflectRepeated; +use reflect::{EnumValueDescriptor, ReflectValueRef}; +use Message; + +/// Reference to a value stored in a field, optional, repeated or map. +// TODO: implement Eq +pub enum ReflectFieldRef<'a> { + /// Singular field, optional or required in proto3 and just plain field in proto3 + Optional(Option<ReflectValueRef<'a>>), + /// Repeated field + Repeated(&'a ReflectRepeated), + /// Map field + Map(&'a ReflectMap), +} + +/// Field descriptor. +/// +/// Can be used for runtime reflection. +pub struct FieldDescriptor { + proto: &'static FieldDescriptorProto, + accessor: Box<FieldAccessor + 'static>, +} + +impl FieldDescriptor { + pub(crate) fn new( + accessor: Box<FieldAccessor + 'static>, + proto: &'static FieldDescriptorProto, + ) -> FieldDescriptor { + assert_eq!(proto.get_name(), accessor.name_generic()); + FieldDescriptor { proto, accessor } + } + + /// Get `.proto` description of field + pub fn proto(&self) -> &'static FieldDescriptorProto { + self.proto + } + + /// Field name as specified in `.proto` file + pub fn name(&self) -> &'static str { + self.proto.get_name() + } + + /// If this field repeated? + pub fn is_repeated(&self) -> bool { + self.proto.get_label() == FieldDescriptorProto_Label::LABEL_REPEATED + } + + /// Check if field is set in given message. + /// + /// For repeated field or map field return `true` if + /// collection is not empty. + /// + /// # Panics + /// + /// If this field belongs to a different message type. + pub fn has_field(&self, m: &Message) -> bool { + self.accessor.has_field_generic(m) + } + + /// Return length of repeated field. + /// + /// For singualar field return `1` if field is set and `0` otherwise. + /// + /// # Panics + /// + /// If this field belongs to a different message type. + pub fn len_field(&self, m: &dyn Message) -> usize { + self.accessor.len_field_generic(m) + } + + /// Get message field or default instance if field is unset. + /// + /// # Panics + /// If this field belongs to a different message type or + /// field type is not message. + pub fn get_message<'a>(&self, m: &'a dyn Message) -> &'a dyn Message { + self.accessor.get_message_generic(m) + } + + /// Get `enum` field. + /// + /// # Panics + /// + /// If this field belongs to a different message type + /// or field type is not singular `enum`. + pub fn get_enum(&self, m: &dyn Message) -> &'static EnumValueDescriptor { + self.accessor.get_enum_generic(m) + } + + /// Get `string` field. + /// + /// # Panics + /// + /// If this field belongs to a different message type + /// or field type is not singular `string`. + pub fn get_str<'a>(&self, m: &'a dyn Message) -> &'a str { + self.accessor.get_str_generic(m) + } + + /// Get `bytes` field. + /// + /// # Panics + /// + /// If this field belongs to a different message type + /// or field type is not singular `bytes`. + pub fn get_bytes<'a>(&self, m: &'a dyn Message) -> &'a [u8] { + self.accessor.get_bytes_generic(m) + } + + /// Get `u32` field. + /// + /// # Panics + /// + /// If this field belongs to a different message type + /// or field type is not singular `u32`. + pub fn get_u32(&self, m: &dyn Message) -> u32 { + self.accessor.get_u32_generic(m) + } + + /// Get `u64` field. + /// + /// # Panics + /// + /// If this field belongs to a different message type + /// or field type is not singular `u64`. + pub fn get_u64(&self, m: &dyn Message) -> u64 { + self.accessor.get_u64_generic(m) + } + + /// Get `i32` field. + /// + /// # Panics + /// + /// If this field belongs to a different message type + /// or field type is not singular `i32`. + pub fn get_i32(&self, m: &dyn Message) -> i32 { + self.accessor.get_i32_generic(m) + } + + /// Get `i64` field. + /// + /// # Panics + /// + /// If this field belongs to a different message type + /// or field type is not singular `i64`. + pub fn get_i64(&self, m: &dyn Message) -> i64 { + self.accessor.get_i64_generic(m) + } + + /// Get `bool` field. + /// + /// # Panics + /// + /// If this field belongs to a different message type or + /// field type is not singular `bool`. + pub fn get_bool(&self, m: &dyn Message) -> bool { + self.accessor.get_bool_generic(m) + } + + /// Get `float` field. + /// + /// # Panics + /// + /// If this field belongs to a different message type or + /// field type is not singular `float`. + pub fn get_f32(&self, m: &dyn Message) -> f32 { + self.accessor.get_f32_generic(m) + } + + /// Get `double` field. + /// + /// # Panics + /// + /// If this field belongs to a different message type + /// or field type is not singular `double`. + pub fn get_f64(&self, m: &dyn Message) -> f64 { + self.accessor.get_f64_generic(m) + } + + /// Get field of any type. + /// + /// # Panics + /// + /// If this field belongs to a different message type. + pub fn get_reflect<'a>(&self, m: &'a dyn Message) -> ReflectFieldRef<'a> { + self.accessor.get_reflect(m) + } +} diff --git a/src/reflect/find_message_or_enum.rs b/src/reflect/find_message_or_enum.rs new file mode 100644 index 0000000..7ee3915 --- /dev/null +++ b/src/reflect/find_message_or_enum.rs @@ -0,0 +1,62 @@ +use crate::descriptor::DescriptorProto; +use crate::descriptor::EnumDescriptorProto; +use crate::descriptor::FileDescriptorProto; + +pub(crate) enum MessageOrEnum<'a> { + Message(&'a DescriptorProto), + Enum(&'a EnumDescriptorProto), +} + +impl<'a> MessageOrEnum<'a> { + fn from_two_options( + m: Option<&'a DescriptorProto>, + e: Option<&'a EnumDescriptorProto>, + ) -> MessageOrEnum<'a> { + match (m, e) { + (Some(_), Some(_)) => panic!("enum and message with the same name"), + (Some(m), None) => MessageOrEnum::Message(m), + (None, Some(e)) => MessageOrEnum::Enum(e), + (None, None) => panic!("not found"), + } + } +} + +pub(crate) fn find_message_or_enum<'a>( + file: &'a FileDescriptorProto, + name_to_package: &str, +) -> (String, MessageOrEnum<'a>) { + let mut path = name_to_package.split('.'); + let first = path.next().unwrap(); + let child_message = file + .get_message_type() + .iter() + .find(|m| m.get_name() == first); + let child_enum = file.get_enum_type().iter().find(|e| e.get_name() == first); + + let mut package_to_name = String::new(); + let mut me = MessageOrEnum::from_two_options(child_message, child_enum); + + for name in path { + let message = match me { + MessageOrEnum::Message(m) => m, + MessageOrEnum::Enum(_) => panic!("enum has no children"), + }; + + if !package_to_name.is_empty() { + package_to_name.push_str("."); + } + package_to_name.push_str(message.get_name()); + + let child_message = message + .get_nested_type() + .iter() + .find(|m| m.get_name() == name); + let child_enum = message + .get_enum_type() + .iter() + .find(|e| e.get_name() == name); + me = MessageOrEnum::from_two_options(child_message, child_enum) + } + + (package_to_name, me) +} diff --git a/src/reflect/map.rs b/src/reflect/map.rs new file mode 100644 index 0000000..9f03123 --- /dev/null +++ b/src/reflect/map.rs @@ -0,0 +1,66 @@ +use std::collections::hash_map; +use std::collections::HashMap; +use std::hash::Hash; + +use super::value::ProtobufValue; + +/// Implemented for `HashMap` with appropriate keys and values +pub trait ReflectMap: 'static { + fn reflect_iter(&self) -> ReflectMapIter; + + fn len(&self) -> usize; +} + +impl<K: ProtobufValue + Eq + Hash + 'static, V: ProtobufValue + 'static> ReflectMap + for HashMap<K, V> +{ + fn reflect_iter<'a>(&'a self) -> ReflectMapIter<'a> { + ReflectMapIter { + imp: Box::new(ReflectMapIterImpl::<'a, K, V> { iter: self.iter() }), + } + } + + fn len(&self) -> usize { + HashMap::len(self) + } +} + +trait ReflectMapIterTrait<'a> { + fn next(&mut self) -> Option<(&'a ProtobufValue, &'a ProtobufValue)>; +} + +struct ReflectMapIterImpl<'a, K: Eq + Hash + 'static, V: 'static> { + iter: hash_map::Iter<'a, K, V>, +} + +impl<'a, K: ProtobufValue + Eq + Hash + 'static, V: ProtobufValue + 'static> ReflectMapIterTrait<'a> + for ReflectMapIterImpl<'a, K, V> +{ + fn next(&mut self) -> Option<(&'a ProtobufValue, &'a ProtobufValue)> { + match self.iter.next() { + Some((k, v)) => Some((k as &ProtobufValue, v as &ProtobufValue)), + None => None, + } + } +} + +pub struct ReflectMapIter<'a> { + imp: Box<ReflectMapIterTrait<'a> + 'a>, +} + +impl<'a> Iterator for ReflectMapIter<'a> { + type Item = (&'a ProtobufValue, &'a ProtobufValue); + + fn next(&mut self) -> Option<(&'a ProtobufValue, &'a ProtobufValue)> { + self.imp.next() + } +} + +impl<'a> IntoIterator for &'a ReflectMap { + type IntoIter = ReflectMapIter<'a>; + type Item = (&'a ProtobufValue, &'a ProtobufValue); + + fn into_iter(self) -> Self::IntoIter { + self.reflect_iter() + } +} diff --git a/src/reflect/message.rs b/src/reflect/message.rs new file mode 100644 index 0000000..c35a854 --- /dev/null +++ b/src/reflect/message.rs @@ -0,0 +1,223 @@ +use descriptor::{DescriptorProto, FileDescriptorProto}; +use descriptorx::find_message_by_rust_name; +use reflect::accessor::FieldAccessor; +use reflect::find_message_or_enum::find_message_or_enum; +use reflect::find_message_or_enum::MessageOrEnum; +use reflect::FieldDescriptor; +use std::collections::HashMap; +use std::marker; +use Message; + +trait MessageFactory: Send + Sync + 'static { + fn new_instance(&self) -> Box<dyn Message>; +} + +struct MessageFactoryImpl<M>(marker::PhantomData<M>); + +impl<M> MessageFactory for MessageFactoryImpl<M> +where + M: 'static + Message + Default + Clone + PartialEq, +{ + fn new_instance(&self) -> Box<dyn Message> { + let m: M = Default::default(); + Box::new(m) + } +} + +/// Dynamic message type +pub struct MessageDescriptor { + full_name: String, + proto: &'static DescriptorProto, + factory: &'static dyn MessageFactory, + fields: Vec<FieldDescriptor>, + + index_by_name: HashMap<String, usize>, + index_by_number: HashMap<u32, usize>, +} + +impl MessageDescriptor { + /// Get underlying `DescriptorProto` object. + pub fn get_proto(&self) -> &DescriptorProto { + self.proto + } + + /// Get a message descriptor for given message type + pub fn for_type<M: Message>() -> &'static MessageDescriptor { + M::descriptor_static() + } + + fn compute_full_name(package: &str, path_to_package: &str, proto: &DescriptorProto) -> String { + let mut full_name = package.to_owned(); + if path_to_package.len() != 0 { + if full_name.len() != 0 { + full_name.push('.'); + } + full_name.push_str(path_to_package); + } + if full_name.len() != 0 { + full_name.push('.'); + } + full_name.push_str(proto.get_name()); + full_name + } + + // Non-generic part of `new` is a separate function + // to reduce code bloat from multiple instantiations. + fn new_non_generic_by_rust_name( + rust_name: &'static str, + fields: Vec<Box<FieldAccessor + 'static>>, + file: &'static FileDescriptorProto, + factory: &'static dyn MessageFactory, + ) -> MessageDescriptor { + let proto = find_message_by_rust_name(file, rust_name); + + let mut field_proto_by_name = HashMap::new(); + for field_proto in proto.message.get_field() { + field_proto_by_name.insert(field_proto.get_name(), field_proto); + } + + let mut index_by_name = HashMap::new(); + let mut index_by_number = HashMap::new(); + for (i, f) in proto.message.get_field().iter().enumerate() { + index_by_number.insert(f.get_number() as u32, i); + index_by_name.insert(f.get_name().to_string(), i); + } + + let mut full_name = file.get_package().to_string(); + if full_name.len() > 0 { + full_name.push('.'); + } + full_name.push_str(proto.message.get_name()); + + MessageDescriptor { + full_name: full_name, + proto: proto.message, + factory, + fields: fields + .into_iter() + .map(|f| { + let proto = *field_proto_by_name.get(&f.name_generic()).unwrap(); + FieldDescriptor::new(f, proto) + }) + .collect(), + index_by_name, + index_by_number, + } + } + + // Non-generic part of `new` is a separate function + // to reduce code bloat from multiple instantiations. + fn new_non_generic_by_pb_name( + protobuf_name_to_package: &'static str, + fields: Vec<Box<FieldAccessor + 'static>>, + file_descriptor_proto: &'static FileDescriptorProto, + factory: &'static dyn MessageFactory, + ) -> MessageDescriptor { + let (path_to_package, proto) = + match find_message_or_enum(file_descriptor_proto, protobuf_name_to_package) { + (path_to_package, MessageOrEnum::Message(m)) => (path_to_package, m), + (_, MessageOrEnum::Enum(_)) => panic!("not a message"), + }; + + let mut field_proto_by_name = HashMap::new(); + for field_proto in proto.get_field() { + field_proto_by_name.insert(field_proto.get_name(), field_proto); + } + + let mut index_by_name = HashMap::new(); + let mut index_by_number = HashMap::new(); + for (i, f) in proto.get_field().iter().enumerate() { + index_by_number.insert(f.get_number() as u32, i); + index_by_name.insert(f.get_name().to_string(), i); + } + + MessageDescriptor { + full_name: MessageDescriptor::compute_full_name( + file_descriptor_proto.get_package(), + &path_to_package, + &proto, + ), + proto, + factory, + fields: fields + .into_iter() + .map(|f| { + let proto = *field_proto_by_name.get(&f.name_generic()).unwrap(); + FieldDescriptor::new(f, proto) + }) + .collect(), + index_by_name, + index_by_number, + } + } + + /// Construct a new message descriptor. + /// + /// This operation is called from generated code and rarely + /// need to be called directly. + #[doc(hidden)] + #[deprecated( + since = "2.12", + note = "Please regenerate .rs files from .proto files to use newer APIs" + )] + pub fn new<M: 'static + Message + Default + Clone + PartialEq>( + rust_name: &'static str, + fields: Vec<Box<FieldAccessor + 'static>>, + file: &'static FileDescriptorProto, + ) -> MessageDescriptor { + let factory = &MessageFactoryImpl(marker::PhantomData::<M>); + MessageDescriptor::new_non_generic_by_rust_name(rust_name, fields, file, factory) + } + + /// Construct a new message descriptor. + /// + /// This operation is called from generated code and rarely + /// need to be called directly. + #[doc(hidden)] + pub fn new_pb_name<M: 'static + Message + Default + Clone + PartialEq>( + protobuf_name_to_package: &'static str, + fields: Vec<Box<FieldAccessor + 'static>>, + file_descriptor_proto: &'static FileDescriptorProto, + ) -> MessageDescriptor { + let factory = &MessageFactoryImpl(marker::PhantomData::<M>); + MessageDescriptor::new_non_generic_by_pb_name( + protobuf_name_to_package, + fields, + file_descriptor_proto, + factory, + ) + } + + /// New empty message + pub fn new_instance(&self) -> Box<dyn Message> { + self.factory.new_instance() + } + + /// Protobuf message name + pub fn name(&self) -> &'static str { + self.proto.get_name() + } + + /// Fully qualified protobuf message name + pub fn full_name(&self) -> &str { + &self.full_name[..] + } + + /// Message field descriptors. + pub fn fields(&self) -> &[FieldDescriptor] { + &self.fields + } + + /// Find field by name + pub fn field_by_name<'a>(&'a self, name: &str) -> &'a FieldDescriptor { + // TODO: clone is weird + let &index = self.index_by_name.get(&name.to_string()).unwrap(); + &self.fields[index] + } + + /// Find field by number + pub fn field_by_number<'a>(&'a self, number: u32) -> &'a FieldDescriptor { + let &index = self.index_by_number.get(&number).unwrap(); + &self.fields[index] + } +} diff --git a/src/reflect/mod.rs b/src/reflect/mod.rs new file mode 100644 index 0000000..ede3743 --- /dev/null +++ b/src/reflect/mod.rs @@ -0,0 +1,27 @@ +//! Reflection implementation for protobuf types. + +use core::Message; + +pub mod accessor; +mod enums; +mod field; +mod find_message_or_enum; +mod map; +mod message; +mod optional; +mod repeated; +mod value; + +pub use self::value::ProtobufValue; +pub use self::value::ReflectValueRef; +#[doc(hidden)] +#[deprecated(since = "2.11", note = "Use ReflectValueRef instead")] +pub use self::value::ReflectValueRef as ProtobufValueRef; + +pub use self::enums::EnumDescriptor; +pub use self::enums::EnumValueDescriptor; + +pub use self::message::MessageDescriptor; + +pub use self::field::FieldDescriptor; +pub use self::field::ReflectFieldRef; diff --git a/src/reflect/optional.rs b/src/reflect/optional.rs new file mode 100644 index 0000000..4d33752 --- /dev/null +++ b/src/reflect/optional.rs @@ -0,0 +1,50 @@ +use std::mem; + +use super::value::ProtobufValue; + +use singular::*; + +pub trait ReflectOptional: 'static { + fn to_option(&self) -> Option<&ProtobufValue>; + + fn set_value(&mut self, value: &ProtobufValue); +} + +impl<V: ProtobufValue + Clone + 'static> ReflectOptional for Option<V> { + fn to_option(&self) -> Option<&ProtobufValue> { + self.as_ref().map(|v| v as &ProtobufValue) + } + + fn set_value(&mut self, value: &ProtobufValue) { + match value.as_any().downcast_ref::<V>() { + Some(v) => mem::replace(self, Some(v.clone())), + None => panic!(), + }; + } +} + +impl<V: ProtobufValue + Clone + 'static> ReflectOptional for SingularField<V> { + fn to_option(&self) -> Option<&ProtobufValue> { + self.as_ref().map(|v| v as &ProtobufValue) + } + + fn set_value(&mut self, value: &ProtobufValue) { + match value.as_any().downcast_ref::<V>() { + Some(v) => mem::replace(self, SingularField::some(v.clone())), + None => panic!(), + }; + } +} + +impl<V: ProtobufValue + Clone + 'static> ReflectOptional for SingularPtrField<V> { + fn to_option(&self) -> Option<&ProtobufValue> { + self.as_ref().map(|v| v as &ProtobufValue) + } + + fn set_value(&mut self, value: &ProtobufValue) { + match value.as_any().downcast_ref::<V>() { + Some(v) => mem::replace(self, SingularPtrField::some(v.clone())), + None => panic!(), + }; + } +} diff --git a/src/reflect/repeated.rs b/src/reflect/repeated.rs new file mode 100644 index 0000000..7ffc979 --- /dev/null +++ b/src/reflect/repeated.rs @@ -0,0 +1,192 @@ +use std::slice; + +use super::value::ProtobufValue; +use super::value::ReflectValueRef; + +use repeated::RepeatedField; + +pub trait ReflectRepeated: 'static { + fn reflect_iter(&self) -> ReflectRepeatedIter; + fn len(&self) -> usize; + fn get(&self, index: usize) -> &ProtobufValue; +} + +impl<V: ProtobufValue + 'static> ReflectRepeated for Vec<V> { + fn reflect_iter<'a>(&'a self) -> ReflectRepeatedIter<'a> { + ReflectRepeatedIter { + imp: Box::new(ReflectRepeatedIterImplSlice::<'a, V> { iter: self.iter() }), + } + } + + fn len(&self) -> usize { + Vec::len(self) + } + + fn get(&self, index: usize) -> &ProtobufValue { + &self[index] + } +} + +// useless +impl<V: ProtobufValue + 'static> ReflectRepeated for [V] { + fn reflect_iter<'a>(&'a self) -> ReflectRepeatedIter<'a> { + ReflectRepeatedIter { + imp: Box::new(ReflectRepeatedIterImplSlice::<'a, V> { iter: self.iter() }), + } + } + + fn len(&self) -> usize { + <[_]>::len(self) + } + + fn get(&self, index: usize) -> &ProtobufValue { + &self[index] + } +} + +impl<V: ProtobufValue + 'static> ReflectRepeated for RepeatedField<V> { + fn reflect_iter<'a>(&'a self) -> ReflectRepeatedIter<'a> { + ReflectRepeatedIter { + imp: Box::new(ReflectRepeatedIterImplSlice::<'a, V> { iter: self.iter() }), + } + } + + fn len(&self) -> usize { + RepeatedField::len(self) + } + + fn get(&self, index: usize) -> &ProtobufValue { + &self[index] + } +} + +trait ReflectRepeatedIterTrait<'a> { + fn next(&mut self) -> Option<&'a ProtobufValue>; +} + +struct ReflectRepeatedIterImplSlice<'a, V: ProtobufValue + 'static> { + iter: slice::Iter<'a, V>, +} + +impl<'a, V: ProtobufValue + 'static> ReflectRepeatedIterTrait<'a> + for ReflectRepeatedIterImplSlice<'a, V> +{ + fn next(&mut self) -> Option<&'a ProtobufValue> { + self.iter.next().map(|v| v as &ProtobufValue) + } +} + +pub struct ReflectRepeatedIter<'a> { + imp: Box<ReflectRepeatedIterTrait<'a> + 'a>, +} + +impl<'a> Iterator for ReflectRepeatedIter<'a> { + type Item = &'a ProtobufValue; + + fn next(&mut self) -> Option<Self::Item> { + self.imp.next() + } +} + +impl<'a> IntoIterator for &'a ReflectRepeated { + type IntoIter = ReflectRepeatedIter<'a>; + type Item = &'a ProtobufValue; + + fn into_iter(self) -> Self::IntoIter { + self.reflect_iter() + } +} + +pub trait ReflectRepeatedEnum<'a> { + fn len(&self) -> usize; + + fn get(&self, index: usize) -> ReflectValueRef<'a>; +} + +pub trait ReflectRepeatedMessage<'a> { + fn len(&self) -> usize; + + fn get(&self, index: usize) -> ReflectValueRef<'a>; +} + +pub enum ReflectRepeatedRef<'a> { + Generic(&'a ReflectRepeated), + U32(&'a [u32]), + U64(&'a [u64]), + I32(&'a [i32]), + I64(&'a [i64]), + F32(&'a [f32]), + F64(&'a [f64]), + Bool(&'a [bool]), + String(&'a [String]), + Bytes(&'a [Vec<u8>]), + Enum(Box<ReflectRepeatedEnum<'a> + 'a>), + Message(Box<ReflectRepeatedMessage<'a> + 'a>), +} + +impl<'a> ReflectRepeatedRef<'a> { + fn len(&self) -> usize { + match *self { + ReflectRepeatedRef::Generic(ref r) => r.len(), + ReflectRepeatedRef::U32(ref r) => r.len(), + ReflectRepeatedRef::U64(ref r) => r.len(), + ReflectRepeatedRef::I32(ref r) => r.len(), + ReflectRepeatedRef::I64(ref r) => r.len(), + ReflectRepeatedRef::F32(ref r) => r.len(), + ReflectRepeatedRef::F64(ref r) => r.len(), + ReflectRepeatedRef::Bool(ref r) => r.len(), + ReflectRepeatedRef::String(ref r) => r.len(), + ReflectRepeatedRef::Bytes(ref r) => r.len(), + ReflectRepeatedRef::Enum(ref r) => r.len(), + ReflectRepeatedRef::Message(ref r) => r.len(), + } + } + + fn get(&self, index: usize) -> ReflectValueRef<'a> { + match *self { + ReflectRepeatedRef::Generic(ref r) => r.get(index).as_ref(), + ReflectRepeatedRef::U32(ref r) => ReflectValueRef::U32(r[index]), + ReflectRepeatedRef::U64(ref r) => ReflectValueRef::U64(r[index]), + ReflectRepeatedRef::I32(ref r) => ReflectValueRef::I32(r[index]), + ReflectRepeatedRef::I64(ref r) => ReflectValueRef::I64(r[index]), + ReflectRepeatedRef::F32(ref r) => ReflectValueRef::F32(r[index]), + ReflectRepeatedRef::F64(ref r) => ReflectValueRef::F64(r[index]), + ReflectRepeatedRef::Bool(ref r) => ReflectValueRef::Bool(r[index]), + ReflectRepeatedRef::String(ref r) => ReflectValueRef::String(&r[index]), + ReflectRepeatedRef::Bytes(ref r) => ReflectValueRef::Bytes(&r[index]), + ReflectRepeatedRef::Enum(ref r) => r.get(index), + ReflectRepeatedRef::Message(ref r) => r.get(index), + } + } +} + +pub struct ReflectRepeatedRefIter<'a> { + repeated: &'a ReflectRepeatedRef<'a>, + pos: usize, +} + +impl<'a> Iterator for ReflectRepeatedRefIter<'a> { + type Item = ReflectValueRef<'a>; + + fn next(&mut self) -> Option<Self::Item> { + if self.pos < self.repeated.len() { + let pos = self.pos; + self.pos += 1; + Some(self.repeated.get(pos)) + } else { + None + } + } +} + +impl<'a> IntoIterator for &'a ReflectRepeatedRef<'a> { + type IntoIter = ReflectRepeatedRefIter<'a>; + type Item = ReflectValueRef<'a>; + + fn into_iter(self) -> Self::IntoIter { + ReflectRepeatedRefIter { + repeated: self, + pos: 0, + } + } +} diff --git a/src/reflect/value.rs b/src/reflect/value.rs new file mode 100644 index 0000000..22f76af --- /dev/null +++ b/src/reflect/value.rs @@ -0,0 +1,185 @@ +use std::any::Any; + +#[cfg(feature = "bytes")] +use bytes::Bytes; +#[cfg(feature = "bytes")] +use chars::Chars; + +use super::*; + +/// Type implemented by all protobuf elementary types +/// (ints, floats, bool, string, bytes, enums, messages). +pub trait ProtobufValue: Any + 'static { + /// As ref + fn as_ref(&self) -> ReflectValueRef; + + /// Convert to `Any` + fn as_any(&self) -> &Any { + unimplemented!() + } + + /// Is value non-zero? + fn is_non_zero(&self) -> bool { + self.as_ref().is_non_zero() + } + + /// Return `ProtobufValueRef` if self is `Copy`. + /// + /// # Panics + /// + /// if `Self` is not `Copy`. + fn as_ref_copy(&self) -> ReflectValueRef<'static> +//where Self : Copy // TODO + { + match self.as_ref() { + ReflectValueRef::Bool(v) => ReflectValueRef::Bool(v), + ReflectValueRef::U32(v) => ReflectValueRef::U32(v), + ReflectValueRef::U64(v) => ReflectValueRef::U64(v), + ReflectValueRef::I32(v) => ReflectValueRef::I32(v), + ReflectValueRef::I64(v) => ReflectValueRef::I64(v), + ReflectValueRef::F32(v) => ReflectValueRef::F32(v), + ReflectValueRef::F64(v) => ReflectValueRef::F64(v), + ReflectValueRef::Enum(v) => ReflectValueRef::Enum(v), + ReflectValueRef::String(..) + | ReflectValueRef::Bytes(..) + | ReflectValueRef::Message(..) => unreachable!(), + } + } +} + +impl ProtobufValue for u32 { + fn as_ref(&self) -> ReflectValueRef { + ReflectValueRef::U32(*self) + } +} + +impl ProtobufValue for u64 { + fn as_ref(&self) -> ReflectValueRef { + ReflectValueRef::U64(*self) + } +} + +impl ProtobufValue for i32 { + fn as_ref(&self) -> ReflectValueRef { + ReflectValueRef::I32(*self) + } +} + +impl ProtobufValue for i64 { + fn as_ref(&self) -> ReflectValueRef { + ReflectValueRef::I64(*self) + } +} + +impl ProtobufValue for f32 { + fn as_ref(&self) -> ReflectValueRef { + ReflectValueRef::F32(*self) + } +} + +impl ProtobufValue for f64 { + fn as_ref(&self) -> ReflectValueRef { + ReflectValueRef::F64(*self) + } +} + +impl ProtobufValue for bool { + fn as_ref(&self) -> ReflectValueRef { + ReflectValueRef::Bool(*self) + } +} + +impl ProtobufValue for String { + fn as_ref(&self) -> ReflectValueRef { + ReflectValueRef::String(*&self) + } +} + +impl ProtobufValue for str { + fn as_ref(&self) -> ReflectValueRef { + ReflectValueRef::String(self) + } +} + +impl ProtobufValue for Vec<u8> { + fn as_ref(&self) -> ReflectValueRef { + ReflectValueRef::Bytes(*&self) + } +} + +#[cfg(feature = "bytes")] +impl ProtobufValue for Bytes { + fn as_ref(&self) -> ReflectValueRef { + ReflectValueRef::Bytes(&*self) + } +} + +#[cfg(feature = "bytes")] +impl ProtobufValue for Chars { + fn as_ref(&self) -> ReflectValueRef { + ReflectValueRef::String(&*self) + } +} + +// conflicting implementations, so generated code is used instead +/* +impl<E : ProtobufEnum> ProtobufValue for E { + fn as_ref(&self) -> ProtobufValueRef { + ProtobufValueRef::Enum(self.descriptor()) + } +} + +impl<M : Message> ProtobufValue for M { + fn as_ref(&self) -> ProtobufValueRef { + ProtobufValueRef::Message(self) + } +} +*/ + +/// A reference to a value +#[derive(Debug)] +pub enum ReflectValueRef<'a> { + /// `u32` + U32(u32), + /// `u64` + U64(u64), + /// `i32` + I32(i32), + /// `i64` + I64(i64), + /// `f32` + F32(f32), + /// `f64` + F64(f64), + /// `bool` + Bool(bool), + /// `string` + String(&'a str), + /// `bytes` + Bytes(&'a [u8]), + /// `enum` + // TODO: change to (i32, EnumDescriptor) + Enum(&'static EnumValueDescriptor), + /// `message` + Message(&'a dyn Message), +} + +impl<'a> ReflectValueRef<'a> { + /// Value is "non-zero"? + #[doc(hidden)] + pub fn is_non_zero(&self) -> bool { + match *self { + ReflectValueRef::U32(v) => v != 0, + ReflectValueRef::U64(v) => v != 0, + ReflectValueRef::I32(v) => v != 0, + ReflectValueRef::I64(v) => v != 0, + ReflectValueRef::F32(v) => v != 0., + ReflectValueRef::F64(v) => v != 0., + ReflectValueRef::Bool(v) => v, + ReflectValueRef::String(v) => !v.is_empty(), + ReflectValueRef::Bytes(v) => !v.is_empty(), + ReflectValueRef::Enum(v) => v.value() != 0, + ReflectValueRef::Message(_) => true, + } + } +} diff --git a/src/repeated.rs b/src/repeated.rs new file mode 100644 index 0000000..e5072cf --- /dev/null +++ b/src/repeated.rs @@ -0,0 +1,468 @@ +#[cfg(feature = "with-serde")] +use serde; + +use std::borrow::Borrow; +use std::cmp::Ordering; +use std::default::Default; +use std::fmt; +use std::hash::Hash; +use std::hash::Hasher; +use std::iter::FromIterator; +use std::iter::IntoIterator; +use std::ops::Deref; +use std::ops::DerefMut; +use std::ops::Index; +use std::ops::IndexMut; +use std::slice; +use std::vec; + +use clear::Clear; + +/// Wrapper around vector to avoid deallocations on clear. +pub struct RepeatedField<T> { + vec: Vec<T>, + len: usize, +} + +impl<T> RepeatedField<T> { + /// Return number of elements in this container. + #[inline] + pub fn len(&self) -> usize { + self.len + } + + /// Clear. + #[inline] + pub fn clear(&mut self) { + self.len = 0; + } +} + +impl<T> Clear for RepeatedField<T> { + #[inline] + fn clear(&mut self) { + self.len = 0; + } +} + +impl<T> Default for RepeatedField<T> { + #[inline] + fn default() -> RepeatedField<T> { + RepeatedField { + vec: Vec::new(), + len: 0, + } + } +} + +impl<T> RepeatedField<T> { + /// Create new empty container. + #[inline] + pub fn new() -> RepeatedField<T> { + Default::default() + } + + /// Create a contained with data from given vec. + #[inline] + pub fn from_vec(vec: Vec<T>) -> RepeatedField<T> { + let len = vec.len(); + RepeatedField { vec: vec, len: len } + } + + /// Convert data into vec. + #[inline] + pub fn into_vec(self) -> Vec<T> { + let mut vec = self.vec; + vec.truncate(self.len); + vec + } + + /// Return current capacity. + #[inline] + pub fn capacity(&self) -> usize { + self.vec.capacity() + } + + /// View data as slice. + #[inline] + pub fn as_slice<'a>(&'a self) -> &'a [T] { + &self.vec[..self.len] + } + + /// View data as mutable slice. + #[inline] + pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] { + &mut self.vec[..self.len] + } + + /// Get subslice of this container. + #[inline] + pub fn slice(&self, start: usize, end: usize) -> &[T] { + &self.as_ref()[start..end] + } + + /// Get mutable subslice of this container. + #[inline] + pub fn slice_mut(&mut self, start: usize, end: usize) -> &mut [T] { + &mut self.as_mut_slice()[start..end] + } + + /// Get slice from given index. + #[inline] + pub fn slice_from(&self, start: usize) -> &[T] { + &self.as_ref()[start..] + } + + /// Get mutable slice from given index. + #[inline] + pub fn slice_from_mut(&mut self, start: usize) -> &mut [T] { + &mut self.as_mut_slice()[start..] + } + + /// Get slice to given index. + #[inline] + pub fn slice_to(&self, end: usize) -> &[T] { + &self.as_ref()[..end] + } + + /// Get mutable slice to given index. + #[inline] + pub fn slice_to_mut(&mut self, end: usize) -> &mut [T] { + &mut self.as_mut_slice()[..end] + } + + /// View this container as two slices split at given index. + #[inline] + pub fn split_at<'a>(&'a self, mid: usize) -> (&'a [T], &'a [T]) { + self.as_ref().split_at(mid) + } + + /// View this container as two mutable slices split at given index. + #[inline] + pub fn split_at_mut<'a>(&'a mut self, mid: usize) -> (&'a mut [T], &'a mut [T]) { + self.as_mut_slice().split_at_mut(mid) + } + + /// View all but first elements of this container. + #[inline] + pub fn tail(&self) -> &[T] { + &self.as_ref()[1..] + } + + /// Last element of this container. + #[inline] + pub fn last(&self) -> Option<&T> { + self.as_ref().last() + } + + /// Mutable last element of this container. + #[inline] + pub fn last_mut<'a>(&'a mut self) -> Option<&'a mut T> { + self.as_mut_slice().last_mut() + } + + /// View all but last elements of this container. + #[inline] + pub fn init<'a>(&'a self) -> &'a [T] { + let s = self.as_ref(); + &s[0..s.len() - 1] + } + + /// Push an element to the end. + #[inline] + pub fn push(&mut self, value: T) { + if self.len == self.vec.len() { + self.vec.push(value); + } else { + self.vec[self.len] = value; + } + self.len += 1; + } + + /// Pop last element. + #[inline] + pub fn pop(&mut self) -> Option<T> { + if self.len == 0 { + None + } else { + self.vec.truncate(self.len); + self.len -= 1; + self.vec.pop() + } + } + + /// Insert an element at specified position. + #[inline] + pub fn insert(&mut self, index: usize, value: T) { + assert!(index <= self.len); + self.vec.insert(index, value); + self.len += 1; + } + + /// Remove an element from specified position. + #[inline] + pub fn remove(&mut self, index: usize) -> T { + assert!(index < self.len); + self.len -= 1; + self.vec.remove(index) + } + + /// Truncate at specified length. + #[inline] + pub fn truncate(&mut self, len: usize) { + if self.len > len { + self.len = len; + } + } + + /// Reverse in place. + #[inline] + pub fn reverse(&mut self) { + self.as_mut_slice().reverse() + } + + /// Into owned iterator. + #[inline] + pub fn into_iter(mut self) -> vec::IntoIter<T> { + self.vec.truncate(self.len); + self.vec.into_iter() + } + + /// Immutable data iterator. + #[inline] + pub fn iter<'a>(&'a self) -> slice::Iter<'a, T> { + self.as_ref().iter() + } + + /// Mutable data iterator. + #[inline] + pub fn iter_mut<'a>(&'a mut self) -> slice::IterMut<'a, T> { + self.as_mut_slice().iter_mut() + } + + /// Sort elements with given comparator. + #[inline] + pub fn sort_by<F>(&mut self, compare: F) + where + F: Fn(&T, &T) -> Ordering, + { + self.as_mut_slice().sort_by(compare) + } + + /// Get data as raw pointer. + #[inline] + pub fn as_ptr(&self) -> *const T { + self.vec.as_ptr() + } + + /// Get data a mutable raw pointer. + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self.vec.as_mut_ptr() + } +} + +impl<T: Default + Clear> RepeatedField<T> { + /// Push default value. + /// This operation could be faster than `rf.push(Default::default())`, + /// because it may reuse previously allocated and cleared element. + pub fn push_default<'a>(&'a mut self) -> &'a mut T { + if self.len == self.vec.len() { + self.vec.push(Default::default()); + } else { + self.vec[self.len].clear(); + } + self.len += 1; + self.last_mut().unwrap() + } +} + +impl<T> From<Vec<T>> for RepeatedField<T> { + #[inline] + fn from(values: Vec<T>) -> RepeatedField<T> { + RepeatedField::from_vec(values) + } +} + +impl<'a, T: Clone> From<&'a [T]> for RepeatedField<T> { + #[inline] + fn from(values: &'a [T]) -> RepeatedField<T> { + RepeatedField::from_slice(values) + } +} + +impl<T> Into<Vec<T>> for RepeatedField<T> { + #[inline] + fn into(self) -> Vec<T> { + self.into_vec() + } +} + +impl<T: Clone> RepeatedField<T> { + /// Copy slice data to `RepeatedField` + #[inline] + pub fn from_slice(values: &[T]) -> RepeatedField<T> { + RepeatedField::from_vec(values.to_vec()) + } + + /// Copy slice data to `RepeatedField` + #[inline] + pub fn from_ref<X: AsRef<[T]>>(values: X) -> RepeatedField<T> { + RepeatedField::from_slice(values.as_ref()) + } + + /// Copy this data into new vec. + #[inline] + pub fn to_vec(&self) -> Vec<T> { + self.as_ref().to_vec() + } +} + +impl<T: Clone> Clone for RepeatedField<T> { + #[inline] + fn clone(&self) -> RepeatedField<T> { + RepeatedField { + vec: self.to_vec(), + len: self.len(), + } + } +} + +impl<T> FromIterator<T> for RepeatedField<T> { + #[inline] + fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> RepeatedField<T> { + RepeatedField::from_vec(FromIterator::from_iter(iter)) + } +} + +impl<'a, T> IntoIterator for &'a RepeatedField<T> { + type Item = &'a T; + type IntoIter = slice::Iter<'a, T>; + + fn into_iter(self) -> slice::Iter<'a, T> { + self.iter() + } +} + +impl<T: PartialEq> PartialEq for RepeatedField<T> { + #[inline] + fn eq(&self, other: &RepeatedField<T>) -> bool { + self.as_ref() == other.as_ref() + } +} + +impl<T: Eq> Eq for RepeatedField<T> {} + +impl<T: PartialEq> RepeatedField<T> { + /// True iff this container contains given element. + #[inline] + pub fn contains(&self, value: &T) -> bool { + self.as_ref().contains(value) + } +} + +impl<T: Hash> Hash for RepeatedField<T> { + fn hash<H: Hasher>(&self, state: &mut H) { + self.as_ref().hash(state); + } +} + +impl<T> AsRef<[T]> for RepeatedField<T> { + #[inline] + fn as_ref<'a>(&'a self) -> &'a [T] { + &self.vec[..self.len] + } +} + +impl<T> Borrow<[T]> for RepeatedField<T> { + #[inline] + fn borrow(&self) -> &[T] { + &self.vec[..self.len] + } +} + +impl<T> Deref for RepeatedField<T> { + type Target = [T]; + #[inline] + fn deref(&self) -> &[T] { + &self.vec[..self.len] + } +} + +impl<T> DerefMut for RepeatedField<T> { + #[inline] + fn deref_mut(&mut self) -> &mut [T] { + &mut self.vec[..self.len] + } +} + +impl<T> Index<usize> for RepeatedField<T> { + type Output = T; + + #[inline] + fn index<'a>(&'a self, index: usize) -> &'a T { + &self.as_ref()[index] + } +} + +impl<T> IndexMut<usize> for RepeatedField<T> { + #[inline] + fn index_mut<'a>(&'a mut self, index: usize) -> &'a mut T { + &mut self.as_mut_slice()[index] + } +} + +impl<T: fmt::Debug> fmt::Debug for RepeatedField<T> { + #[inline] + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + self.as_ref().fmt(f) + } +} + +#[cfg(feature = "with-serde")] +impl<T: serde::Serialize> serde::Serialize for RepeatedField<T> { + fn serialize<S>( + &self, + serializer: S, + ) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error> + where + S: serde::Serializer, + { + self.as_ref().serialize(serializer) + } +} + +#[cfg(feature = "with-serde")] +impl<'de, T: serde::Deserialize<'de> + Default> serde::Deserialize<'de> for RepeatedField<T> { + fn deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deserializer<'de>>::Error> + where + D: serde::Deserializer<'de>, + { + Vec::deserialize(deserializer).map(RepeatedField::from) + } +} + +#[cfg(test)] +mod test { + use super::RepeatedField; + + #[test] + fn as_mut_slice() { + let mut v = RepeatedField::new(); + v.push(10); + v.push(20); + v.clear(); + assert_eq!(v.as_mut_slice(), &mut []); + v.push(30); + assert_eq!(v.as_mut_slice(), &mut [30]); + } + + #[test] + fn push_default() { + let mut v = RepeatedField::new(); + v.push("aa".to_string()); + v.push("bb".to_string()); + v.clear(); + assert_eq!("".to_string(), *v.push_default()); + } +} diff --git a/src/rt.rs b/src/rt.rs new file mode 100644 index 0000000..312bb4f --- /dev/null +++ b/src/rt.rs @@ -0,0 +1,933 @@ +//! Functions used by generated protobuf code. +//! Should not be used by programs written by hands. + +use std::collections::HashMap; +use std::default::Default; +use std::hash::Hash; + +#[cfg(feature = "bytes")] +use bytes::Bytes; +#[cfg(feature = "bytes")] +use chars::Chars; + +use core::*; +use enums::ProtobufEnum; +use error::ProtobufError; +use error::ProtobufResult; +use error::WireError; +use repeated::RepeatedField; +use singular::SingularField; +use singular::SingularPtrField; +use stream::wire_format; +use stream::wire_format::WireType; +use stream::wire_format::WireTypeFixed32; +use stream::wire_format::WireTypeFixed64; +use stream::wire_format::WireTypeLengthDelimited; +use stream::wire_format::WireTypeVarint; +use stream::CodedInputStream; +use stream::CodedOutputStream; +use types::*; +use zigzag::*; + +use unknown::UnknownFields; + +/// Given `u64` value compute varint encoded length. +pub fn compute_raw_varint64_size(value: u64) -> u32 { + if (value & (0xffffffffffffffffu64 << 7)) == 0 { + return 1; + } + if (value & (0xffffffffffffffffu64 << 14)) == 0 { + return 2; + } + if (value & (0xffffffffffffffffu64 << 21)) == 0 { + return 3; + } + if (value & (0xffffffffffffffffu64 << 28)) == 0 { + return 4; + } + if (value & (0xffffffffffffffffu64 << 35)) == 0 { + return 5; + } + if (value & (0xffffffffffffffffu64 << 42)) == 0 { + return 6; + } + if (value & (0xffffffffffffffffu64 << 49)) == 0 { + return 7; + } + if (value & (0xffffffffffffffffu64 << 56)) == 0 { + return 8; + } + if (value & (0xffffffffffffffffu64 << 63)) == 0 { + return 9; + } + 10 +} + +/// Given `u32` value compute varint encoded length. +pub fn compute_raw_varint32_size(value: u32) -> u32 { + compute_raw_varint64_size(value as u64) +} + +/// Helper trait implemented by integer types which could be encoded as varint. +pub trait ProtobufVarint { + /// Size of self when encoded as varint. + fn len_varint(&self) -> u32; +} + +/// Helper trait implemented by integer types which could be encoded as zigzag varint. +pub trait ProtobufVarintZigzag { + /// Size of self when encoded as zigzag varint. + fn len_varint_zigzag(&self) -> u32; +} + +impl ProtobufVarint for u64 { + fn len_varint(&self) -> u32 { + compute_raw_varint64_size(*self) + } +} + +impl ProtobufVarint for u32 { + fn len_varint(&self) -> u32 { + (*self as u64).len_varint() + } +} + +impl ProtobufVarint for i64 { + fn len_varint(&self) -> u32 { + // same as length of u64 + (*self as u64).len_varint() + } +} + +impl ProtobufVarintZigzag for i64 { + fn len_varint_zigzag(&self) -> u32 { + compute_raw_varint64_size(encode_zig_zag_64(*self)) + } +} + +impl ProtobufVarint for i32 { + fn len_varint(&self) -> u32 { + // sign-extend and then compute + (*self as i64).len_varint() + } +} + +impl ProtobufVarintZigzag for i32 { + fn len_varint_zigzag(&self) -> u32 { + compute_raw_varint32_size(encode_zig_zag_32(*self)) + } +} + +impl ProtobufVarint for bool { + fn len_varint(&self) -> u32 { + 1 + } +} + +/* Commented out due to https://github.com/mozilla/rust/issues/8075 +impl<E:ProtobufEnum> ProtobufVarint for E { + fn len_varint(&self) -> u32 { + self.value().len_varint() + } +} +*/ + +/// Size of serialized repeated packed field, excluding length and tag. +pub fn vec_packed_varint_data_size<T: ProtobufVarint>(vec: &[T]) -> u32 { + vec.iter().map(|v| v.len_varint()).fold(0, |a, i| a + i) +} + +/// Size of serialized repeated packed field, excluding length and tag. +pub fn vec_packed_varint_zigzag_data_size<T: ProtobufVarintZigzag>(vec: &[T]) -> u32 { + vec.iter() + .map(|v| v.len_varint_zigzag()) + .fold(0, |a, i| a + i) +} + +/// Size of serialized repeated packed enum field, excluding length and tag. +pub fn vec_packed_enum_data_size<E: ProtobufEnum>(vec: &[E]) -> u32 { + vec.iter() + .map(|e| compute_raw_varint32_size(e.value() as u32)) + .fold(0, |a, i| a + i) +} + +/// Size of serialized data with length prefix and tag +pub fn vec_packed_varint_size<T: ProtobufVarint>(field_number: u32, vec: &[T]) -> u32 { + if vec.is_empty() { + 0 + } else { + let data_size = vec_packed_varint_data_size(vec); + tag_size(field_number) + data_size.len_varint() + data_size + } +} + +/// Size of serialized data with length prefix and tag +pub fn vec_packed_varint_zigzag_size<T: ProtobufVarintZigzag>(field_number: u32, vec: &[T]) -> u32 { + if vec.is_empty() { + 0 + } else { + let data_size = vec_packed_varint_zigzag_data_size(vec); + tag_size(field_number) + data_size.len_varint() + data_size + } +} + +/// Size of serialized data with length prefix and tag +pub fn vec_packed_enum_size<E: ProtobufEnum>(field_number: u32, vec: &[E]) -> u32 { + if vec.is_empty() { + 0 + } else { + let data_size = vec_packed_enum_data_size(vec); + tag_size(field_number) + data_size.len_varint() + data_size + } +} + +/// Compute tag size. Size of tag does not depend on wire type. +pub fn tag_size(field_number: u32) -> u32 { + wire_format::Tag::make(field_number, WireTypeFixed64) + .value() + .len_varint() +} + +fn value_size_no_tag<T: ProtobufVarint>(value: T, wt: WireType) -> u32 { + match wt { + WireTypeFixed64 => 8, + WireTypeFixed32 => 4, + WireTypeVarint => value.len_varint(), + _ => panic!(), + } +} + +/// Integer value size when encoded as specified wire type. +pub fn value_size<T: ProtobufVarint>(field_number: u32, value: T, wt: WireType) -> u32 { + tag_size(field_number) + value_size_no_tag(value, wt) +} + +/// Integer value size when encoded as specified wire type. +pub fn value_varint_zigzag_size_no_tag<T: ProtobufVarintZigzag>(value: T) -> u32 { + value.len_varint_zigzag() +} + +/// Length of value when encoding with zigzag encoding with tag +pub fn value_varint_zigzag_size<T: ProtobufVarintZigzag>(field_number: u32, value: T) -> u32 { + tag_size(field_number) + value_varint_zigzag_size_no_tag(value) +} + +fn enum_size_no_tag<E: ProtobufEnum>(value: E) -> u32 { + value.value().len_varint() +} + +/// Size of encoded enum field value. +pub fn enum_size<E: ProtobufEnum>(field_number: u32, value: E) -> u32 { + tag_size(field_number) + enum_size_no_tag(value) +} + +fn bytes_size_no_tag(bytes: &[u8]) -> u32 { + compute_raw_varint64_size(bytes.len() as u64) + bytes.len() as u32 +} + +/// Size of encoded bytes field. +pub fn bytes_size(field_number: u32, bytes: &[u8]) -> u32 { + tag_size(field_number) + bytes_size_no_tag(bytes) +} + +fn string_size_no_tag(s: &str) -> u32 { + bytes_size_no_tag(s.as_bytes()) +} + +/// Size of encoded string field. +pub fn string_size(field_number: u32, s: &str) -> u32 { + tag_size(field_number) + string_size_no_tag(s) +} + +/// Size of encoded unknown fields size. +pub fn unknown_fields_size(unknown_fields: &UnknownFields) -> u32 { + let mut r = 0; + for (number, values) in unknown_fields { + r += (tag_size(number) + 4) * values.fixed32.len() as u32; + r += (tag_size(number) + 8) * values.fixed64.len() as u32; + + r += tag_size(number) * values.varint.len() as u32; + for varint in &values.varint { + r += varint.len_varint(); + } + + r += tag_size(number) * values.length_delimited.len() as u32; + for bytes in &values.length_delimited { + r += bytes_size_no_tag(&bytes); + } + } + r +} + +/// Read repeated `int32` field into given vec. +pub fn read_repeated_int32_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<i32>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_int32_into(target), + WireTypeVarint => { + target.push(is.read_int32()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `int64` field into given vec. +pub fn read_repeated_int64_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<i64>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_int64_into(target), + WireTypeVarint => { + target.push(is.read_int64()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `uint32` field into given vec. +pub fn read_repeated_uint32_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<u32>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_uint32_into(target), + WireTypeVarint => { + target.push(is.read_uint32()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `uint64` field into given vec. +pub fn read_repeated_uint64_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<u64>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_uint64_into(target), + WireTypeVarint => { + target.push(is.read_uint64()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `sint32` field into given vec. +pub fn read_repeated_sint32_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<i32>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_sint32_into(target), + WireTypeVarint => { + target.push(is.read_sint32()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `sint64` field into given vec. +pub fn read_repeated_sint64_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<i64>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_sint64_into(target), + WireTypeVarint => { + target.push(is.read_sint64()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `fixed32` field into given vec. +pub fn read_repeated_fixed32_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<u32>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_fixed32_into(target), + WireTypeFixed32 => { + target.push(is.read_fixed32()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `fixed64` field into given vec. +pub fn read_repeated_fixed64_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<u64>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_fixed64_into(target), + WireTypeFixed64 => { + target.push(is.read_fixed64()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `sfixed32` field into given vec. +pub fn read_repeated_sfixed32_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<i32>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_sfixed32_into(target), + WireTypeFixed32 => { + target.push(is.read_sfixed32()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `sfixed64` field into given vec. +pub fn read_repeated_sfixed64_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<i64>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_sfixed64_into(target), + WireTypeFixed64 => { + target.push(is.read_sfixed64()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `double` field into given vec. +pub fn read_repeated_double_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<f64>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_double_into(target), + WireTypeFixed64 => { + target.push(is.read_double()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `float` field into given vec. +pub fn read_repeated_float_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<f32>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_float_into(target), + WireTypeFixed32 => { + target.push(is.read_float()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `bool` field into given vec. +pub fn read_repeated_bool_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<bool>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_bool_into(target), + WireTypeVarint => { + target.push(is.read_bool()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `enum` field into given vec. +/// This function is no longer called from generated code, remove in 1.5. +pub fn read_repeated_enum_into<E: ProtobufEnum>( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<E>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_repeated_packed_enum_into(target), + WireTypeVarint => { + target.push(is.read_enum()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Helper function to read single enum value. +#[inline] +fn read_enum_with_unknown_fields_into<E: ProtobufEnum, C>( + is: &mut CodedInputStream, + target: C, + field_number: u32, + unknown_fields: &mut UnknownFields, +) -> ProtobufResult<()> +where + C: FnOnce(E), +{ + let i = is.read_int32()?; + match ProtobufEnum::from_i32(i) { + Some(e) => target(e), + None => unknown_fields.add_varint(field_number, i as i64 as u64), + } + Ok(()) +} + +fn read_repeated_packed_enum_with_unknown_fields_into<E: ProtobufEnum>( + is: &mut CodedInputStream, + target: &mut Vec<E>, + field_number: u32, + unknown_fields: &mut UnknownFields, +) -> ProtobufResult<()> { + let len = is.read_raw_varint64()?; + let old_limit = is.push_limit(len)?; + while !is.eof()? { + read_enum_with_unknown_fields_into(is, |e| target.push(e), field_number, unknown_fields)?; + } + is.pop_limit(old_limit); + Ok(()) +} + +/// Read repeated `enum` field into given vec, +/// and when value is unknown store it in unknown fields +/// which matches proto2 spec. +/// +/// See explanation +/// [here](https://github.com/stepancheg/rust-protobuf/issues/233#issuecomment-375142710) +pub fn read_repeated_enum_with_unknown_fields_into<E: ProtobufEnum>( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<E>, + field_number: u32, + unknown_fields: &mut UnknownFields, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => read_repeated_packed_enum_with_unknown_fields_into( + is, + target, + field_number, + unknown_fields, + ), + WireTypeVarint => { + read_enum_with_unknown_fields_into(is, |e| target.push(e), field_number, unknown_fields) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `enum` field into given vec, +/// and when value is unknown store it in unknown fields +/// which matches proto2 spec. +/// +/// See explanation +/// [here](https://github.com/stepancheg/rust-protobuf/issues/233#issuecomment-375142710) +pub fn read_proto3_enum_with_unknown_fields_into<E: ProtobufEnum>( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut E, + field_number: u32, + unknown_fields: &mut UnknownFields, +) -> ProtobufResult<()> { + if wire_type != WireType::WireTypeVarint { + return Err(unexpected_wire_type(wire_type)); + } + + read_enum_with_unknown_fields_into(is, |e| *target = e, field_number, unknown_fields) +} + +/// Read repeated `enum` field into given vec, +/// and when value is unknown store it in unknown fields +/// which matches proto2 spec. +/// +/// See explanation +/// [here](https://github.com/stepancheg/rust-protobuf/issues/233#issuecomment-375142710) +pub fn read_proto2_enum_with_unknown_fields_into<E: ProtobufEnum>( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Option<E>, + field_number: u32, + unknown_fields: &mut UnknownFields, +) -> ProtobufResult<()> { + if wire_type != WireType::WireTypeVarint { + return Err(unexpected_wire_type(wire_type)); + } + + read_enum_with_unknown_fields_into(is, |e| *target = Some(e), field_number, unknown_fields) +} + +/// Read repeated `string` field into given vec. +pub fn read_repeated_string_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut RepeatedField<String>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => { + let tmp = target.push_default(); + is.read_string_into(tmp) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `Chars` field into given vec. +#[cfg(feature = "bytes")] +pub fn read_repeated_carllerche_string_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<Chars>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => { + target.push(is.read_carllerche_chars()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read singular `string` field. +pub fn read_singular_string_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut SingularField<String>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => { + let tmp = target.set_default(); + is.read_string_into(tmp) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read singular `Chars` field. +#[cfg(feature = "bytes")] +pub fn read_singular_carllerche_string_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Option<Chars>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => { + *target = Some(is.read_carllerche_chars()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read singular `string` field for proto3. +pub fn read_singular_proto3_string_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut String, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_string_into(target), + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read singular `Chars` field for proto3. +#[cfg(feature = "bytes")] +pub fn read_singular_proto3_carllerche_string_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Chars, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => { + *target = is.read_carllerche_chars()?; + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `bytes` field into given vec. +pub fn read_repeated_bytes_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut RepeatedField<Vec<u8>>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => { + let tmp = target.push_default(); + is.read_bytes_into(tmp) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `Bytes` field into given vec. +#[cfg(feature = "bytes")] +pub fn read_repeated_carllerche_bytes_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<Bytes>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => { + target.push(is.read_carllerche_bytes()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read singular `bytes` field. +pub fn read_singular_bytes_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut SingularField<Vec<u8>>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => { + let tmp = target.set_default(); + is.read_bytes_into(tmp) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read singular `Bytes` field. +#[cfg(feature = "bytes")] +pub fn read_singular_carllerche_bytes_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Option<Bytes>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => { + *target = Some(is.read_carllerche_bytes()?); + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read singular `bytes` field for proto3. +pub fn read_singular_proto3_bytes_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Vec<u8>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => is.read_bytes_into(target), + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read singular `Bytes` field for proto3. +#[cfg(feature = "bytes")] +pub fn read_singular_proto3_carllerche_bytes_into( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut Bytes, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => { + *target = is.read_carllerche_bytes()?; + Ok(()) + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read repeated `message` field. +pub fn read_repeated_message_into<M: Message + Default>( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut RepeatedField<M>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => { + is.incr_recursion()?; + let tmp = target.push_default(); + let res = is.merge_message(tmp); + is.decr_recursion(); + res + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +/// Read singular `message` field. +pub fn read_singular_message_into<M: Message + Default>( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut SingularPtrField<M>, +) -> ProtobufResult<()> { + match wire_type { + WireTypeLengthDelimited => { + is.incr_recursion()?; + let tmp = target.set_default(); + let res = is.merge_message(tmp); + is.decr_recursion(); + res + } + _ => Err(unexpected_wire_type(wire_type)), + } +} + +fn skip_group(is: &mut CodedInputStream) -> ProtobufResult<()> { + loop { + let (_, wire_type) = is.read_tag_unpack()?; + if wire_type == wire_format::WireTypeEndGroup { + return Ok(()); + } + is.skip_field(wire_type)?; + } +} + +/// Handle unknown field in generated code. +/// Either store a value in unknown, or skip a group. +pub fn read_unknown_or_skip_group( + field_number: u32, + wire_type: WireType, + is: &mut CodedInputStream, + unknown_fields: &mut UnknownFields, +) -> ProtobufResult<()> { + match wire_type { + wire_format::WireTypeStartGroup => skip_group(is), + _ => { + let unknown = is.read_unknown(wire_type)?; + unknown_fields.add_value(field_number, unknown); + Ok(()) + } + } +} + +/// Create an error for unexpected wire type. +/// +/// Function is used in generated code, so error types can be changed, +/// but this function remains unchanged. +pub fn unexpected_wire_type(wire_type: WireType) -> ProtobufError { + ProtobufError::WireError(WireError::UnexpectedWireType(wire_type)) +} + +/// Compute serialized size of `map` field and cache nested field sizes. +pub fn compute_map_size<K, V>(field_number: u32, map: &HashMap<K::Value, V::Value>) -> u32 +where + K: ProtobufType, + V: ProtobufType, + K::Value: Eq + Hash, +{ + let mut sum = 0; + for (k, v) in map { + let key_tag_size = 1; + let value_tag_size = 1; + + let key_len = K::compute_size_with_length_delimiter(k); + let value_len = V::compute_size_with_length_delimiter(v); + + let entry_len = key_tag_size + key_len + value_tag_size + value_len; + sum += tag_size(field_number) + compute_raw_varint32_size(entry_len) + entry_len; + } + sum +} + +/// Write map, message sizes must be already known. +pub fn write_map_with_cached_sizes<K, V>( + field_number: u32, + map: &HashMap<K::Value, V::Value>, + os: &mut CodedOutputStream, +) -> ProtobufResult<()> +where + K: ProtobufType, + V: ProtobufType, + K::Value: Eq + Hash, +{ + for (k, v) in map { + let key_tag_size = 1; + let value_tag_size = 1; + + let key_len = K::get_cached_size_with_length_delimiter(k); + let value_len = V::get_cached_size_with_length_delimiter(v); + + let entry_len = key_tag_size + key_len + value_tag_size + value_len; + + os.write_tag(field_number, WireType::WireTypeLengthDelimited)?; + os.write_raw_varint32(entry_len)?; + K::write_with_cached_size(1, k, os)?; + V::write_with_cached_size(2, v, os)?; + } + Ok(()) +} + +/// Read `map` field. +pub fn read_map_into<K, V>( + wire_type: WireType, + is: &mut CodedInputStream, + target: &mut HashMap<K::Value, V::Value>, +) -> ProtobufResult<()> +where + K: ProtobufType, + V: ProtobufType, + K::Value: Eq + Hash + Default, + V::Value: Default, +{ + if wire_type != WireType::WireTypeLengthDelimited { + return Err(unexpected_wire_type(wire_type)); + } + + let mut key = Default::default(); + let mut value = Default::default(); + + let len = is.read_raw_varint32()?; + let old_limit = is.push_limit(len as u64)?; + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != K::wire_type() { + return Err(unexpected_wire_type(wire_type)); + } + key = K::read(is)?; + } + 2 => { + if wire_type != V::wire_type() { + return Err(unexpected_wire_type(wire_type)); + } + value = V::read(is)?; + } + _ => is.skip_field(wire_type)?, + } + } + is.pop_limit(old_limit); + + target.insert(key, value); + + Ok(()) +} diff --git a/src/rust.rs b/src/rust.rs new file mode 100644 index 0000000..9d4995b --- /dev/null +++ b/src/rust.rs @@ -0,0 +1,121 @@ +#[cfg_attr(rustfmt, rustfmt_skip)] +static RUST_KEYWORDS: &'static [&'static str] = &[ + "as", + "async", + "await", + "break", + "crate", + "dyn", + "else", + "enum", + "extern", + "false", + "fn", + "for", + "if", + "impl", + "in", + "let", + "loop", + "match", + "mod", + "move", + "mut", + "pub", + "ref", + "return", + "static", + "self", + "Self", + "struct", + "super", + "true", + "trait", + "type", + "unsafe", + "use", + "while", + "continue", + "box", + "const", + "where", + "virtual", + "proc", + "alignof", + "become", + "offsetof", + "priv", + "pure", + "sizeof", + "typeof", + "unsized", + "yield", + "do", + "abstract", + "final", + "override", + "macro", +]; + +pub fn is_rust_keyword(ident: &str) -> bool { + RUST_KEYWORDS.contains(&ident) +} + +fn hex_digit(value: u32) -> char { + if value < 10 { + (b'0' + value as u8) as char + } else if value < 0x10 { + (b'a' + value as u8 - 10) as char + } else { + unreachable!() + } +} + +pub fn quote_escape_str(s: &str) -> String { + let mut buf = String::new(); + buf.push('"'); + buf.extend(s.chars().flat_map(|c| c.escape_default())); + buf.push('"'); + buf +} + +pub fn quote_escape_bytes(bytes: &[u8]) -> String { + let mut buf = String::new(); + buf.push('b'); + buf.push('"'); + for &b in bytes { + match b { + b'\n' => buf.push_str(r"\n"), + b'\r' => buf.push_str(r"\r"), + b'\t' => buf.push_str(r"\t"), + b'"' => buf.push_str("\\\""), + b'\\' => buf.push_str(r"\\"), + b'\x20'..=b'\x7e' => buf.push(b as char), + _ => { + buf.push_str(r"\x"); + buf.push(hex_digit((b as u32) >> 4)); + buf.push(hex_digit((b as u32) & 0x0f)); + } + } + } + buf.push('"'); + buf +} + +#[cfg(test)] +mod test { + + use super::*; + + #[test] + fn test_quote_escape_bytes() { + assert_eq!("b\"\"", quote_escape_bytes(b"")); + assert_eq!("b\"xyZW\"", quote_escape_bytes(b"xyZW")); + assert_eq!("b\"aa\\\"bb\"", quote_escape_bytes(b"aa\"bb")); + assert_eq!("b\"aa\\r\\n\\tbb\"", quote_escape_bytes(b"aa\r\n\tbb")); + assert_eq!( + "b\"\\x00\\x01\\x12\\xfe\\xff\"", + quote_escape_bytes(b"\x00\x01\x12\xfe\xff") + ); + } +} diff --git a/src/rustproto.rs b/src/rustproto.rs new file mode 100644 index 0000000..92c2547 --- /dev/null +++ b/src/rustproto.rs @@ -0,0 +1,200 @@ +// This file is generated by rust-protobuf 2.14.0-pre. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `rustproto.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +pub mod exts { + use protobuf::Message as Message_imported_for_functions; + + pub const expose_oneof_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17001, phantom: ::std::marker::PhantomData }; + + pub const expose_fields_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17003, phantom: ::std::marker::PhantomData }; + + pub const generate_accessors_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17004, phantom: ::std::marker::PhantomData }; + + pub const carllerche_bytes_for_bytes_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17011, phantom: ::std::marker::PhantomData }; + + pub const carllerche_bytes_for_string_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17012, phantom: ::std::marker::PhantomData }; + + pub const serde_derive_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17030, phantom: ::std::marker::PhantomData }; + + pub const serde_derive_cfg_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeString> = ::protobuf::ext::ExtFieldOptional { field_number: 17031, phantom: ::std::marker::PhantomData }; + + pub const lite_runtime_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17035, phantom: ::std::marker::PhantomData }; + + pub const expose_oneof: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17001, phantom: ::std::marker::PhantomData }; + + pub const expose_fields: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17003, phantom: ::std::marker::PhantomData }; + + pub const generate_accessors: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17004, phantom: ::std::marker::PhantomData }; + + pub const carllerche_bytes_for_bytes: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17011, phantom: ::std::marker::PhantomData }; + + pub const carllerche_bytes_for_string: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17012, phantom: ::std::marker::PhantomData }; + + pub const serde_derive: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17030, phantom: ::std::marker::PhantomData }; + + pub const serde_derive_cfg: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeString> = ::protobuf::ext::ExtFieldOptional { field_number: 17031, phantom: ::std::marker::PhantomData }; + + pub const expose_fields_field: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FieldOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17003, phantom: ::std::marker::PhantomData }; + + pub const generate_accessors_field: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FieldOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17004, phantom: ::std::marker::PhantomData }; + + pub const carllerche_bytes_for_bytes_field: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FieldOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17011, phantom: ::std::marker::PhantomData }; + + pub const carllerche_bytes_for_string_field: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FieldOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17012, phantom: ::std::marker::PhantomData }; +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x0frustproto.proto\x12\trustproto\x1a\x20google/protobuf/descriptor.p\ + roto:H\n\x10expose_oneof_all\x18\xe9\x84\x01\x20\x01(\x08\x12\x1c.google\ + .protobuf.FileOptionsR\x0eexposeOneofAll:J\n\x11expose_fields_all\x18\ + \xeb\x84\x01\x20\x01(\x08\x12\x1c.google.protobuf.FileOptionsR\x0fexpose\ + FieldsAll:T\n\x16generate_accessors_all\x18\xec\x84\x01\x20\x01(\x08\x12\ + \x1c.google.protobuf.FileOptionsR\x14generateAccessorsAll:b\n\x1ecarller\ + che_bytes_for_bytes_all\x18\xf3\x84\x01\x20\x01(\x08\x12\x1c.google.prot\ + obuf.FileOptionsR\x1acarllercheBytesForBytesAll:d\n\x1fcarllerche_bytes_\ + for_string_all\x18\xf4\x84\x01\x20\x01(\x08\x12\x1c.google.protobuf.File\ + OptionsR\x1bcarllercheBytesForStringAll:H\n\x10serde_derive_all\x18\x86\ + \x85\x01\x20\x01(\x08\x12\x1c.google.protobuf.FileOptionsR\x0eserdeDeriv\ + eAll:O\n\x14serde_derive_cfg_all\x18\x87\x85\x01\x20\x01(\t\x12\x1c.goog\ + le.protobuf.FileOptionsR\x11serdeDeriveCfgAll:H\n\x10lite_runtime_all\ + \x18\x8b\x85\x01\x20\x01(\x08\x12\x1c.google.protobuf.FileOptionsR\x0eli\ + teRuntimeAll:D\n\x0cexpose_oneof\x18\xe9\x84\x01\x20\x01(\x08\x12\x1f.go\ + ogle.protobuf.MessageOptionsR\x0bexposeOneof:F\n\rexpose_fields\x18\xeb\ + \x84\x01\x20\x01(\x08\x12\x1f.google.protobuf.MessageOptionsR\x0cexposeF\ + ields:P\n\x12generate_accessors\x18\xec\x84\x01\x20\x01(\x08\x12\x1f.goo\ + gle.protobuf.MessageOptionsR\x11generateAccessors:^\n\x1acarllerche_byte\ + s_for_bytes\x18\xf3\x84\x01\x20\x01(\x08\x12\x1f.google.protobuf.Message\ + OptionsR\x17carllercheBytesForBytes:`\n\x1bcarllerche_bytes_for_string\ + \x18\xf4\x84\x01\x20\x01(\x08\x12\x1f.google.protobuf.MessageOptionsR\ + \x18carllercheBytesForString:D\n\x0cserde_derive\x18\x86\x85\x01\x20\x01\ + (\x08\x12\x1f.google.protobuf.MessageOptionsR\x0bserdeDerive:K\n\x10serd\ + e_derive_cfg\x18\x87\x85\x01\x20\x01(\t\x12\x1f.google.protobuf.MessageO\ + ptionsR\x0eserdeDeriveCfg:O\n\x13expose_fields_field\x18\xeb\x84\x01\x20\ + \x01(\x08\x12\x1d.google.protobuf.FieldOptionsR\x11exposeFieldsField:Y\n\ + \x18generate_accessors_field\x18\xec\x84\x01\x20\x01(\x08\x12\x1d.google\ + .protobuf.FieldOptionsR\x16generateAccessorsField:g\n\x20carllerche_byte\ + s_for_bytes_field\x18\xf3\x84\x01\x20\x01(\x08\x12\x1d.google.protobuf.F\ + ieldOptionsR\x1ccarllercheBytesForBytesField:i\n!carllerche_bytes_for_st\ + ring_field\x18\xf4\x84\x01\x20\x01(\x08\x12\x1d.google.protobuf.FieldOpt\ + ionsR\x1dcarllercheBytesForStringFieldJ\xf2\x13\n\x06\x12\x04\0\07\x01\n\ + \x08\n\x01\x0c\x12\x03\0\0\x12\n\t\n\x02\x03\0\x12\x03\x02\0*\nh\n\x01\ + \x02\x12\x03\x07\0\x122^\x20see\x20https://github.com/gogo/protobuf/blob\ + /master/gogoproto/gogo.proto\n\x20for\x20the\x20original\x20idea\n\n\t\n\ + \x01\x07\x12\x04\t\0\x1b\x01\n7\n\x02\x07\0\x12\x03\x0b\x04+\x1a,\x20Whe\ + n\x20true,\x20oneof\x20field\x20is\x20generated\x20public\n\n\n\n\x03\ + \x07\0\x02\x12\x03\t\x07\"\n\n\n\x03\x07\0\x04\x12\x03\x0b\x04\x0c\n\n\n\ + \x03\x07\0\x05\x12\x03\x0b\r\x11\n\n\n\x03\x07\0\x01\x12\x03\x0b\x12\"\n\ + \n\n\x03\x07\0\x03\x12\x03\x0b%*\nI\n\x02\x07\x01\x12\x03\r\x04,\x1a>\ + \x20When\x20true\x20all\x20fields\x20are\x20public,\x20and\x20not\x20acc\ + essors\x20generated\n\n\n\n\x03\x07\x01\x02\x12\x03\t\x07\"\n\n\n\x03\ + \x07\x01\x04\x12\x03\r\x04\x0c\n\n\n\x03\x07\x01\x05\x12\x03\r\r\x11\n\n\ + \n\x03\x07\x01\x01\x12\x03\r\x12#\n\n\n\x03\x07\x01\x03\x12\x03\r&+\nP\n\ + \x02\x07\x02\x12\x03\x0f\x041\x1aE\x20When\x20false,\x20`get_`,\x20`set_\ + `,\x20`mut_`\x20etc.\x20accessors\x20are\x20not\x20generated\n\n\n\n\x03\ + \x07\x02\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x02\x04\x12\x03\x0f\x04\x0c\n\ + \n\n\x03\x07\x02\x05\x12\x03\x0f\r\x11\n\n\n\x03\x07\x02\x01\x12\x03\x0f\ + \x12(\n\n\n\x03\x07\x02\x03\x12\x03\x0f+0\n2\n\x02\x07\x03\x12\x03\x11\ + \x049\x1a'\x20Use\x20`bytes::Bytes`\x20for\x20`bytes`\x20fields\n\n\n\n\ + \x03\x07\x03\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x03\x04\x12\x03\x11\x04\ + \x0c\n\n\n\x03\x07\x03\x05\x12\x03\x11\r\x11\n\n\n\x03\x07\x03\x01\x12\ + \x03\x11\x120\n\n\n\x03\x07\x03\x03\x12\x03\x1138\n3\n\x02\x07\x04\x12\ + \x03\x13\x04:\x1a(\x20Use\x20`bytes::Bytes`\x20for\x20`string`\x20fields\ + \n\n\n\n\x03\x07\x04\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x04\x04\x12\x03\ + \x13\x04\x0c\n\n\n\x03\x07\x04\x05\x12\x03\x13\r\x11\n\n\n\x03\x07\x04\ + \x01\x12\x03\x13\x121\n\n\n\x03\x07\x04\x03\x12\x03\x1349\nJ\n\x02\x07\ + \x05\x12\x03\x15\x04+\x1a?\x20Use\x20`serde_derive`\x20to\x20implement\ + \x20`Serialize`\x20and\x20`Deserialize`\n\n\n\n\x03\x07\x05\x02\x12\x03\ + \t\x07\"\n\n\n\x03\x07\x05\x04\x12\x03\x15\x04\x0c\n\n\n\x03\x07\x05\x05\ + \x12\x03\x15\r\x11\n\n\n\x03\x07\x05\x01\x12\x03\x15\x12\"\n\n\n\x03\x07\ + \x05\x03\x12\x03\x15%*\n3\n\x02\x07\x06\x12\x03\x17\x041\x1a(\x20Guard\ + \x20serde\x20annotations\x20with\x20cfg\x20attr.\n\n\n\n\x03\x07\x06\x02\ + \x12\x03\t\x07\"\n\n\n\x03\x07\x06\x04\x12\x03\x17\x04\x0c\n\n\n\x03\x07\ + \x06\x05\x12\x03\x17\r\x13\n\n\n\x03\x07\x06\x01\x12\x03\x17\x14(\n\n\n\ + \x03\x07\x06\x03\x12\x03\x17+0\nN\n\x02\x07\x07\x12\x03\x1a\x04+\x1aC\ + \x20When\x20true,\x20will\x20only\x20generate\x20codes\x20that\x20works\ + \x20with\x20lite\x20runtime.\n\n\n\n\x03\x07\x07\x02\x12\x03\t\x07\"\n\n\ + \n\x03\x07\x07\x04\x12\x03\x1a\x04\x0c\n\n\n\x03\x07\x07\x05\x12\x03\x1a\ + \r\x11\n\n\n\x03\x07\x07\x01\x12\x03\x1a\x12\"\n\n\n\x03\x07\x07\x03\x12\ + \x03\x1a%*\n\t\n\x01\x07\x12\x04\x1d\0,\x01\n7\n\x02\x07\x08\x12\x03\x1f\ + \x04'\x1a,\x20When\x20true,\x20oneof\x20field\x20is\x20generated\x20publ\ + ic\n\n\n\n\x03\x07\x08\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\x08\x04\x12\ + \x03\x1f\x04\x0c\n\n\n\x03\x07\x08\x05\x12\x03\x1f\r\x11\n\n\n\x03\x07\ + \x08\x01\x12\x03\x1f\x12\x1e\n\n\n\x03\x07\x08\x03\x12\x03\x1f!&\nI\n\ + \x02\x07\t\x12\x03!\x04(\x1a>\x20When\x20true\x20all\x20fields\x20are\ + \x20public,\x20and\x20not\x20accessors\x20generated\n\n\n\n\x03\x07\t\ + \x02\x12\x03\x1d\x07%\n\n\n\x03\x07\t\x04\x12\x03!\x04\x0c\n\n\n\x03\x07\ + \t\x05\x12\x03!\r\x11\n\n\n\x03\x07\t\x01\x12\x03!\x12\x1f\n\n\n\x03\x07\ + \t\x03\x12\x03!\"'\nP\n\x02\x07\n\x12\x03#\x04-\x1aE\x20When\x20false,\ + \x20`get_`,\x20`set_`,\x20`mut_`\x20etc.\x20accessors\x20are\x20not\x20g\ + enerated\n\n\n\n\x03\x07\n\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\n\x04\x12\ + \x03#\x04\x0c\n\n\n\x03\x07\n\x05\x12\x03#\r\x11\n\n\n\x03\x07\n\x01\x12\ + \x03#\x12$\n\n\n\x03\x07\n\x03\x12\x03#',\n2\n\x02\x07\x0b\x12\x03%\x045\ + \x1a'\x20Use\x20`bytes::Bytes`\x20for\x20`bytes`\x20fields\n\n\n\n\x03\ + \x07\x0b\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\x0b\x04\x12\x03%\x04\x0c\n\n\ + \n\x03\x07\x0b\x05\x12\x03%\r\x11\n\n\n\x03\x07\x0b\x01\x12\x03%\x12,\n\ + \n\n\x03\x07\x0b\x03\x12\x03%/4\n3\n\x02\x07\x0c\x12\x03'\x046\x1a(\x20U\ + se\x20`bytes::Bytes`\x20for\x20`string`\x20fields\n\n\n\n\x03\x07\x0c\ + \x02\x12\x03\x1d\x07%\n\n\n\x03\x07\x0c\x04\x12\x03'\x04\x0c\n\n\n\x03\ + \x07\x0c\x05\x12\x03'\r\x11\n\n\n\x03\x07\x0c\x01\x12\x03'\x12-\n\n\n\ + \x03\x07\x0c\x03\x12\x03'05\nJ\n\x02\x07\r\x12\x03)\x04'\x1a?\x20Use\x20\ + `serde_derive`\x20to\x20implement\x20`Serialize`\x20and\x20`Deserialize`\ + \n\n\n\n\x03\x07\r\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\r\x04\x12\x03)\x04\ + \x0c\n\n\n\x03\x07\r\x05\x12\x03)\r\x11\n\n\n\x03\x07\r\x01\x12\x03)\x12\ + \x1e\n\n\n\x03\x07\r\x03\x12\x03)!&\n3\n\x02\x07\x0e\x12\x03+\x04-\x1a(\ + \x20Guard\x20serde\x20annotations\x20with\x20cfg\x20attr.\n\n\n\n\x03\ + \x07\x0e\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\x0e\x04\x12\x03+\x04\x0c\n\n\ + \n\x03\x07\x0e\x05\x12\x03+\r\x13\n\n\n\x03\x07\x0e\x01\x12\x03+\x14$\n\ + \n\n\x03\x07\x0e\x03\x12\x03+',\n\t\n\x01\x07\x12\x04.\07\x01\nI\n\x02\ + \x07\x0f\x12\x030\x04.\x1a>\x20When\x20true\x20all\x20fields\x20are\x20p\ + ublic,\x20and\x20not\x20accessors\x20generated\n\n\n\n\x03\x07\x0f\x02\ + \x12\x03.\x07#\n\n\n\x03\x07\x0f\x04\x12\x030\x04\x0c\n\n\n\x03\x07\x0f\ + \x05\x12\x030\r\x11\n\n\n\x03\x07\x0f\x01\x12\x030\x12%\n\n\n\x03\x07\ + \x0f\x03\x12\x030(-\nP\n\x02\x07\x10\x12\x032\x043\x1aE\x20When\x20false\ + ,\x20`get_`,\x20`set_`,\x20`mut_`\x20etc.\x20accessors\x20are\x20not\x20\ + generated\n\n\n\n\x03\x07\x10\x02\x12\x03.\x07#\n\n\n\x03\x07\x10\x04\ + \x12\x032\x04\x0c\n\n\n\x03\x07\x10\x05\x12\x032\r\x11\n\n\n\x03\x07\x10\ + \x01\x12\x032\x12*\n\n\n\x03\x07\x10\x03\x12\x032-2\n2\n\x02\x07\x11\x12\ + \x034\x04;\x1a'\x20Use\x20`bytes::Bytes`\x20for\x20`bytes`\x20fields\n\n\ + \n\n\x03\x07\x11\x02\x12\x03.\x07#\n\n\n\x03\x07\x11\x04\x12\x034\x04\ + \x0c\n\n\n\x03\x07\x11\x05\x12\x034\r\x11\n\n\n\x03\x07\x11\x01\x12\x034\ + \x122\n\n\n\x03\x07\x11\x03\x12\x0345:\n3\n\x02\x07\x12\x12\x036\x04<\ + \x1a(\x20Use\x20`bytes::Bytes`\x20for\x20`string`\x20fields\n\n\n\n\x03\ + \x07\x12\x02\x12\x03.\x07#\n\n\n\x03\x07\x12\x04\x12\x036\x04\x0c\n\n\n\ + \x03\x07\x12\x05\x12\x036\r\x11\n\n\n\x03\x07\x12\x01\x12\x036\x123\n\n\ + \n\x03\x07\x12\x03\x12\x0366;\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/src/singular.rs b/src/singular.rs new file mode 100644 index 0000000..71d4f0a --- /dev/null +++ b/src/singular.rs @@ -0,0 +1,580 @@ +#[cfg(feature = "with-serde")] +use serde; + +use std::default::Default; +use std::fmt; +use std::hash::Hash; +use std::hash::Hasher; +use std::mem; +use std::option; + +use clear::Clear; + +/// Like `Option<T>`, but keeps the actual element on `clear`. +pub struct SingularField<T> { + value: T, + set: bool, +} + +/// Like `Option<Box<T>>`, but keeps the actual element on `clear`. +pub struct SingularPtrField<T> { + value: Option<Box<T>>, + set: bool, +} + +impl<T> SingularField<T> { + /// Construct this object from given value. + #[inline] + pub fn some(value: T) -> SingularField<T> { + SingularField { + value: value, + set: true, + } + } + + /// True iff this object contains data. + #[inline] + pub fn is_some(&self) -> bool { + self.set + } + + /// True iff this object contains no data. + #[inline] + pub fn is_none(&self) -> bool { + !self.is_some() + } + + /// Convert this object into `Option`. + #[inline] + pub fn into_option(self) -> Option<T> { + if self.set { + Some(self.value) + } else { + None + } + } + + /// View data as `Option`. + #[inline] + pub fn as_ref<'a>(&'a self) -> Option<&'a T> { + if self.set { + Some(&self.value) + } else { + None + } + } + + /// View data as mutable `Option`. + #[inline] + pub fn as_mut<'a>(&'a mut self) -> Option<&'a mut T> { + if self.set { + Some(&mut self.value) + } else { + None + } + } + + /// Unwrap data as reference. + #[inline] + pub fn unwrap_ref<'a>(&'a self) -> &'a T { + self.as_ref().unwrap() + } + + /// Unwrap data as mutable reference. + #[inline] + pub fn unwrap_mut_ref<'a>(&'a mut self) -> &'a mut T { + self.as_mut().unwrap() + } + + /// Unwrap data, panic if not set. + #[inline] + pub fn unwrap(self) -> T { + if self.set { + self.value + } else { + panic!(); + } + } + + /// Unwrap data or return given default value. + #[inline] + pub fn unwrap_or(self, def: T) -> T { + if self.set { + self.value + } else { + def + } + } + + /// Unwrap data or return given default value. + #[inline] + pub fn unwrap_or_else<F>(self, f: F) -> T + where + F: FnOnce() -> T, + { + if self.set { + self.value + } else { + f() + } + } + + /// Apply a function to contained element and store result in new `SingularPtrField`. + #[inline] + pub fn map<U, F>(self, f: F) -> SingularPtrField<U> + where + F: FnOnce(T) -> U, + { + SingularPtrField::from_option(self.into_option().map(f)) + } + + /// View as iterator over references. + #[inline] + pub fn iter<'a>(&'a self) -> option::IntoIter<&'a T> { + self.as_ref().into_iter() + } + + /// View as iterator over mutable references. + #[inline] + pub fn mut_iter<'a>(&'a mut self) -> option::IntoIter<&'a mut T> { + self.as_mut().into_iter() + } + + /// Clear this object. + /// Note, contained object destructor is not called, so allocated memory could be reused. + #[inline] + pub fn clear(&mut self) { + self.set = false; + } +} + +impl<T: Default> SingularField<T> { + /// Construct a `SingularField` with no data. + #[inline] + pub fn none() -> SingularField<T> { + SingularField { + value: Default::default(), + set: false, + } + } + + /// Construct `SingularField` from `Option`. + #[inline] + pub fn from_option(option: Option<T>) -> SingularField<T> { + match option { + Some(x) => SingularField::some(x), + None => SingularField::none(), + } + } + + /// Return data as option, clear this object. + #[inline] + pub fn take(&mut self) -> Option<T> { + if self.set { + self.set = false; + Some(mem::replace(&mut self.value, Default::default())) + } else { + None + } + } +} + +impl<T> SingularPtrField<T> { + /// Construct `SingularPtrField` from given object. + #[inline] + pub fn some(value: T) -> SingularPtrField<T> { + SingularPtrField { + value: Some(Box::new(value)), + set: true, + } + } + + /// Construct an empty `SingularPtrField`. + #[inline] + pub fn none() -> SingularPtrField<T> { + SingularPtrField { + value: None, + set: false, + } + } + + /// Construct `SingularPtrField` from optional. + #[inline] + pub fn from_option(option: Option<T>) -> SingularPtrField<T> { + match option { + Some(x) => SingularPtrField::some(x), + None => SingularPtrField::none(), + } + } + + /// True iff this object contains data. + #[inline] + pub fn is_some(&self) -> bool { + self.set + } + + /// True iff this object contains no data. + #[inline] + pub fn is_none(&self) -> bool { + !self.is_some() + } + + /// Convert into `Option<T>`. + #[inline] + pub fn into_option(self) -> Option<T> { + if self.set { + Some(*self.value.unwrap()) + } else { + None + } + } + + /// View data as reference option. + #[inline] + pub fn as_ref<'a>(&'a self) -> Option<&'a T> { + if self.set { + Some(&**self.value.as_ref().unwrap()) + } else { + None + } + } + + /// View data as mutable reference option. + #[inline] + pub fn as_mut<'a>(&'a mut self) -> Option<&'a mut T> { + if self.set { + Some(&mut **self.value.as_mut().unwrap()) + } else { + None + } + } + + /// Get data as reference. + /// Panics if empty. + #[inline] + pub fn get_ref<'a>(&'a self) -> &'a T { + self.as_ref().unwrap() + } + + /// Get data as mutable reference. + /// Panics if empty. + #[inline] + pub fn get_mut_ref<'a>(&'a mut self) -> &'a mut T { + self.as_mut().unwrap() + } + + /// Take the data. + /// Panics if empty + #[inline] + pub fn unwrap(self) -> T { + if self.set { + *self.value.unwrap() + } else { + panic!(); + } + } + + /// Take the data or return supplied default element if empty. + #[inline] + pub fn unwrap_or(self, def: T) -> T { + if self.set { + *self.value.unwrap() + } else { + def + } + } + + /// Take the data or return supplied default element if empty. + #[inline] + pub fn unwrap_or_else<F>(self, f: F) -> T + where + F: FnOnce() -> T, + { + if self.set { + *self.value.unwrap() + } else { + f() + } + } + + /// Apply given function to contained data to construct another `SingularPtrField`. + /// Returns empty `SingularPtrField` if this object is empty. + #[inline] + pub fn map<U, F>(self, f: F) -> SingularPtrField<U> + where + F: FnOnce(T) -> U, + { + SingularPtrField::from_option(self.into_option().map(f)) + } + + /// View data as iterator. + #[inline] + pub fn iter<'a>(&'a self) -> option::IntoIter<&'a T> { + self.as_ref().into_iter() + } + + /// View data as mutable iterator. + #[inline] + pub fn mut_iter<'a>(&'a mut self) -> option::IntoIter<&'a mut T> { + self.as_mut().into_iter() + } + + /// Take data as option, leaving this object empty. + #[inline] + pub fn take(&mut self) -> Option<T> { + if self.set { + self.set = false; + Some(*self.value.take().unwrap()) + } else { + None + } + } + + /// Clear this object, but do not call destructor of underlying data. + #[inline] + pub fn clear(&mut self) { + self.set = false; + } +} + +impl<T: Default + Clear> SingularField<T> { + /// Get contained data, consume self. Return default value for type if this is empty. + #[inline] + pub fn unwrap_or_default(mut self) -> T { + self.value.clear(); + self.value + } + + /// Initialize this object with default value. + /// This operation can be more efficient then construction of clear element, + /// because it may reuse previously contained object. + #[inline] + pub fn set_default<'a>(&'a mut self) -> &'a mut T { + self.set = true; + self.value.clear(); + &mut self.value + } +} + +impl<T: Default + Clear> SingularPtrField<T> { + /// Get contained data, consume self. Return default value for type if this is empty. + #[inline] + pub fn unwrap_or_default(mut self) -> T { + if self.set { + self.unwrap() + } else if self.value.is_some() { + self.value.clear(); + *self.value.unwrap() + } else { + Default::default() + } + } + + /// Initialize this object with default value. + /// This operation can be more efficient then construction of clear element, + /// because it may reuse previously contained object. + #[inline] + pub fn set_default<'a>(&'a mut self) -> &'a mut T { + self.set = true; + if self.value.is_some() { + self.value.as_mut().unwrap().clear(); + } else { + self.value = Some(Default::default()); + } + self.as_mut().unwrap() + } +} + +impl<T: Default> Default for SingularField<T> { + #[inline] + fn default() -> SingularField<T> { + SingularField::none() + } +} + +impl<T> Default for SingularPtrField<T> { + #[inline] + fn default() -> SingularPtrField<T> { + SingularPtrField::none() + } +} + +impl<T: Default> From<Option<T>> for SingularField<T> { + fn from(o: Option<T>) -> Self { + SingularField::from_option(o) + } +} + +impl<T> From<Option<T>> for SingularPtrField<T> { + fn from(o: Option<T>) -> Self { + SingularPtrField::from_option(o) + } +} + +impl<T: Clone + Default> Clone for SingularField<T> { + #[inline] + fn clone(&self) -> SingularField<T> { + if self.set { + SingularField::some(self.value.clone()) + } else { + SingularField::none() + } + } +} + +impl<T: Clone> Clone for SingularPtrField<T> { + #[inline] + fn clone(&self) -> SingularPtrField<T> { + if self.set { + SingularPtrField::some(self.as_ref().unwrap().clone()) + } else { + SingularPtrField::none() + } + } +} + +impl<T: fmt::Debug> fmt::Debug for SingularField<T> { + #[inline] + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + if self.is_some() { + write!(f, "Some({:?})", *self.as_ref().unwrap()) + } else { + write!(f, "None") + } + } +} + +impl<T: fmt::Debug> fmt::Debug for SingularPtrField<T> { + #[inline] + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + if self.is_some() { + write!(f, "Some({:?})", *self.as_ref().unwrap()) + } else { + write!(f, "None") + } + } +} + +impl<T: PartialEq> PartialEq for SingularField<T> { + #[inline] + fn eq(&self, other: &SingularField<T>) -> bool { + self.as_ref() == other.as_ref() + } +} + +impl<T: Eq> Eq for SingularField<T> {} + +impl<T: PartialEq> PartialEq for SingularPtrField<T> { + #[inline] + fn eq(&self, other: &SingularPtrField<T>) -> bool { + self.as_ref() == other.as_ref() + } +} + +impl<T: Eq> Eq for SingularPtrField<T> {} + +impl<T: Hash> Hash for SingularField<T> { + fn hash<H: Hasher>(&self, state: &mut H) { + self.as_ref().hash(state); + } +} + +impl<T: Hash> Hash for SingularPtrField<T> { + fn hash<H: Hasher>(&self, state: &mut H) { + self.as_ref().hash(state); + } +} + +impl<'a, T> IntoIterator for &'a SingularField<T> { + type Item = &'a T; + type IntoIter = option::IntoIter<&'a T>; + + fn into_iter(self) -> option::IntoIter<&'a T> { + self.iter() + } +} + +impl<'a, T> IntoIterator for &'a SingularPtrField<T> { + type Item = &'a T; + type IntoIter = option::IntoIter<&'a T>; + + fn into_iter(self) -> option::IntoIter<&'a T> { + self.iter() + } +} + +#[cfg(feature = "with-serde")] +impl<T: serde::Serialize> serde::Serialize for SingularPtrField<T> { + fn serialize<S>( + &self, + serializer: S, + ) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error> + where + S: serde::Serializer, + { + self.as_ref().serialize(serializer) + } +} + +#[cfg(feature = "with-serde")] +impl<T: serde::Serialize> serde::Serialize for SingularField<T> { + fn serialize<S>( + &self, + serializer: S, + ) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error> + where + S: serde::Serializer, + { + self.as_ref().serialize(serializer) + } +} + +#[cfg(feature = "with-serde")] +impl<'de, T: serde::Deserialize<'de>> serde::Deserialize<'de> for SingularPtrField<T> { + fn deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deserializer<'de>>::Error> + where + D: serde::Deserializer<'de>, + { + Option::deserialize(deserializer).map(SingularPtrField::from_option) + } +} + +#[cfg(feature = "with-serde")] +impl<'de, T: serde::Deserialize<'de> + Default> serde::Deserialize<'de> for SingularField<T> { + fn deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deserializer<'de>>::Error> + where + D: serde::Deserializer<'de>, + { + Option::deserialize(deserializer).map(SingularField::from_option) + } +} + +#[cfg(test)] +mod test { + use super::SingularField; + use clear::Clear; + + #[test] + fn test_set_default_clears() { + #[derive(Default)] + struct Foo { + b: isize, + } + + impl Clear for Foo { + fn clear(&mut self) { + self.b = 0; + } + } + + let mut x = SingularField::some(Foo { b: 10 }); + x.clear(); + x.set_default(); + assert_eq!(0, x.as_ref().unwrap().b); + + x.as_mut().unwrap().b = 11; + // without clear + x.set_default(); + assert_eq!(0, x.as_ref().unwrap().b); + } +} diff --git a/src/stream.rs b/src/stream.rs new file mode 100644 index 0000000..53c3f45 --- /dev/null +++ b/src/stream.rs @@ -0,0 +1,1802 @@ +#![doc(hidden)] + +//! `CodedInputStream` and `CodedOutputStream` implementations + +use std::io; +use std::io::Write; +use std::io::{BufRead, Read}; +use std::mem; +use std::slice; + +#[cfg(feature = "bytes")] +use bytes::Bytes; +#[cfg(feature = "bytes")] +use chars::Chars; + +use buf_read_iter::BufReadIter; +use core::Message; +use enums::ProtobufEnum; +use error::ProtobufError; +use error::ProtobufResult; +use error::WireError; +use misc::remaining_capacity_as_slice_mut; +use misc::remove_lifetime_mut; +use unknown::UnknownFields; +use unknown::UnknownValue; +use unknown::UnknownValueRef; +use varint; +use zigzag::decode_zig_zag_32; +use zigzag::decode_zig_zag_64; +use zigzag::encode_zig_zag_32; +use zigzag::encode_zig_zag_64; + +/// 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; + +/// 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; + +/// Serialization constants. +pub mod wire_format { + // TODO: temporary + pub use self::WireType::*; + + /// Tag occupies 3 bits + pub const TAG_TYPE_BITS: u32 = 3; + /// Tag mask + pub const TAG_TYPE_MASK: u32 = (1u32 << TAG_TYPE_BITS as usize) - 1; + /// Max possible field number + pub const FIELD_NUMBER_MAX: u32 = 0x1fffffff; + + /// One of six defined protobuf wire types + #[derive(PartialEq, Eq, Clone, Debug)] + pub enum WireType { + /// Varint (e. g. `int32` or `sint64`) + WireTypeVarint = 0, + /// Fixed size 64 bit (e. g. `fixed64` or `double`) + WireTypeFixed64 = 1, + /// Length-delimited (e. g. `message` or `string`) + WireTypeLengthDelimited = 2, + /// Groups are not supported by rust-protobuf + WireTypeStartGroup = 3, + /// Groups are not supported by rust-protobuf + WireTypeEndGroup = 4, + /// Fixed size 64 bit (e. g. `fixed32` or `float`) + WireTypeFixed32 = 5, + } + + impl Copy for WireType {} + + impl WireType { + /// Parse wire type + pub fn new(n: u32) -> Option<WireType> { + match n { + 0 => Some(WireTypeVarint), + 1 => Some(WireTypeFixed64), + 2 => Some(WireTypeLengthDelimited), + 3 => Some(WireTypeStartGroup), + 4 => Some(WireTypeEndGroup), + 5 => Some(WireTypeFixed32), + _ => None, + } + } + } + + /// Parsed protobuf tag, which is a pair of field number and wire type + #[derive(Clone)] + pub struct Tag { + field_number: u32, + wire_type: WireType, + } + + impl Copy for Tag {} + + impl Tag { + /// Pack a tag to integer + pub fn value(self) -> u32 { + (self.field_number << TAG_TYPE_BITS) | (self.wire_type as u32) + } + + /// Parse integer into `Tag` object + // TODO: should return Result instead of Option + pub fn new(value: u32) -> Option<Tag> { + let wire_type = WireType::new(value & TAG_TYPE_MASK); + if wire_type.is_none() { + return None; + } + let field_number = value >> TAG_TYPE_BITS; + if field_number == 0 { + return None; + } + Some(Tag { + field_number: field_number, + wire_type: wire_type.unwrap(), + }) + } + + /// Create a tag from a field number and wire type. + /// + /// # Panics + /// + /// If field number is outside of allowed range. + pub fn make(field_number: u32, wire_type: WireType) -> Tag { + assert!(field_number > 0 && field_number <= FIELD_NUMBER_MAX); + Tag { + field_number: field_number, + wire_type: wire_type, + } + } + + /// Tag as pair of (field number, wire type) + pub fn unpack(self) -> (u32, WireType) { + (self.field_number(), self.wire_type()) + } + + fn wire_type(self) -> WireType { + self.wire_type + } + + /// Protobuf field number + pub fn field_number(self) -> u32 { + self.field_number + } + } +} + +/// Buffered read with handy utilities. +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 even if `Read` is not. + pub fn new(read: &'a mut Read) -> CodedInputStream<'a> { + CodedInputStream::from_buf_read_iter(BufReadIter::from_read(read)) + } + + /// Create from `BufRead`. + /// + /// `CodedInputStream` will utilize `BufRead` buffer. + pub fn from_buffered_reader(buf_read: &'a mut 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_carllerche_bytes`](crate::CodedInputStream::read_carllerche_bytes) + /// will return a shared copy of this bytes object. + #[cfg(feature = "bytes")] + pub fn from_carllerche_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: 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) -> ProtobufResult<()> { + if self.recursion_level >= self.recursion_limit { + return Err(ProtobufError::WireError(WireError::OverRecursionLimit)); + } + 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`. + /// + /// Return `0` on EOF. + // TODO: overload with `Read::read` + pub fn read(&mut self, buf: &mut [u8]) -> ProtobufResult<()> { + self.source.read_exact(buf)?; + Ok(()) + } + + /// 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_callerche_bytes(&mut self, count: usize) -> ProtobufResult<Bytes> { + self.source.read_exact_bytes(count) + } + + /// Read one byte + #[inline(always)] + pub fn read_raw_byte(&mut self) -> ProtobufResult<u8> { + self.source.read_byte() + } + + /// Push new limit, return previous limit. + pub fn push_limit(&mut self, limit: u64) -> ProtobufResult<u64> { + 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) -> ProtobufResult<bool> { + self.source.eof() + } + + /// Check we are at EOF. + /// + /// Return error if we are not at EOF. + pub fn check_eof(&mut self) -> ProtobufResult<()> { + let eof = self.eof()?; + if !eof { + return Err(ProtobufError::WireError(WireError::UnexpectedEof)); + } + Ok(()) + } + + fn read_raw_varint64_slow(&mut self) -> ProtobufResult<u64> { + let mut r: u64 = 0; + let mut i = 0; + loop { + if i == 10 { + return Err(ProtobufError::WireError(WireError::IncorrectVarint)); + } + let b = self.read_raw_byte()?; + // TODO: may overflow if i == 9 + r = r | (((b & 0x7f) as u64) << (i * 7)); + i += 1; + if b < 0x80 { + return Ok(r); + } + } + } + + /// Read varint + #[inline(always)] + pub fn read_raw_varint64(&mut self) -> ProtobufResult<u64> { + 'slow: loop { + let ret; + let consume; + + loop { + let rem = self.source.remaining_in_buf(); + + if rem.len() >= 1 { + // most varints are in practice fit in 1 byte + if rem[0] < 0x80 { + ret = rem[0] as u64; + consume = 1; + } else { + // handle case of two bytes too + if rem.len() >= 2 && rem[1] < 0x80 { + ret = (rem[0] & 0x7f) as u64 | (rem[1] as u64) << 7; + consume = 2; + } else if rem.len() >= 10 { + // Read from array when buf at at least 10 bytes, + // max len for varint. + let mut r: u64 = 0; + let mut i: usize = 0; + { + let rem = rem; + loop { + if i == 10 { + return Err(ProtobufError::WireError( + WireError::IncorrectVarint, + )); + } + + let b = if true { + // skip range check + unsafe { *rem.get_unchecked(i) } + } else { + rem[i] + }; + + // TODO: may overflow if i == 9 + r = r | (((b & 0x7f) as u64) << (i * 7)); + i += 1; + if b < 0x80 { + break; + } + } + } + consume = i; + ret = r; + } else { + break 'slow; + } + } + } else { + break 'slow; + } + break; + } + + self.source.consume(consume); + return Ok(ret); + } + + self.read_raw_varint64_slow() + } + + /// Read varint + #[inline(always)] + pub fn read_raw_varint32(&mut self) -> ProtobufResult<u32> { + self.read_raw_varint64().map(|v| v as u32) + } + + /// Read little-endian 32-bit integer + pub fn read_raw_little_endian32(&mut self) -> ProtobufResult<u32> { + let mut r = 0u32; + let bytes: &mut [u8] = unsafe { + let p: *mut u8 = mem::transmute(&mut r); + slice::from_raw_parts_mut(p, mem::size_of::<u32>()) + }; + self.read(bytes)?; + Ok(r.to_le()) + } + + /// Read little-endian 64-bit integer + pub fn read_raw_little_endian64(&mut self) -> ProtobufResult<u64> { + let mut r = 0u64; + let bytes: &mut [u8] = unsafe { + let p: *mut u8 = mem::transmute(&mut r); + slice::from_raw_parts_mut(p, mem::size_of::<u64>()) + }; + self.read(bytes)?; + Ok(r.to_le()) + } + + /// Read tag + #[inline] + pub fn read_tag(&mut self) -> ProtobufResult<wire_format::Tag> { + let v = self.read_raw_varint32()?; + match wire_format::Tag::new(v) { + Some(tag) => Ok(tag), + None => Err(ProtobufError::WireError(WireError::IncorrectTag(v))), + } + } + + /// Read tag, return it is pair (field number, wire type) + #[inline] + pub fn read_tag_unpack(&mut self) -> ProtobufResult<(u32, wire_format::WireType)> { + self.read_tag().map(|t| t.unpack()) + } + + /// Read `double` + pub fn read_double(&mut self) -> ProtobufResult<f64> { + let bits = self.read_raw_little_endian64()?; + unsafe { Ok(mem::transmute::<u64, f64>(bits)) } + } + + /// Read `float` + pub fn read_float(&mut self) -> ProtobufResult<f32> { + let bits = self.read_raw_little_endian32()?; + unsafe { Ok(mem::transmute::<u32, f32>(bits)) } + } + + /// Read `int64` + pub fn read_int64(&mut self) -> ProtobufResult<i64> { + self.read_raw_varint64().map(|v| v as i64) + } + + /// Read `int32` + pub fn read_int32(&mut self) -> ProtobufResult<i32> { + self.read_raw_varint32().map(|v| v as i32) + } + + /// Read `uint64` + pub fn read_uint64(&mut self) -> ProtobufResult<u64> { + self.read_raw_varint64() + } + + /// Read `uint32` + pub fn read_uint32(&mut self) -> ProtobufResult<u32> { + self.read_raw_varint32() + } + + /// Read `sint64` + pub fn read_sint64(&mut self) -> ProtobufResult<i64> { + self.read_uint64().map(decode_zig_zag_64) + } + + /// Read `sint32` + pub fn read_sint32(&mut self) -> ProtobufResult<i32> { + self.read_uint32().map(decode_zig_zag_32) + } + + /// Read `fixed64` + pub fn read_fixed64(&mut self) -> ProtobufResult<u64> { + self.read_raw_little_endian64() + } + + /// Read `fixed32` + pub fn read_fixed32(&mut self) -> ProtobufResult<u32> { + self.read_raw_little_endian32() + } + + /// Read `sfixed64` + pub fn read_sfixed64(&mut self) -> ProtobufResult<i64> { + self.read_raw_little_endian64().map(|v| v as i64) + } + + /// Read `sfixed32` + pub fn read_sfixed32(&mut self) -> ProtobufResult<i32> { + self.read_raw_little_endian32().map(|v| v as i32) + } + + /// Read `bool` + pub fn read_bool(&mut self) -> ProtobufResult<bool> { + self.read_raw_varint32().map(|v| v != 0) + } + + /// Read `enum` as `ProtobufEnum` + pub fn read_enum<E: ProtobufEnum>(&mut self) -> ProtobufResult<E> { + let i = self.read_int32()?; + match ProtobufEnum::from_i32(i) { + Some(e) => Ok(e), + None => Err(ProtobufError::WireError(WireError::InvalidEnumValue(i))), + } + } + + /// Read `repeated` packed `double` + pub fn read_repeated_packed_double_into( + &mut self, + target: &mut Vec<f64>, + ) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + + target.reserve((len / 4) as usize); + + let old_limit = self.push_limit(len)?; + while !self.eof()? { + target.push(self.read_double()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read `repeated` packed `float` + pub fn read_repeated_packed_float_into(&mut self, target: &mut Vec<f32>) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + + target.reserve((len / 4) as usize); + + let old_limit = self.push_limit(len)?; + while !self.eof()? { + target.push(self.read_float()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read `repeated` packed `int64` + pub fn read_repeated_packed_int64_into(&mut self, target: &mut Vec<i64>) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + let old_limit = self.push_limit(len as u64)?; + while !self.eof()? { + target.push(self.read_int64()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read repeated packed `int32` + pub fn read_repeated_packed_int32_into(&mut self, target: &mut Vec<i32>) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + let old_limit = self.push_limit(len)?; + while !self.eof()? { + target.push(self.read_int32()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read repeated packed `uint64` + pub fn read_repeated_packed_uint64_into( + &mut self, + target: &mut Vec<u64>, + ) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + let old_limit = self.push_limit(len)?; + while !self.eof()? { + target.push(self.read_uint64()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read repeated packed `uint32` + pub fn read_repeated_packed_uint32_into( + &mut self, + target: &mut Vec<u32>, + ) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + let old_limit = self.push_limit(len)?; + while !self.eof()? { + target.push(self.read_uint32()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read repeated packed `sint64` + pub fn read_repeated_packed_sint64_into( + &mut self, + target: &mut Vec<i64>, + ) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + let old_limit = self.push_limit(len)?; + while !self.eof()? { + target.push(self.read_sint64()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read repeated packed `sint32` + pub fn read_repeated_packed_sint32_into( + &mut self, + target: &mut Vec<i32>, + ) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + let old_limit = self.push_limit(len)?; + while !self.eof()? { + target.push(self.read_sint32()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read repeated packed `fixed64` + pub fn read_repeated_packed_fixed64_into( + &mut self, + target: &mut Vec<u64>, + ) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + + target.reserve((len / 8) as usize); + + let old_limit = self.push_limit(len)?; + while !self.eof()? { + target.push(self.read_fixed64()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read repeated packed `fixed32` + pub fn read_repeated_packed_fixed32_into( + &mut self, + target: &mut Vec<u32>, + ) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + + target.reserve((len / 4) as usize); + + let old_limit = self.push_limit(len)?; + while !self.eof()? { + target.push(self.read_fixed32()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read repeated packed `sfixed64` + pub fn read_repeated_packed_sfixed64_into( + &mut self, + target: &mut Vec<i64>, + ) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + + target.reserve((len / 8) as usize); + + let old_limit = self.push_limit(len)?; + while !self.eof()? { + target.push(self.read_sfixed64()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read repeated packed `sfixed32` + pub fn read_repeated_packed_sfixed32_into( + &mut self, + target: &mut Vec<i32>, + ) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + + target.reserve((len / 4) as usize); + + let old_limit = self.push_limit(len)?; + while !self.eof()? { + target.push(self.read_sfixed32()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read repeated packed `bool` + pub fn read_repeated_packed_bool_into(&mut self, target: &mut Vec<bool>) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + + // regular bool value is 1-byte size + target.reserve(len as usize); + + let old_limit = self.push_limit(len)?; + while !self.eof()? { + target.push(self.read_bool()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read repeated packed `enum` into `ProtobufEnum` + pub fn read_repeated_packed_enum_into<E: ProtobufEnum>( + &mut self, + target: &mut Vec<E>, + ) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + let old_limit = self.push_limit(len)?; + while !self.eof()? { + target.push(self.read_enum()?); + } + self.pop_limit(old_limit); + Ok(()) + } + + /// Read `UnknownValue` + pub fn read_unknown( + &mut self, + wire_type: wire_format::WireType, + ) -> ProtobufResult<UnknownValue> { + match wire_type { + wire_format::WireTypeVarint => { + self.read_raw_varint64().map(|v| UnknownValue::Varint(v)) + } + wire_format::WireTypeFixed64 => self.read_fixed64().map(|v| UnknownValue::Fixed64(v)), + wire_format::WireTypeFixed32 => self.read_fixed32().map(|v| UnknownValue::Fixed32(v)), + wire_format::WireTypeLengthDelimited => { + let len = self.read_raw_varint32()?; + self.read_raw_bytes(len) + .map(|v| UnknownValue::LengthDelimited(v)) + } + _ => Err(ProtobufError::WireError(WireError::UnexpectedWireType( + wire_type, + ))), + } + } + + /// Skip field + pub fn skip_field(&mut self, wire_type: wire_format::WireType) -> ProtobufResult<()> { + self.read_unknown(wire_type).map(|_| ()) + } + + /// Read raw bytes into the supplied vector. The vector will be resized as needed and + /// overwritten. + pub fn read_raw_bytes_into(&mut self, count: u32, target: &mut Vec<u8>) -> ProtobufResult<()> { + if false { + // Master uses this version, but keep existing version for a while + // to avoid possible breakages. + return self.source.read_exact_to_vec(count as usize, target); + } + + let count = count as usize; + + // TODO: also do some limits when reading from unlimited source + if count as u64 > self.source.bytes_until_limit() { + return Err(ProtobufError::WireError(WireError::TruncatedMessage)); + } + + unsafe { + target.set_len(0); + } + + if count >= READ_RAW_BYTES_MAX_ALLOC { + // avoid calling `reserve` on buf with very large buffer: could be a malformed message + + let mut take = self.by_ref().take(count as u64); + take.read_to_end(target)?; + + if target.len() != count { + return Err(ProtobufError::WireError(WireError::TruncatedMessage)); + } + } else { + target.reserve(count); + unsafe { + target.set_len(count); + } + + self.source.read_exact(target)?; + } + Ok(()) + } + + /// Read exact number of bytes + pub fn read_raw_bytes(&mut self, count: u32) -> ProtobufResult<Vec<u8>> { + 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) -> ProtobufResult<()> { + // TODO: make it more efficient + self.read_raw_bytes(count).map(|_| ()) + } + + /// Read `bytes` field, length delimited + pub fn read_bytes(&mut self) -> ProtobufResult<Vec<u8>> { + let mut r = Vec::new(); + self.read_bytes_into(&mut r)?; + Ok(r) + } + + /// Read `bytes` field, length delimited + #[cfg(feature = "bytes")] + pub fn read_carllerche_bytes(&mut self) -> ProtobufResult<Bytes> { + let len = self.read_raw_varint32()?; + self.read_raw_callerche_bytes(len as usize) + } + + /// Read `string` field, length delimited + #[cfg(feature = "bytes")] + pub fn read_carllerche_chars(&mut self) -> ProtobufResult<Chars> { + let bytes = self.read_carllerche_bytes()?; + Ok(Chars::from_bytes(bytes)?) + } + + /// Read `bytes` field, length delimited + pub fn read_bytes_into(&mut self, target: &mut Vec<u8>) -> ProtobufResult<()> { + 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) -> ProtobufResult<String> { + 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) -> ProtobufResult<()> { + 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)), + }; + mem::replace(target, s); + Ok(()) + } + + /// Read message, do not check if message is initialized + pub fn merge_message<M: Message>(&mut self, message: &mut M) -> ProtobufResult<()> { + let len = self.read_raw_varint64()?; + let old_limit = self.push_limit(len)?; + message.merge_from(self)?; + self.pop_limit(old_limit); + Ok(()) + } + + /// Read message + pub fn read_message<M: Message>(&mut self) -> ProtobufResult<M> { + let mut r: M = Message::new(); + self.merge_message(&mut r)?; + r.check_initialized()?; + Ok(r) + } +} + +impl<'a> Read for CodedInputStream<'a> { + fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { + 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) + } +} + +#[doc(hidden)] +pub trait WithCodedOutputStream { + fn with_coded_output_stream<T, F>(self, cb: F) -> ProtobufResult<T> + where + F: FnOnce(&mut CodedOutputStream) -> ProtobufResult<T>; +} + +impl<'a> WithCodedOutputStream for &'a mut (Write + 'a) { + fn with_coded_output_stream<T, F>(self, cb: F) -> ProtobufResult<T> + where + F: FnOnce(&mut CodedOutputStream) -> ProtobufResult<T>, + { + let mut os = CodedOutputStream::new(self); + let r = cb(&mut os)?; + os.flush()?; + Ok(r) + } +} + +impl<'a> WithCodedOutputStream for &'a mut Vec<u8> { + fn with_coded_output_stream<T, F>(mut self, cb: F) -> ProtobufResult<T> + where + F: FnOnce(&mut CodedOutputStream) -> ProtobufResult<T>, + { + let mut os = CodedOutputStream::vec(&mut self); + let r = cb(&mut os)?; + os.flush()?; + Ok(r) + } +} + +#[doc(hidden)] +pub fn with_coded_output_stream_to_bytes<F>(cb: F) -> ProtobufResult<Vec<u8>> +where + F: FnOnce(&mut CodedOutputStream) -> ProtobufResult<()>, +{ + let mut v = Vec::new(); + v.with_coded_output_stream(cb)?; + Ok(v) +} + +/// Helper internal utility, should not be used directly +#[doc(hidden)] +pub trait WithCodedInputStream { + fn with_coded_input_stream<T, F>(self, cb: F) -> ProtobufResult<T> + where + F: FnOnce(&mut CodedInputStream) -> ProtobufResult<T>; +} + +impl<'a> WithCodedInputStream for &'a mut (Read + 'a) { + fn with_coded_input_stream<T, F>(self, cb: F) -> ProtobufResult<T> + where + F: FnOnce(&mut CodedInputStream) -> ProtobufResult<T>, + { + let mut is = CodedInputStream::new(self); + let r = cb(&mut is)?; + is.check_eof()?; + Ok(r) + } +} + +impl<'a> WithCodedInputStream for &'a mut (BufRead + 'a) { + fn with_coded_input_stream<T, F>(self, cb: F) -> ProtobufResult<T> + where + F: FnOnce(&mut CodedInputStream) -> ProtobufResult<T>, + { + let mut is = CodedInputStream::from_buffered_reader(self); + let r = cb(&mut is)?; + is.check_eof()?; + Ok(r) + } +} + +impl<'a> WithCodedInputStream for &'a [u8] { + fn with_coded_input_stream<T, F>(self, cb: F) -> ProtobufResult<T> + where + F: FnOnce(&mut CodedInputStream) -> ProtobufResult<T>, + { + let mut is = CodedInputStream::from_bytes(self); + let r = cb(&mut is)?; + is.check_eof()?; + Ok(r) + } +} + +#[cfg(feature = "bytes")] +impl<'a> WithCodedInputStream for &'a Bytes { + fn with_coded_input_stream<T, F>(self, cb: F) -> ProtobufResult<T> + where + F: FnOnce(&mut CodedInputStream) -> ProtobufResult<T>, + { + let mut is = CodedInputStream::from_carllerche_bytes(self); + let r = cb(&mut is)?; + is.check_eof()?; + Ok(r) + } +} + +enum OutputTarget<'a> { + Write(&'a mut Write, Vec<u8>), + Vec(&'a mut Vec<u8>), + Bytes, +} + +/// Buffered write with handy utilities +pub struct CodedOutputStream<'a> { + target: OutputTarget<'a>, + // alias to buf from target + buffer: &'a mut [u8], + // within buffer + position: usize, +} + +impl<'a> CodedOutputStream<'a> { + /// Construct from given `Write`. + /// + /// `CodedOutputStream` is buffered even if `Write` is not + pub fn new(writer: &'a mut Write) -> CodedOutputStream<'a> { + let buffer_len = OUTPUT_STREAM_BUFFER_SIZE; + + let mut buffer_storage = Vec::with_capacity(buffer_len); + unsafe { + buffer_storage.set_len(buffer_len); + } + + let buffer = unsafe { remove_lifetime_mut(&mut buffer_storage as &mut [u8]) }; + + CodedOutputStream { + target: OutputTarget::Write(writer, buffer_storage), + buffer: buffer, + position: 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> { + CodedOutputStream { + target: OutputTarget::Bytes, + buffer: bytes, + position: 0, + } + } + + /// `CodedOutputStream` which writes directly to `Vec<u8>`. + /// + /// Caller should call `flush` at the end to guarantee vec contains + /// all written data. + pub fn vec(vec: &'a mut Vec<u8>) -> CodedOutputStream<'a> { + CodedOutputStream { + target: OutputTarget::Vec(vec), + buffer: &mut [], + position: 0, + } + } + + /// 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.len() as u64, self.position as u64); + } + OutputTarget::Write(..) | OutputTarget::Vec(..) => { + panic!("must not be called with Writer or Vec"); + } + } + } + + fn refresh_buffer(&mut self) -> ProtobufResult<()> { + match self.target { + OutputTarget::Write(ref mut write, _) => { + write.write_all(&self.buffer[0..self.position as usize])?; + self.position = 0; + } + OutputTarget::Vec(ref mut vec) => unsafe { + let vec_len = vec.len(); + assert!(vec_len + self.position <= vec.capacity()); + vec.set_len(vec_len + self.position); + vec.reserve(1); + self.buffer = remove_lifetime_mut(remaining_capacity_as_slice_mut(vec)); + self.position = 0; + }, + OutputTarget::Bytes => { + panic!("refresh_buffer must not be called on CodedOutputStream create from slice"); + } + } + Ok(()) + } + + /// Flush the buffer to underlying write + pub fn flush(&mut self) -> ProtobufResult<()> { + match self.target { + OutputTarget::Bytes => Ok(()), + OutputTarget::Write(..) | OutputTarget::Vec(..) => { + // TODO: must not reserve additional in Vec + self.refresh_buffer() + } + } + } + + /// Write a byte + pub fn write_raw_byte(&mut self, byte: u8) -> ProtobufResult<()> { + if self.position as usize == self.buffer.len() { + self.refresh_buffer()?; + } + self.buffer[self.position as usize] = byte; + self.position += 1; + Ok(()) + } + + /// Write bytes + pub fn write_raw_bytes(&mut self, bytes: &[u8]) -> ProtobufResult<()> { + if bytes.len() <= self.buffer.len() - self.position { + let bottom = self.position as usize; + let top = bottom + (bytes.len() as usize); + self.buffer[bottom..top].copy_from_slice(bytes); + self.position += bytes.len(); + return Ok(()); + } + + self.refresh_buffer()?; + + assert!(self.position == 0); + + if self.position + bytes.len() < self.buffer.len() { + &mut self.buffer[self.position..self.position + bytes.len()].copy_from_slice(bytes); + self.position += bytes.len(); + return Ok(()); + } + + match self.target { + OutputTarget::Bytes => { + unreachable!(); + } + OutputTarget::Write(ref mut write, _) => { + write.write_all(bytes)?; + } + OutputTarget::Vec(ref mut vec) => { + vec.extend(bytes); + unsafe { + self.buffer = remove_lifetime_mut(remaining_capacity_as_slice_mut(vec)); + } + } + } + Ok(()) + } + + /// Write a tag + pub fn write_tag( + &mut self, + field_number: u32, + wire_type: wire_format::WireType, + ) -> ProtobufResult<()> { + self.write_raw_varint32(wire_format::Tag::make(field_number, wire_type).value()) + } + + /// Write varint + pub fn write_raw_varint32(&mut self, value: u32) -> ProtobufResult<()> { + if self.buffer.len() - self.position >= 5 { + // fast path + let len = varint::encode_varint32(value, &mut self.buffer[self.position..]); + self.position += len; + Ok(()) + } else { + // slow path + let buf = &mut [0u8; 5]; + let len = varint::encode_varint32(value, buf); + self.write_raw_bytes(&buf[..len]) + } + } + + /// Write varint + pub fn write_raw_varint64(&mut self, value: u64) -> ProtobufResult<()> { + if self.buffer.len() - self.position >= 10 { + // fast path + let len = varint::encode_varint64(value, &mut self.buffer[self.position..]); + self.position += len; + Ok(()) + } else { + // slow path + let buf = &mut [0u8; 10]; + let len = varint::encode_varint64(value, buf); + self.write_raw_bytes(&buf[..len]) + } + } + + /// Write 32-bit integer little endian + pub fn write_raw_little_endian32(&mut self, value: u32) -> ProtobufResult<()> { + let bytes = unsafe { mem::transmute::<_, [u8; 4]>(value.to_le()) }; + self.write_raw_bytes(&bytes) + } + + /// Write 64-bit integer little endian + pub fn write_raw_little_endian64(&mut self, value: u64) -> ProtobufResult<()> { + let bytes = unsafe { mem::transmute::<_, [u8; 8]>(value.to_le()) }; + self.write_raw_bytes(&bytes) + } + + /// Write `float` + pub fn write_float_no_tag(&mut self, value: f32) -> ProtobufResult<()> { + let bits = unsafe { mem::transmute::<f32, u32>(value) }; + self.write_raw_little_endian32(bits) + } + + /// Write `double` + pub fn write_double_no_tag(&mut self, value: f64) -> ProtobufResult<()> { + let bits = unsafe { mem::transmute::<f64, u64>(value) }; + self.write_raw_little_endian64(bits) + } + + /// Write `float` field + pub fn write_float(&mut self, field_number: u32, value: f32) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeFixed32)?; + self.write_float_no_tag(value)?; + Ok(()) + } + + /// Write `double` field + pub fn write_double(&mut self, field_number: u32, value: f64) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeFixed64)?; + self.write_double_no_tag(value)?; + Ok(()) + } + + /// Write varint + pub fn write_uint64_no_tag(&mut self, value: u64) -> ProtobufResult<()> { + self.write_raw_varint64(value) + } + + /// Write varint + pub fn write_uint32_no_tag(&mut self, value: u32) -> ProtobufResult<()> { + self.write_raw_varint32(value) + } + + /// Write varint + pub fn write_int64_no_tag(&mut self, value: i64) -> ProtobufResult<()> { + self.write_raw_varint64(value as u64) + } + + /// Write varint + pub fn write_int32_no_tag(&mut self, value: i32) -> ProtobufResult<()> { + self.write_raw_varint64(value as u64) + } + + /// Write zigzag varint + pub fn write_sint64_no_tag(&mut self, value: i64) -> ProtobufResult<()> { + self.write_uint64_no_tag(encode_zig_zag_64(value)) + } + + /// Write zigzag varint + pub fn write_sint32_no_tag(&mut self, value: i32) -> ProtobufResult<()> { + self.write_uint32_no_tag(encode_zig_zag_32(value)) + } + + /// Write `fixed64` + pub fn write_fixed64_no_tag(&mut self, value: u64) -> ProtobufResult<()> { + self.write_raw_little_endian64(value) + } + + /// Write `fixed32` + pub fn write_fixed32_no_tag(&mut self, value: u32) -> ProtobufResult<()> { + self.write_raw_little_endian32(value) + } + + /// Write `sfixed64` + pub fn write_sfixed64_no_tag(&mut self, value: i64) -> ProtobufResult<()> { + self.write_raw_little_endian64(value as u64) + } + + /// Write `sfixed32` + pub fn write_sfixed32_no_tag(&mut self, value: i32) -> ProtobufResult<()> { + self.write_raw_little_endian32(value as u32) + } + + /// Write `bool` + pub fn write_bool_no_tag(&mut self, value: bool) -> ProtobufResult<()> { + self.write_raw_varint32(if value { 1 } else { 0 }) + } + + /// Write `enum` + pub fn write_enum_no_tag(&mut self, value: i32) -> ProtobufResult<()> { + self.write_int32_no_tag(value) + } + + /// Write `enum` + pub fn write_enum_obj_no_tag<E>(&mut self, value: E) -> ProtobufResult<()> + where + E: ProtobufEnum, + { + self.write_enum_no_tag(value.value()) + } + + /// Write unknown value + pub fn write_unknown_no_tag(&mut self, unknown: UnknownValueRef) -> ProtobufResult<()> { + 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) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeVarint)?; + self.write_uint64_no_tag(value)?; + Ok(()) + } + + /// Write `uint32` field + pub fn write_uint32(&mut self, field_number: u32, value: u32) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeVarint)?; + self.write_uint32_no_tag(value)?; + Ok(()) + } + + /// Write `int64` field + pub fn write_int64(&mut self, field_number: u32, value: i64) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeVarint)?; + self.write_int64_no_tag(value)?; + Ok(()) + } + + /// Write `int32` field + pub fn write_int32(&mut self, field_number: u32, value: i32) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeVarint)?; + self.write_int32_no_tag(value)?; + Ok(()) + } + + /// Write `sint64` field + pub fn write_sint64(&mut self, field_number: u32, value: i64) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeVarint)?; + self.write_sint64_no_tag(value)?; + Ok(()) + } + + /// Write `sint32` field + pub fn write_sint32(&mut self, field_number: u32, value: i32) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeVarint)?; + self.write_sint32_no_tag(value)?; + Ok(()) + } + + /// Write `fixed64` field + pub fn write_fixed64(&mut self, field_number: u32, value: u64) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeFixed64)?; + self.write_fixed64_no_tag(value)?; + Ok(()) + } + + /// Write `fixed32` field + pub fn write_fixed32(&mut self, field_number: u32, value: u32) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeFixed32)?; + self.write_fixed32_no_tag(value)?; + Ok(()) + } + + /// Write `sfixed64` field + pub fn write_sfixed64(&mut self, field_number: u32, value: i64) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeFixed64)?; + self.write_sfixed64_no_tag(value)?; + Ok(()) + } + + /// Write `sfixed32` field + pub fn write_sfixed32(&mut self, field_number: u32, value: i32) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeFixed32)?; + self.write_sfixed32_no_tag(value)?; + Ok(()) + } + + /// Write `bool` field + pub fn write_bool(&mut self, field_number: u32, value: bool) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeVarint)?; + self.write_bool_no_tag(value)?; + Ok(()) + } + + /// Write `enum` field + pub fn write_enum(&mut self, field_number: u32, value: i32) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeVarint)?; + self.write_enum_no_tag(value)?; + Ok(()) + } + + /// Write `enum` field + pub fn write_enum_obj<E>(&mut self, field_number: u32, value: E) -> ProtobufResult<()> + where + E: ProtobufEnum, + { + self.write_enum(field_number, value.value()) + } + + /// Write unknown field + pub fn write_unknown( + &mut self, + field_number: u32, + value: UnknownValueRef, + ) -> ProtobufResult<()> { + 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) -> ProtobufResult<()> { + for (number, values) in fields { + for value in values { + self.write_unknown(number, value)?; + } + } + Ok(()) + } + + /// Write bytes + pub fn write_bytes_no_tag(&mut self, bytes: &[u8]) -> ProtobufResult<()> { + 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) -> ProtobufResult<()> { + self.write_bytes_no_tag(s.as_bytes()) + } + + /// Write message + pub fn write_message_no_tag<M: Message>(&mut self, msg: &M) -> ProtobufResult<()> { + msg.write_length_delimited_to(self) + } + + /// Write `bytes` field + pub fn write_bytes(&mut self, field_number: u32, bytes: &[u8]) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeLengthDelimited)?; + self.write_bytes_no_tag(bytes)?; + Ok(()) + } + + /// Write `string` field + pub fn write_string(&mut self, field_number: u32, s: &str) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeLengthDelimited)?; + self.write_string_no_tag(s)?; + Ok(()) + } + + /// Write `message` field + pub fn write_message<M: Message>(&mut self, field_number: u32, msg: &M) -> ProtobufResult<()> { + self.write_tag(field_number, wire_format::WireTypeLengthDelimited)?; + self.write_message_no_tag(msg)?; + Ok(()) + } +} + +impl<'a> Write for CodedOutputStream<'a> { + fn write(&mut self, buf: &[u8]) -> io::Result<usize> { + self.write_raw_bytes(buf)?; + Ok(buf.len()) + } + + fn flush(&mut self) -> io::Result<()> { + CodedOutputStream::flush(self).map_err(Into::into) + } +} + +#[cfg(test)] +mod test { + + use std::fmt::Debug; + use std::io; + use std::io::BufRead; + use std::io::Read; + use std::io::Write; + use std::iter::repeat; + + use error::ProtobufError; + use error::ProtobufResult; + use hex::decode_hex; + use hex::encode_hex; + + use super::wire_format; + use super::CodedInputStream; + use super::CodedOutputStream; + use super::READ_RAW_BYTES_MAX_ALLOC; + + fn test_read_partial<F>(hex: &str, mut callback: F) + where + F: FnMut(&mut CodedInputStream), + { + let d = decode_hex(hex); + let mut reader = io::Cursor::new(d); + let mut is = CodedInputStream::from_buffered_reader(&mut reader as &mut dyn BufRead); + assert_eq!(0, is.pos()); + callback(&mut is); + } + + fn test_read<F>(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<F, V>(hex: &str, v: V, mut callback: F) + where + F: FnMut(&mut CodedInputStream) -> ProtobufResult<V>, + 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_vaint_malformed() { + // varint cannot have length > 10 + test_read_partial("ff ff ff ff ff ff ff ff ff ff 01", |reader| { + let result = reader.read_raw_varint64(); + match result { + // TODO: make an enum variant + Err(ProtobufError::WireError(..)) => (), + _ => panic!(), + } + }); + test_read_partial("ff ff ff ff ff ff ff ff ff ff 01", |reader| { + let result = reader.read_raw_varint32(); + match result { + // TODO: make an enum variant + Err(ProtobufError::WireError(..)) => (), + _ => panic!(), + } + }); + } + + #[test] + fn test_input_stream_read_raw_varint_unexpected_eof() { + test_read_partial("96 97", |reader| { + let result = reader.read_raw_varint32(); + match result { + Err(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] + 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")); + } + + fn test_write<F>(expected: &str, mut gen: F) + where + F: FnMut(&mut CodedOutputStream) -> ProtobufResult<()>, + { + 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<u8> + { + 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, wire_format::WireTypeVarint)); + } + + #[test] + fn test_output_stream_write_raw_bytes() { + test_write("00 ab", |os| os.write_raw_bytes(&[0x00, 0xab])); + + let expected = repeat("01 02 03 04") + .take(2048) + .collect::<Vec<_>>() + .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<u8> + { + 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); + } + } +} diff --git a/src/strx.rs b/src/strx.rs new file mode 100644 index 0000000..af09de2 --- /dev/null +++ b/src/strx.rs @@ -0,0 +1,34 @@ +pub fn remove_to<'s>(s: &'s str, c: char) -> &'s str { + match s.rfind(c) { + Some(pos) => &s[(pos + 1)..], + None => s, + } +} + +pub fn remove_suffix<'s>(s: &'s str, suffix: &str) -> &'s str { + if !s.ends_with(suffix) { + s + } else { + &s[..(s.len() - suffix.len())] + } +} + +#[cfg(test)] +mod test { + + use super::remove_suffix; + use super::remove_to; + + #[test] + fn test_remove_to() { + assert_eq!("aaa", remove_to("aaa", '.')); + assert_eq!("bbb", remove_to("aaa.bbb", '.')); + assert_eq!("ccc", remove_to("aaa.bbb.ccc", '.')); + } + + #[test] + fn test_remove_suffix() { + assert_eq!("bbb", remove_suffix("bbbaaa", "aaa")); + assert_eq!("aaa", remove_suffix("aaa", "bbb")); + } +} diff --git a/src/text_format.rs b/src/text_format.rs new file mode 100644 index 0000000..7ba3721 --- /dev/null +++ b/src/text_format.rs @@ -0,0 +1,328 @@ +//! Protobuf "text format" implementation. +//! +//! Text format message look like this: +//! +//! ```text,ignore +//! size: 17 +//! color: "red" +//! children { +//! size: 18 +//! color: "blue" +//! } +//! children { +//! size: 19 +//! color: "green" +//! } +//! ``` +//! +//! This format is not specified, but it is implemented by all official +//! protobuf implementations, including `protoc` command which can decode +//! and encode messages using text format. + +use core::Message; +use reflect::ReflectFieldRef; +use reflect::ReflectValueRef; +use std; +use std::fmt; +use std::fmt::Write; + +fn quote_bytes_to(bytes: &[u8], buf: &mut String) { + for &c in bytes { + match c { + b'\n' => buf.push_str(r"\n"), + b'\r' => buf.push_str(r"\r"), + b'\t' => buf.push_str(r"\t"), + b'"' => buf.push_str("\\\""), + b'\\' => buf.push_str(r"\\"), + b'\x20'..=b'\x7e' => buf.push(c as char), + _ => { + buf.push('\\'); + buf.push((b'0' + (c >> 6)) as char); + buf.push((b'0' + ((c >> 3) & 7)) as char); + buf.push((b'0' + (c & 7)) as char); + } + } + } +} + +fn quote_escape_bytes_to(bytes: &[u8], buf: &mut String) { + buf.push('"'); + quote_bytes_to(bytes, buf); + buf.push('"'); +} + +#[doc(hidden)] +pub fn quote_escape_bytes(bytes: &[u8]) -> String { + let mut r = String::new(); + quote_escape_bytes_to(bytes, &mut r); + r +} + +#[doc(hidden)] +pub fn unescape_string(string: &str) -> Vec<u8> { + fn parse_if_digit(chars: &mut std::str::Chars) -> u8 { + let mut copy = chars.clone(); + let f = match copy.next() { + None => return 0, + Some(f) => f, + }; + let d = match f { + '0'..='9' => (f as u8 - b'0'), + _ => return 0, + }; + *chars = copy; + d + } + + fn parse_hex_digit(chars: &mut std::str::Chars) -> u8 { + match chars.next().unwrap() { + c @ '0'..='9' => (c as u8) - b'0', + c @ 'a'..='f' => (c as u8) - b'a' + 10, + c @ 'A'..='F' => (c as u8) - b'A' + 10, + _ => panic!("incorrect hex escape"), + } + } + + fn parse_escape_rem(chars: &mut std::str::Chars) -> u8 { + let n = chars.next().unwrap(); + match n { + 'a' => return b'\x07', + 'b' => return b'\x08', + 'f' => return b'\x0c', + 'n' => return b'\n', + 'r' => return b'\r', + 't' => return b'\t', + 'v' => return b'\x0b', + '"' => return b'"', + '\'' => return b'\'', + '0'..='9' => { + let d1 = n as u8 - b'0'; + let d2 = parse_if_digit(chars); + let d3 = parse_if_digit(chars); + return (d1 * 64 + d2 * 8 + d3) as u8; + } + 'x' => { + let d1 = parse_hex_digit(chars); + let d2 = parse_hex_digit(chars); + return d1 * 16 + d2; + } + c => return c as u8, // TODO: validate ASCII + }; + } + + let mut chars = string.chars(); + let mut r = Vec::new(); + + loop { + let f = match chars.next() { + None => return r, + Some(f) => f, + }; + + if f == '\\' { + r.push(parse_escape_rem(&mut chars)); + } else { + r.push(f as u8); // TODO: escape UTF-8 + } + } +} + +fn print_str_to(s: &str, buf: &mut String) { + // TODO: keep printable Unicode + quote_escape_bytes_to(s.as_bytes(), buf); +} + +fn do_indent(buf: &mut String, pretty: bool, indent: usize) { + if pretty && indent > 0 { + for _ in 0..indent { + buf.push_str(" "); + } + } +} + +fn print_start_field( + buf: &mut String, + pretty: bool, + indent: usize, + first: &mut bool, + field_name: &str, +) { + if !*first && !pretty { + buf.push_str(" "); + } + do_indent(buf, pretty, indent); + *first = false; + buf.push_str(field_name); +} + +fn print_end_field(buf: &mut String, pretty: bool) { + if pretty { + buf.push_str("\n"); + } +} + +fn print_field( + buf: &mut String, + pretty: bool, + indent: usize, + first: &mut bool, + field_name: &str, + value: ReflectValueRef, +) { + print_start_field(buf, pretty, indent, first, field_name); + + match value { + ReflectValueRef::Message(m) => { + buf.push_str(" {"); + if pretty { + buf.push_str("\n"); + } + print_to_internal(m, buf, pretty, indent + 1); + do_indent(buf, pretty, indent); + buf.push_str("}"); + } + ReflectValueRef::Enum(e) => { + buf.push_str(": "); + buf.push_str(e.name()); + } + ReflectValueRef::String(s) => { + buf.push_str(": "); + print_str_to(s, buf); + } + ReflectValueRef::Bytes(b) => { + buf.push_str(": "); + quote_escape_bytes_to(b, buf); + } + ReflectValueRef::I32(v) => { + write!(buf, ": {}", v).unwrap(); + } + ReflectValueRef::I64(v) => { + write!(buf, ": {}", v).unwrap(); + } + ReflectValueRef::U32(v) => { + write!(buf, ": {}", v).unwrap(); + } + ReflectValueRef::U64(v) => { + write!(buf, ": {}", v).unwrap(); + } + ReflectValueRef::Bool(v) => { + write!(buf, ": {}", v).unwrap(); + } + ReflectValueRef::F32(v) => { + write!(buf, ": {}", v).unwrap(); + } + ReflectValueRef::F64(v) => { + write!(buf, ": {}", v).unwrap(); + } + } + + print_end_field(buf, pretty); +} + +fn print_to_internal(m: &Message, buf: &mut String, pretty: bool, indent: usize) { + let d = m.descriptor(); + let mut first = true; + for f in d.fields() { + match f.get_reflect(m) { + ReflectFieldRef::Map(map) => { + for (k, v) in map { + print_start_field(buf, pretty, indent, &mut first, f.name()); + buf.push_str(" {"); + if pretty { + buf.push_str("\n"); + } + + let mut entry_first = true; + + print_field(buf, pretty, indent + 1, &mut entry_first, "key", k.as_ref()); + print_field( + buf, + pretty, + indent + 1, + &mut entry_first, + "value", + v.as_ref(), + ); + do_indent(buf, pretty, indent); + buf.push_str("}"); + print_end_field(buf, pretty); + } + } + ReflectFieldRef::Repeated(repeated) => { + // TODO: do not print zeros for v3 + for v in repeated { + print_field(buf, pretty, indent, &mut first, f.name(), v.as_ref()); + } + } + ReflectFieldRef::Optional(optional) => { + if let Some(v) = optional { + print_field(buf, pretty, indent, &mut first, f.name(), v); + } + } + } + } + + // TODO: unknown fields +} + +/// Text-format +pub fn print_to(m: &Message, buf: &mut String) { + print_to_internal(m, buf, false, 0) +} + +fn print_to_string_internal(m: &Message, pretty: bool) -> String { + let mut r = String::new(); + print_to_internal(m, &mut r, pretty, 0); + r.to_string() +} + +/// Text-format +pub fn print_to_string(m: &Message) -> String { + print_to_string_internal(m, false) +} + +/// Text-format to `fmt::Formatter`. +pub fn fmt(m: &Message, f: &mut fmt::Formatter) -> fmt::Result { + let pretty = f.alternate(); + f.write_str(&print_to_string_internal(m, pretty)) +} + +#[cfg(test)] +mod test { + + fn escape(data: &[u8]) -> String { + let mut s = String::with_capacity(data.len() * 4); + super::quote_bytes_to(data, &mut s); + s + } + + fn test_escape_unescape(text: &str, escaped: &str) { + assert_eq!(text.as_bytes(), &super::unescape_string(escaped)[..]); + assert_eq!(escaped, &escape(text.as_bytes())[..]); + } + + #[test] + fn test_print_to_bytes() { + assert_eq!("ab", escape(b"ab")); + assert_eq!("a\\\\023", escape(b"a\\023")); + assert_eq!("a\\r\\n\\t '\\\"\\\\", escape(b"a\r\n\t '\"\\")); + assert_eq!("\\344\\275\\240\\345\\245\\275", escape("ä½ å¥½".as_bytes())); + } + + #[test] + fn test_unescape_string() { + test_escape_unescape("", ""); + test_escape_unescape("aa", "aa"); + test_escape_unescape("\n", "\\n"); + test_escape_unescape("\r", "\\r"); + test_escape_unescape("\t", "\\t"); + test_escape_unescape("ä½ å¥½", "\\344\\275\\240\\345\\245\\275"); + // hex + assert_eq!(b"aaa\x01bbb", &super::unescape_string("aaa\\x01bbb")[..]); + assert_eq!(b"aaa\xcdbbb", &super::unescape_string("aaa\\xCDbbb")[..]); + assert_eq!(b"aaa\xcdbbb", &super::unescape_string("aaa\\xCDbbb")[..]); + // quotes + assert_eq!(b"aaa\"bbb", &super::unescape_string("aaa\\\"bbb")[..]); + assert_eq!(b"aaa\'bbb", &super::unescape_string("aaa\\\'bbb")[..]); + } +} diff --git a/src/types.rs b/src/types.rs new file mode 100644 index 0000000..2c3863a --- /dev/null +++ b/src/types.rs @@ -0,0 +1,685 @@ +//! Implementations of `ProtobufType` for all types. + +use std::marker; +use std::mem; + +#[cfg(feature = "bytes")] +use bytes::Bytes; +#[cfg(feature = "bytes")] +use chars::Chars; + +use core::Message; +use enums::ProtobufEnum; +use error::ProtobufResult; +use parse_from_bytes; +use reflect::ProtobufValue; +use rt; +use stream::CodedInputStream; +use stream::CodedOutputStream; +use unknown::UnknownValues; +use wire_format::WireType; +use zigzag::decode_zig_zag_32; +use zigzag::decode_zig_zag_64; + +/// Protobuf elementary type as generic trait +pub trait ProtobufType { + /// Rust type of value + type Value: ProtobufValue + Clone + 'static; + + /// Wire type when writing to stream + fn wire_type() -> WireType; + + /// Read value from `CodedInputStream` + fn read(is: &mut CodedInputStream) -> ProtobufResult<Self::Value>; + + /// Compute wire size + fn compute_size(value: &Self::Value) -> u32; + + /// Get value from `UnknownValues` + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<Self::Value>; + + /// Compute size adding length prefix if wire type is length delimited + /// (i. e. string, bytes, message) + fn compute_size_with_length_delimiter(value: &Self::Value) -> u32 { + let size = Self::compute_size(value); + if Self::wire_type() == WireType::WireTypeLengthDelimited { + rt::compute_raw_varint32_size(size) + size + } else { + size + } + } + + /// Get previously computed size + #[inline] + fn get_cached_size(value: &Self::Value) -> u32 { + Self::compute_size(value) + } + + /// Get previously cached size with length prefix + #[inline] + fn get_cached_size_with_length_delimiter(value: &Self::Value) -> u32 { + let size = Self::get_cached_size(value); + if Self::wire_type() == WireType::WireTypeLengthDelimited { + rt::compute_raw_varint32_size(size) + size + } else { + size + } + } + + /// Write a value with previously cached size + fn write_with_cached_size( + field_number: u32, + value: &Self::Value, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()>; +} + +/// `float` +pub struct ProtobufTypeFloat; +/// `double` +pub struct ProtobufTypeDouble; +/// `uint32` +pub struct ProtobufTypeInt32; +/// `int64` +pub struct ProtobufTypeInt64; +/// `uint32` +pub struct ProtobufTypeUint32; +/// `uint64` +pub struct ProtobufTypeUint64; +/// `sint32` +pub struct ProtobufTypeSint32; +/// `sint64` +pub struct ProtobufTypeSint64; +/// `fixed32` +pub struct ProtobufTypeFixed32; +/// `fixed64` +pub struct ProtobufTypeFixed64; +/// `sfixed32` +pub struct ProtobufTypeSfixed32; +/// `sfixed64` +pub struct ProtobufTypeSfixed64; +/// `bool` +pub struct ProtobufTypeBool; +/// `string` +pub struct ProtobufTypeString; +/// `bytes` +pub struct ProtobufTypeBytes; +/// Something which should be deleted +pub struct ProtobufTypeChars; + +/// `bytes` as [`Bytes`](bytes::Bytes) +#[cfg(feature = "bytes")] +pub struct ProtobufTypeCarllercheBytes; +/// `string` as [`Chars`](crate::Chars) +#[cfg(feature = "bytes")] +pub struct ProtobufTypeCarllercheChars; + +/// `enum` +pub struct ProtobufTypeEnum<E: ProtobufEnum>(marker::PhantomData<E>); +/// `message` +pub struct ProtobufTypeMessage<M: Message>(marker::PhantomData<M>); + +impl ProtobufType for ProtobufTypeFloat { + type Value = f32; + + fn wire_type() -> WireType { + WireType::WireTypeFixed32 + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<f32> { + is.read_float() + } + + fn compute_size(_value: &f32) -> u32 { + 4 + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<f32> { + unknown_values + .fixed32 + .iter() + .rev() + .next() + .map(|&bits| unsafe { mem::transmute::<u32, f32>(bits) }) + } + + fn write_with_cached_size( + field_number: u32, + value: &f32, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_float(field_number, *value) + } +} + +impl ProtobufType for ProtobufTypeDouble { + type Value = f64; + + fn wire_type() -> WireType { + WireType::WireTypeFixed64 + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<f64> { + is.read_double() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<f64> { + unknown_values + .fixed64 + .iter() + .rev() + .next() + .map(|&bits| unsafe { mem::transmute::<u64, f64>(bits) }) + } + + fn compute_size(_value: &f64) -> u32 { + 8 + } + + fn write_with_cached_size( + field_number: u32, + value: &f64, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_double(field_number, *value) + } +} + +impl ProtobufType for ProtobufTypeInt32 { + type Value = i32; + + fn wire_type() -> WireType { + WireType::WireTypeVarint + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<i32> { + is.read_int32() + } + + fn compute_size(value: &i32) -> u32 { + // See also: https://github.com/protocolbuffers/protobuf/blob/bd00671b924310c0353a730bf8fa77c44e0a9c72/src/google/protobuf/io/coded_stream.h#L1300-L1306 + if *value < 0 { + return 10; + } + rt::compute_raw_varint32_size(*value as u32) + } + + fn write_with_cached_size( + field_number: u32, + value: &i32, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_int32(field_number, *value) + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<i32> { + unknown_values.varint.iter().rev().next().map(|&v| v as i32) + } +} + +impl ProtobufType for ProtobufTypeInt64 { + type Value = i64; + + fn wire_type() -> WireType { + WireType::WireTypeVarint + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<i64> { + is.read_int64() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<i64> { + unknown_values.varint.iter().rev().next().map(|&v| v as i64) + } + + fn compute_size(value: &i64) -> u32 { + rt::compute_raw_varint64_size(*value as u64) + } + + fn write_with_cached_size( + field_number: u32, + value: &i64, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_int64(field_number, *value) + } +} + +impl ProtobufType for ProtobufTypeUint32 { + type Value = u32; + + fn wire_type() -> WireType { + WireType::WireTypeVarint + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<u32> { + is.read_uint32() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<u32> { + unknown_values.varint.iter().rev().next().map(|&v| v as u32) + } + + fn compute_size(value: &u32) -> u32 { + rt::compute_raw_varint32_size(*value) + } + + fn write_with_cached_size( + field_number: u32, + value: &u32, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_uint32(field_number, *value) + } +} + +impl ProtobufType for ProtobufTypeUint64 { + type Value = u64; + + fn wire_type() -> WireType { + WireType::WireTypeVarint + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<u64> { + is.read_uint64() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<u64> { + unknown_values.varint.iter().cloned().rev().next() + } + + fn compute_size(value: &u64) -> u32 { + rt::compute_raw_varint64_size(*value) + } + + fn write_with_cached_size( + field_number: u32, + value: &u64, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_uint64(field_number, *value) + } +} + +impl ProtobufType for ProtobufTypeSint32 { + type Value = i32; + + fn wire_type() -> WireType { + WireType::WireTypeVarint + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<i32> { + is.read_sint32() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<i32> { + ProtobufTypeUint32::get_from_unknown(unknown_values).map(decode_zig_zag_32) + } + + fn compute_size(value: &i32) -> u32 { + rt::value_varint_zigzag_size_no_tag(*value) + } + + fn write_with_cached_size( + field_number: u32, + value: &i32, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_sint32(field_number, *value) + } +} + +impl ProtobufType for ProtobufTypeSint64 { + type Value = i64; + + fn wire_type() -> WireType { + WireType::WireTypeVarint + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<i64> { + is.read_sint64() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<i64> { + ProtobufTypeUint64::get_from_unknown(unknown_values).map(decode_zig_zag_64) + } + + fn compute_size(value: &i64) -> u32 { + rt::value_varint_zigzag_size_no_tag(*value) + } + + fn write_with_cached_size( + field_number: u32, + value: &i64, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_sint64(field_number, *value) + } +} + +impl ProtobufType for ProtobufTypeFixed32 { + type Value = u32; + + fn wire_type() -> WireType { + WireType::WireTypeFixed32 + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<u32> { + is.read_fixed32() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<u32> { + unknown_values.fixed32.iter().cloned().rev().next() + } + + fn compute_size(_value: &u32) -> u32 { + 4 + } + + fn write_with_cached_size( + field_number: u32, + value: &u32, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_fixed32(field_number, *value) + } +} + +impl ProtobufType for ProtobufTypeFixed64 { + type Value = u64; + + fn wire_type() -> WireType { + WireType::WireTypeFixed64 + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<u64> { + is.read_fixed64() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<u64> { + unknown_values.fixed64.iter().cloned().rev().next() + } + + fn compute_size(_value: &u64) -> u32 { + 8 + } + + fn write_with_cached_size( + field_number: u32, + value: &u64, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_fixed64(field_number, *value) + } +} + +impl ProtobufType for ProtobufTypeSfixed32 { + type Value = i32; + + fn wire_type() -> WireType { + WireType::WireTypeFixed32 + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<i32> { + is.read_sfixed32() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<i32> { + ProtobufTypeFixed32::get_from_unknown(unknown_values).map(|u| u as i32) + } + + fn compute_size(_value: &i32) -> u32 { + 4 + } + + fn write_with_cached_size( + field_number: u32, + value: &i32, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_sfixed32(field_number, *value) + } +} + +impl ProtobufType for ProtobufTypeSfixed64 { + type Value = i64; + + fn wire_type() -> WireType { + WireType::WireTypeFixed64 + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<i64> { + is.read_sfixed64() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<i64> { + ProtobufTypeFixed64::get_from_unknown(unknown_values).map(|u| u as i64) + } + + fn compute_size(_value: &i64) -> u32 { + 8 + } + + fn write_with_cached_size( + field_number: u32, + value: &i64, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_sfixed64(field_number, *value) + } +} + +impl ProtobufType for ProtobufTypeBool { + type Value = bool; + + fn wire_type() -> WireType { + WireType::WireTypeVarint + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<bool> { + is.read_bool() + } + + fn get_from_unknown(unknown: &UnknownValues) -> Option<bool> { + unknown.varint.iter().rev().next().map(|&v| v != 0) + } + + fn compute_size(_value: &bool) -> u32 { + 1 + } + + fn write_with_cached_size( + field_number: u32, + value: &bool, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_bool(field_number, *value) + } +} + +impl ProtobufType for ProtobufTypeString { + type Value = String; + + fn wire_type() -> WireType { + WireType::WireTypeLengthDelimited + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<String> { + is.read_string() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<String> { + // TODO: should not panic + ProtobufTypeBytes::get_from_unknown(unknown_values) + .map(|b| String::from_utf8(b).expect("not a valid string")) + } + + fn compute_size(value: &String) -> u32 { + value.len() as u32 + } + + fn write_with_cached_size( + field_number: u32, + value: &String, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_string(field_number, &value) + } +} + +impl ProtobufType for ProtobufTypeBytes { + type Value = Vec<u8>; + + fn wire_type() -> WireType { + WireType::WireTypeLengthDelimited + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<Vec<u8>> { + is.read_bytes() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<Vec<u8>> { + unknown_values.length_delimited.iter().cloned().rev().next() + } + + fn compute_size(value: &Vec<u8>) -> u32 { + value.len() as u32 + } + + fn write_with_cached_size( + field_number: u32, + value: &Vec<u8>, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_bytes(field_number, &value) + } +} + +#[cfg(feature = "bytes")] +impl ProtobufType for ProtobufTypeCarllercheBytes { + type Value = Bytes; + + fn wire_type() -> WireType { + ProtobufTypeBytes::wire_type() + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<Self::Value> { + is.read_carllerche_bytes() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<Bytes> { + ProtobufTypeBytes::get_from_unknown(unknown_values).map(Bytes::from) + } + + fn compute_size(value: &Bytes) -> u32 { + value.len() as u32 + } + + fn write_with_cached_size( + field_number: u32, + value: &Bytes, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_bytes(field_number, &value) + } +} + +#[cfg(feature = "bytes")] +impl ProtobufType for ProtobufTypeCarllercheChars { + type Value = Chars; + + fn wire_type() -> WireType { + ProtobufTypeBytes::wire_type() + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<Self::Value> { + is.read_carllerche_chars() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<Chars> { + ProtobufTypeString::get_from_unknown(unknown_values).map(Chars::from) + } + + fn compute_size(value: &Chars) -> u32 { + value.len() as u32 + } + + fn write_with_cached_size( + field_number: u32, + value: &Chars, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_string(field_number, &value) + } +} + +impl<E: ProtobufEnum + ProtobufValue> ProtobufType for ProtobufTypeEnum<E> { + type Value = E; + + fn wire_type() -> WireType { + WireType::WireTypeVarint + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<E> { + is.read_enum() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<E> { + // TODO: do not panic + ProtobufTypeInt32::get_from_unknown(unknown_values) + .map(|i| E::from_i32(i).expect("not a valid enum value")) + } + + fn compute_size(value: &E) -> u32 { + rt::compute_raw_varint32_size(value.value() as u32) // TODO: wrap + } + + fn write_with_cached_size( + field_number: u32, + value: &E, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_enum_obj(field_number, *value) + } +} + +impl<M: Message + Clone + ProtobufValue> ProtobufType for ProtobufTypeMessage<M> { + type Value = M; + + fn wire_type() -> WireType { + WireType::WireTypeLengthDelimited + } + + fn read(is: &mut CodedInputStream) -> ProtobufResult<M> { + is.read_message() + } + + fn get_from_unknown(unknown_values: &UnknownValues) -> Option<M> { + // TODO: do not panic + unknown_values + .length_delimited + .iter() + .rev() + .next() + .map(|bytes| parse_from_bytes(bytes).expect("cannot parse message")) + } + + fn compute_size(value: &M) -> u32 { + value.compute_size() + } + + fn get_cached_size(value: &M) -> u32 { + value.get_cached_size() + } + + fn write_with_cached_size( + field_number: u32, + value: &Self::Value, + os: &mut CodedOutputStream, + ) -> ProtobufResult<()> { + os.write_tag(field_number, WireType::WireTypeLengthDelimited)?; + os.write_raw_varint32(value.get_cached_size())?; + value.write_to_with_cached_sizes(os)?; + Ok(()) + } +} diff --git a/src/unknown.rs b/src/unknown.rs new file mode 100644 index 0000000..2ab9a94 --- /dev/null +++ b/src/unknown.rs @@ -0,0 +1,325 @@ +use clear::Clear; +use std::collections::hash_map; +use std::collections::hash_map::DefaultHasher; +use std::collections::HashMap; +use std::default::Default; +use std::hash::Hash; +use std::hash::Hasher; +use std::slice; +use stream::wire_format; +use zigzag::encode_zig_zag_32; +use zigzag::encode_zig_zag_64; + +/// Unknown value. +/// +/// See [`UnknownFields`](crate::UnknownFields) for the explanations. +#[derive(Debug)] +pub enum UnknownValue { + /// 32-bit unknown (e. g. `fixed32` or `float`) + Fixed32(u32), + /// 64-bit unknown (e. g. `fixed64` or `double`) + Fixed64(u64), + /// Varint unknown (e. g. `int32` or `bool`) + Varint(u64), + /// Length-delimited unknown (e. g. `message` or `string`) + LengthDelimited(Vec<u8>), +} + +impl UnknownValue { + /// Wire type for this unknown + pub fn wire_type(&self) -> wire_format::WireType { + self.get_ref().wire_type() + } + + /// As ref + pub fn get_ref<'s>(&'s self) -> UnknownValueRef<'s> { + match *self { + UnknownValue::Fixed32(fixed32) => UnknownValueRef::Fixed32(fixed32), + UnknownValue::Fixed64(fixed64) => UnknownValueRef::Fixed64(fixed64), + UnknownValue::Varint(varint) => UnknownValueRef::Varint(varint), + UnknownValue::LengthDelimited(ref bytes) => UnknownValueRef::LengthDelimited(&bytes), + } + } + + /// Construct unknown value from `sint32` value. + pub fn sint32(i: i32) -> UnknownValue { + UnknownValue::Varint(encode_zig_zag_32(i) as u64) + } + + /// Construct unknown value from `sint64` value. + pub fn sint64(i: i64) -> UnknownValue { + UnknownValue::Varint(encode_zig_zag_64(i)) + } +} + +/// Reference to unknown value. +/// +/// See [`UnknownFields`](crate::UnknownFields) for explanations. +pub enum UnknownValueRef<'o> { + /// 32-bit unknown + Fixed32(u32), + /// 64-bit unknown + Fixed64(u64), + /// Varint unknown + Varint(u64), + /// Length-delimited unknown + LengthDelimited(&'o [u8]), +} + +impl<'o> UnknownValueRef<'o> { + /// Wire-type to serialize this unknown + pub fn wire_type(&self) -> wire_format::WireType { + match *self { + UnknownValueRef::Fixed32(_) => wire_format::WireTypeFixed32, + UnknownValueRef::Fixed64(_) => wire_format::WireTypeFixed64, + UnknownValueRef::Varint(_) => wire_format::WireTypeVarint, + UnknownValueRef::LengthDelimited(_) => wire_format::WireTypeLengthDelimited, + } + } +} + +/// Field unknown values. +/// +/// See [`UnknownFields`](crate::UnknownFields) for explanations. +#[derive(Clone, PartialEq, Eq, Debug, Default, Hash)] +pub struct UnknownValues { + /// 32-bit unknowns + pub fixed32: Vec<u32>, + /// 64-bit unknowns + pub fixed64: Vec<u64>, + /// Varint unknowns + pub varint: Vec<u64>, + /// Length-delimited unknowns + pub length_delimited: Vec<Vec<u8>>, +} + +impl UnknownValues { + /// Add unknown value + pub fn add_value(&mut self, value: UnknownValue) { + match value { + UnknownValue::Fixed64(fixed64) => self.fixed64.push(fixed64), + UnknownValue::Fixed32(fixed32) => self.fixed32.push(fixed32), + UnknownValue::Varint(varint) => self.varint.push(varint), + UnknownValue::LengthDelimited(length_delimited) => { + self.length_delimited.push(length_delimited) + } + }; + } + + /// Iterate over unknown values + pub fn iter<'s>(&'s self) -> UnknownValuesIter<'s> { + UnknownValuesIter { + fixed32: self.fixed32.iter(), + fixed64: self.fixed64.iter(), + varint: self.varint.iter(), + length_delimited: self.length_delimited.iter(), + } + } +} + +impl<'a> IntoIterator for &'a UnknownValues { + type Item = UnknownValueRef<'a>; + type IntoIter = UnknownValuesIter<'a>; + + fn into_iter(self) -> UnknownValuesIter<'a> { + self.iter() + } +} + +/// Iterator over unknown values +pub struct UnknownValuesIter<'o> { + fixed32: slice::Iter<'o, u32>, + fixed64: slice::Iter<'o, u64>, + varint: slice::Iter<'o, u64>, + length_delimited: slice::Iter<'o, Vec<u8>>, +} + +impl<'o> Iterator for UnknownValuesIter<'o> { + type Item = UnknownValueRef<'o>; + + fn next(&mut self) -> Option<UnknownValueRef<'o>> { + let fixed32 = self.fixed32.next(); + if fixed32.is_some() { + return Some(UnknownValueRef::Fixed32(*fixed32.unwrap())); + } + let fixed64 = self.fixed64.next(); + if fixed64.is_some() { + return Some(UnknownValueRef::Fixed64(*fixed64.unwrap())); + } + let varint = self.varint.next(); + if varint.is_some() { + return Some(UnknownValueRef::Varint(*varint.unwrap())); + } + let length_delimited = self.length_delimited.next(); + if length_delimited.is_some() { + return Some(UnknownValueRef::LengthDelimited(&length_delimited.unwrap())); + } + None + } +} + +/// Hold "unknown" fields in parsed message. +/// +/// Field may be unknown if it they are added in newer version of `.proto`. +/// Unknown fields are stored in `UnknownFields` structure, so +/// protobuf message could process messages without losing data. +/// +/// For example, in this operation: load from DB, modify, store to DB, +/// even when working with older `.proto` file, new fields won't be lost. +#[derive(Clone, PartialEq, Eq, Debug, Default)] +pub struct UnknownFields { + /// The map. + // option is needed, because HashMap constructor performs allocation, + // and very expensive + // TODO: hide + pub fields: Option<Box<HashMap<u32, UnknownValues>>>, +} + +/// Very simple hash implementation of `Hash` for `UnknownFields`. +/// Since map is unordered, we cannot put entry hashes into hasher, +/// instead we summing hashes of entries. +impl Hash for UnknownFields { + fn hash<H: Hasher>(&self, state: &mut H) { + if let Some(ref map) = self.fields { + if !map.is_empty() { + let mut hash: u64 = 0; + for (k, v) in &**map { + let mut entry_hasher = DefaultHasher::new(); + Hash::hash(&(k, v), &mut entry_hasher); + hash = hash.wrapping_add(entry_hasher.finish()); + } + Hash::hash(&map.len(), state); + Hash::hash(&hash, state); + } + } + } +} + +impl UnknownFields { + /// Empty unknown fields + pub fn new() -> UnknownFields { + Default::default() + } + + fn init_map(&mut self) { + if self.fields.is_none() { + self.fields = Some(Default::default()); + } + } + + fn find_field<'a>(&'a mut self, number: &'a u32) -> &'a mut UnknownValues { + self.init_map(); + + match self.fields.as_mut().unwrap().entry(*number) { + hash_map::Entry::Occupied(e) => e.into_mut(), + hash_map::Entry::Vacant(e) => e.insert(Default::default()), + } + } + + /// Add unknown fixed 32-bit + pub fn add_fixed32(&mut self, number: u32, fixed32: u32) { + self.find_field(&number).fixed32.push(fixed32); + } + + /// Add unknown fixed 64-bit + pub fn add_fixed64(&mut self, number: u32, fixed64: u64) { + self.find_field(&number).fixed64.push(fixed64); + } + + /// Add unknown varint + pub fn add_varint(&mut self, number: u32, varint: u64) { + self.find_field(&number).varint.push(varint); + } + + /// Add unknown length delimited + pub fn add_length_delimited(&mut self, number: u32, length_delimited: Vec<u8>) { + self.find_field(&number) + .length_delimited + .push(length_delimited); + } + + /// Add unknown value + pub fn add_value(&mut self, number: u32, value: UnknownValue) { + self.find_field(&number).add_value(value); + } + + /// Iterate over all unknowns + pub fn iter<'s>(&'s self) -> UnknownFieldsIter<'s> { + UnknownFieldsIter { + entries: self.fields.as_ref().map(|m| m.iter()), + } + } + + /// Find unknown field by number + pub fn get(&self, field_number: u32) -> Option<&UnknownValues> { + match self.fields { + Some(ref map) => map.get(&field_number), + None => None, + } + } +} + +impl Clear for UnknownFields { + fn clear(&mut self) { + if let Some(ref mut fields) = self.fields { + fields.clear(); + } + } +} + +impl<'a> IntoIterator for &'a UnknownFields { + type Item = (u32, &'a UnknownValues); + type IntoIter = UnknownFieldsIter<'a>; + + fn into_iter(self) -> UnknownFieldsIter<'a> { + self.iter() + } +} + +/// Iterator over [`UnknownFields`](crate::UnknownFields) +pub struct UnknownFieldsIter<'s> { + entries: Option<hash_map::Iter<'s, u32, UnknownValues>>, +} + +impl<'s> Iterator for UnknownFieldsIter<'s> { + type Item = (u32, &'s UnknownValues); + + fn next(&mut self) -> Option<(u32, &'s UnknownValues)> { + match self.entries { + Some(ref mut entries) => entries.next().map(|(&number, values)| (number, values)), + None => None, + } + } +} + +#[cfg(test)] +mod test { + use super::UnknownFields; + use std::collections::hash_map::DefaultHasher; + use std::hash::Hash; + use std::hash::Hasher; + + #[test] + fn unknown_fields_hash() { + let mut unknown_fields_1 = UnknownFields::new(); + let mut unknown_fields_2 = UnknownFields::new(); + + // Check field order is not important + + unknown_fields_1.add_fixed32(10, 222); + unknown_fields_1.add_fixed32(10, 223); + unknown_fields_1.add_fixed64(14, 224); + + unknown_fields_2.add_fixed32(10, 222); + unknown_fields_2.add_fixed64(14, 224); + unknown_fields_2.add_fixed32(10, 223); + + fn hash(unknown_fields: &UnknownFields) -> u64 { + let mut hasher = DefaultHasher::new(); + Hash::hash(unknown_fields, &mut hasher); + hasher.finish() + } + + assert_eq!(hash(&unknown_fields_1), hash(&unknown_fields_2)); + } +} diff --git a/src/varint.rs b/src/varint.rs new file mode 100644 index 0000000..1f1cb1c --- /dev/null +++ b/src/varint.rs @@ -0,0 +1,35 @@ +/// Encode u64 as varint. +/// Panics if buffer length is less than 10. +#[inline] +pub fn encode_varint64(mut value: u64, buf: &mut [u8]) -> usize { + assert!(buf.len() >= 10); + + unsafe { + let mut i = 0; + while (value & !0x7F) > 0 { + *buf.get_unchecked_mut(i) = ((value & 0x7F) | 0x80) as u8; + value >>= 7; + i += 1; + } + *buf.get_unchecked_mut(i) = value as u8; + i + 1 + } +} + +/// Encode u32 value as varint. +/// Panics if buffer length is less than 5. +#[inline] +pub fn encode_varint32(mut value: u32, buf: &mut [u8]) -> usize { + assert!(buf.len() >= 5); + + unsafe { + let mut i = 0; + while (value & !0x7F) > 0 { + *buf.get_unchecked_mut(i) = ((value & 0x7F) | 0x80) as u8; + value >>= 7; + i += 1; + } + *buf.get_unchecked_mut(i) = value as u8; + i + 1 + } +} diff --git a/src/well_known_types/any.rs b/src/well_known_types/any.rs new file mode 100644 index 0000000..25166a0 --- /dev/null +++ b/src/well_known_types/any.rs @@ -0,0 +1,368 @@ +// This file is generated by rust-protobuf 2.14.0-pre. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/protobuf/any.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Any { + // message fields + pub type_url: ::std::string::String, + pub value: ::std::vec::Vec<u8>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Any { + fn default() -> &'a Any { + <Any as ::protobuf::Message>::default_instance() + } +} + +impl Any { + pub fn new() -> Any { + ::std::default::Default::default() + } + + // string type_url = 1; + + + pub fn get_type_url(&self) -> &str { + &self.type_url + } + pub fn clear_type_url(&mut self) { + self.type_url.clear(); + } + + // Param is passed by value, moved + pub fn set_type_url(&mut self, v: ::std::string::String) { + self.type_url = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_type_url(&mut self) -> &mut ::std::string::String { + &mut self.type_url + } + + // Take field + pub fn take_type_url(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.type_url, ::std::string::String::new()) + } + + // bytes value = 2; + + + pub fn get_value(&self) -> &[u8] { + &self.value + } + pub fn clear_value(&mut self) { + self.value.clear(); + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) { + self.value = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> { + &mut self.value + } + + // Take field + pub fn take_value(&mut self) -> ::std::vec::Vec<u8> { + ::std::mem::replace(&mut self.value, ::std::vec::Vec::new()) + } +} + +impl ::protobuf::Message for Any { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.type_url)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.type_url.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.type_url); + } + if !self.value.is_empty() { + my_size += ::protobuf::rt::bytes_size(2, &self.value); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.type_url.is_empty() { + os.write_string(1, &self.type_url)?; + } + if !self.value.is_empty() { + os.write_bytes(2, &self.value)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Any { + Any::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "type_url", + |m: &Any| { &m.type_url }, + |m: &mut Any| { &mut m.type_url }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "value", + |m: &Any| { &m.value }, + |m: &mut Any| { &mut m.value }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Any>( + "Any", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Any { + static mut instance: ::protobuf::lazy::Lazy<Any> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Any::new) + } + } +} + +impl ::protobuf::Clear for Any { + fn clear(&mut self) { + self.type_url.clear(); + self.value.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Any { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Any { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x19google/protobuf/any.proto\x12\x0fgoogle.protobuf\"6\n\x03Any\x12\ + \x19\n\x08type_url\x18\x01\x20\x01(\tR\x07typeUrl\x12\x14\n\x05value\x18\ + \x02\x20\x01(\x0cR\x05valueBo\n\x13com.google.protobufB\x08AnyProtoP\x01\ + Z%github.com/golang/protobuf/ptypes/any\xa2\x02\x03GPB\xaa\x02\x1eGoogle\ + .Protobuf.WellKnownTypesJ\x8a&\n\x07\x12\x05\x1e\0\x8a\x01\x01\n\xcc\x0c\ + \n\x01\x0c\x12\x03\x1e\0\x122\xc1\x0c\x20Protocol\x20Buffers\x20-\x20Goo\ + gle's\x20data\x20interchange\x20format\n\x20Copyright\x202008\x20Google\ + \x20Inc.\x20\x20All\x20rights\x20reserved.\n\x20https://developers.googl\ + e.com/protocol-buffers/\n\n\x20Redistribution\x20and\x20use\x20in\x20sou\ + rce\x20and\x20binary\x20forms,\x20with\x20or\x20without\n\x20modificatio\ + n,\x20are\x20permitted\x20provided\x20that\x20the\x20following\x20condit\ + ions\x20are\n\x20met:\n\n\x20\x20\x20\x20\x20*\x20Redistributions\x20of\ + \x20source\x20code\x20must\x20retain\x20the\x20above\x20copyright\n\x20n\ + otice,\x20this\x20list\x20of\x20conditions\x20and\x20the\x20following\ + \x20disclaimer.\n\x20\x20\x20\x20\x20*\x20Redistributions\x20in\x20binar\ + y\x20form\x20must\x20reproduce\x20the\x20above\n\x20copyright\x20notice,\ + \x20this\x20list\x20of\x20conditions\x20and\x20the\x20following\x20discl\ + aimer\n\x20in\x20the\x20documentation\x20and/or\x20other\x20materials\ + \x20provided\x20with\x20the\n\x20distribution.\n\x20\x20\x20\x20\x20*\ + \x20Neither\x20the\x20name\x20of\x20Google\x20Inc.\x20nor\x20the\x20name\ + s\x20of\x20its\n\x20contributors\x20may\x20be\x20used\x20to\x20endorse\ + \x20or\x20promote\x20products\x20derived\x20from\n\x20this\x20software\ + \x20without\x20specific\x20prior\x20written\x20permission.\n\n\x20THIS\ + \x20SOFTWARE\x20IS\x20PROVIDED\x20BY\x20THE\x20COPYRIGHT\x20HOLDERS\x20A\ + ND\x20CONTRIBUTORS\n\x20\"AS\x20IS\"\x20AND\x20ANY\x20EXPRESS\x20OR\x20I\ + MPLIED\x20WARRANTIES,\x20INCLUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\ + \x20THE\x20IMPLIED\x20WARRANTIES\x20OF\x20MERCHANTABILITY\x20AND\x20FITN\ + ESS\x20FOR\n\x20A\x20PARTICULAR\x20PURPOSE\x20ARE\x20DISCLAIMED.\x20IN\ + \x20NO\x20EVENT\x20SHALL\x20THE\x20COPYRIGHT\n\x20OWNER\x20OR\x20CONTRIB\ + UTORS\x20BE\x20LIABLE\x20FOR\x20ANY\x20DIRECT,\x20INDIRECT,\x20INCIDENTA\ + L,\n\x20SPECIAL,\x20EXEMPLARY,\x20OR\x20CONSEQUENTIAL\x20DAMAGES\x20(INC\ + LUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\x20PROCUREMENT\x20OF\x20SUBSTI\ + TUTE\x20GOODS\x20OR\x20SERVICES;\x20LOSS\x20OF\x20USE,\n\x20DATA,\x20OR\ + \x20PROFITS;\x20OR\x20BUSINESS\x20INTERRUPTION)\x20HOWEVER\x20CAUSED\x20\ + AND\x20ON\x20ANY\n\x20THEORY\x20OF\x20LIABILITY,\x20WHETHER\x20IN\x20CON\ + TRACT,\x20STRICT\x20LIABILITY,\x20OR\x20TORT\n\x20(INCLUDING\x20NEGLIGEN\ + CE\x20OR\x20OTHERWISE)\x20ARISING\x20IN\x20ANY\x20WAY\x20OUT\x20OF\x20TH\ + E\x20USE\n\x20OF\x20THIS\x20SOFTWARE,\x20EVEN\x20IF\x20ADVISED\x20OF\x20\ + THE\x20POSSIBILITY\x20OF\x20SUCH\x20DAMAGE.\n\n\x08\n\x01\x02\x12\x03\ + \x20\0\x18\n\x08\n\x01\x08\x12\x03\"\0;\n\t\n\x02\x08%\x12\x03\"\0;\n\ + \x08\n\x01\x08\x12\x03#\0<\n\t\n\x02\x08\x0b\x12\x03#\0<\n\x08\n\x01\x08\ + \x12\x03$\0,\n\t\n\x02\x08\x01\x12\x03$\0,\n\x08\n\x01\x08\x12\x03%\0)\n\ + \t\n\x02\x08\x08\x12\x03%\0)\n\x08\n\x01\x08\x12\x03&\0\"\n\t\n\x02\x08\ + \n\x12\x03&\0\"\n\x08\n\x01\x08\x12\x03'\0!\n\t\n\x02\x08$\x12\x03'\0!\n\ + \x81\x0f\n\x02\x04\0\x12\x05o\0\x8a\x01\x01\x1a\xf3\x0e\x20`Any`\x20cont\ + ains\x20an\x20arbitrary\x20serialized\x20protocol\x20buffer\x20message\ + \x20along\x20with\x20a\n\x20URL\x20that\x20describes\x20the\x20type\x20o\ + f\x20the\x20serialized\x20message.\n\n\x20Protobuf\x20library\x20provide\ + s\x20support\x20to\x20pack/unpack\x20Any\x20values\x20in\x20the\x20form\ + \n\x20of\x20utility\x20functions\x20or\x20additional\x20generated\x20met\ + hods\x20of\x20the\x20Any\x20type.\n\n\x20Example\x201:\x20Pack\x20and\ + \x20unpack\x20a\x20message\x20in\x20C++.\n\n\x20\x20\x20\x20\x20Foo\x20f\ + oo\x20=\x20...;\n\x20\x20\x20\x20\x20Any\x20any;\n\x20\x20\x20\x20\x20an\ + y.PackFrom(foo);\n\x20\x20\x20\x20\x20...\n\x20\x20\x20\x20\x20if\x20(an\ + y.UnpackTo(&foo))\x20{\n\x20\x20\x20\x20\x20\x20\x20...\n\x20\x20\x20\ + \x20\x20}\n\n\x20Example\x202:\x20Pack\x20and\x20unpack\x20a\x20message\ + \x20in\x20Java.\n\n\x20\x20\x20\x20\x20Foo\x20foo\x20=\x20...;\n\x20\x20\ + \x20\x20\x20Any\x20any\x20=\x20Any.pack(foo);\n\x20\x20\x20\x20\x20...\n\ + \x20\x20\x20\x20\x20if\x20(any.is(Foo.class))\x20{\n\x20\x20\x20\x20\x20\ + \x20\x20foo\x20=\x20any.unpack(Foo.class);\n\x20\x20\x20\x20\x20}\n\n\ + \x20\x20Example\x203:\x20Pack\x20and\x20unpack\x20a\x20message\x20in\x20\ + Python.\n\n\x20\x20\x20\x20\x20foo\x20=\x20Foo(...)\n\x20\x20\x20\x20\ + \x20any\x20=\x20Any()\n\x20\x20\x20\x20\x20any.Pack(foo)\n\x20\x20\x20\ + \x20\x20...\n\x20\x20\x20\x20\x20if\x20any.Is(Foo.DESCRIPTOR):\n\x20\x20\ + \x20\x20\x20\x20\x20any.Unpack(foo)\n\x20\x20\x20\x20\x20\x20\x20...\n\n\ + \x20The\x20pack\x20methods\x20provided\x20by\x20protobuf\x20library\x20w\ + ill\x20by\x20default\x20use\n\x20'type.googleapis.com/full.type.name'\ + \x20as\x20the\x20type\x20URL\x20and\x20the\x20unpack\n\x20methods\x20onl\ + y\x20use\x20the\x20fully\x20qualified\x20type\x20name\x20after\x20the\ + \x20last\x20'/'\n\x20in\x20the\x20type\x20URL,\x20for\x20example\x20\"fo\ + o.bar.com/x/y.z\"\x20will\x20yield\x20type\n\x20name\x20\"y.z\".\n\n\n\ + \x20JSON\n\x20====\n\x20The\x20JSON\x20representation\x20of\x20an\x20`An\ + y`\x20value\x20uses\x20the\x20regular\n\x20representation\x20of\x20the\ + \x20deserialized,\x20embedded\x20message,\x20with\x20an\n\x20additional\ + \x20field\x20`@type`\x20which\x20contains\x20the\x20type\x20URL.\x20Exam\ + ple:\n\n\x20\x20\x20\x20\x20package\x20google.profile;\n\x20\x20\x20\x20\ + \x20message\x20Person\x20{\n\x20\x20\x20\x20\x20\x20\x20string\x20first_\ + name\x20=\x201;\n\x20\x20\x20\x20\x20\x20\x20string\x20last_name\x20=\ + \x202;\n\x20\x20\x20\x20\x20}\n\n\x20\x20\x20\x20\x20{\n\x20\x20\x20\x20\ + \x20\x20\x20\"@type\":\x20\"type.googleapis.com/google.profile.Person\",\ + \n\x20\x20\x20\x20\x20\x20\x20\"firstName\":\x20<string>,\n\x20\x20\x20\ + \x20\x20\x20\x20\"lastName\":\x20<string>\n\x20\x20\x20\x20\x20}\n\n\x20\ + If\x20the\x20embedded\x20message\x20type\x20is\x20well-known\x20and\x20h\ + as\x20a\x20custom\x20JSON\n\x20representation,\x20that\x20representation\ + \x20will\x20be\x20embedded\x20adding\x20a\x20field\n\x20`value`\x20which\ + \x20holds\x20the\x20custom\x20JSON\x20in\x20addition\x20to\x20the\x20`@t\ + ype`\n\x20field.\x20Example\x20(for\x20message\x20[google.protobuf.Durat\ + ion][]):\n\n\x20\x20\x20\x20\x20{\n\x20\x20\x20\x20\x20\x20\x20\"@type\"\ + :\x20\"type.googleapis.com/google.protobuf.Duration\",\n\x20\x20\x20\x20\ + \x20\x20\x20\"value\":\x20\"1.212s\"\n\x20\x20\x20\x20\x20}\n\n\n\n\n\ + \x03\x04\0\x01\x12\x03o\x08\x0b\n\xe4\x07\n\x04\x04\0\x02\0\x12\x04\x86\ + \x01\x02\x16\x1a\xd5\x07\x20A\x20URL/resource\x20name\x20whose\x20conten\ + t\x20describes\x20the\x20type\x20of\x20the\n\x20serialized\x20protocol\ + \x20buffer\x20message.\n\n\x20For\x20URLs\x20which\x20use\x20the\x20sche\ + me\x20`http`,\x20`https`,\x20or\x20no\x20scheme,\x20the\n\x20following\ + \x20restrictions\x20and\x20interpretations\x20apply:\n\n\x20*\x20If\x20n\ + o\x20scheme\x20is\x20provided,\x20`https`\x20is\x20assumed.\n\x20*\x20Th\ + e\x20last\x20segment\x20of\x20the\x20URL's\x20path\x20must\x20represent\ + \x20the\x20fully\n\x20\x20\x20qualified\x20name\x20of\x20the\x20type\x20\ + (as\x20in\x20`path/google.protobuf.Duration`).\n\x20\x20\x20The\x20name\ + \x20should\x20be\x20in\x20a\x20canonical\x20form\x20(e.g.,\x20leading\ + \x20\".\"\x20is\n\x20\x20\x20not\x20accepted).\n\x20*\x20An\x20HTTP\x20G\ + ET\x20on\x20the\x20URL\x20must\x20yield\x20a\x20[google.protobuf.Type][]\ + \n\x20\x20\x20value\x20in\x20binary\x20format,\x20or\x20produce\x20an\ + \x20error.\n\x20*\x20Applications\x20are\x20allowed\x20to\x20cache\x20lo\ + okup\x20results\x20based\x20on\x20the\n\x20\x20\x20URL,\x20or\x20have\ + \x20them\x20precompiled\x20into\x20a\x20binary\x20to\x20avoid\x20any\n\ + \x20\x20\x20lookup.\x20Therefore,\x20binary\x20compatibility\x20needs\ + \x20to\x20be\x20preserved\n\x20\x20\x20on\x20changes\x20to\x20types.\x20\ + (Use\x20versioned\x20type\x20names\x20to\x20manage\n\x20\x20\x20breaking\ + \x20changes.)\n\n\x20Schemes\x20other\x20than\x20`http`,\x20`https`\x20(\ + or\x20the\x20empty\x20scheme)\x20might\x20be\n\x20used\x20with\x20implem\ + entation\x20specific\x20semantics.\n\n\n\r\n\x05\x04\0\x02\0\x05\x12\x04\ + \x86\x01\x02\x08\n\r\n\x05\x04\0\x02\0\x01\x12\x04\x86\x01\t\x11\n\r\n\ + \x05\x04\0\x02\0\x03\x12\x04\x86\x01\x14\x15\nW\n\x04\x04\0\x02\x01\x12\ + \x04\x89\x01\x02\x12\x1aI\x20Must\x20be\x20a\x20valid\x20serialized\x20p\ + rotocol\x20buffer\x20of\x20the\x20above\x20specified\x20type.\n\n\r\n\ + \x05\x04\0\x02\x01\x05\x12\x04\x89\x01\x02\x07\n\r\n\x05\x04\0\x02\x01\ + \x01\x12\x04\x89\x01\x08\r\n\r\n\x05\x04\0\x02\x01\x03\x12\x04\x89\x01\ + \x10\x11b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/src/well_known_types/api.rs b/src/well_known_types/api.rs new file mode 100644 index 0000000..c4848f2 --- /dev/null +++ b/src/well_known_types/api.rs @@ -0,0 +1,1296 @@ +// This file is generated by rust-protobuf 2.14.0-pre. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/protobuf/api.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Api { + // message fields + pub name: ::std::string::String, + pub methods: ::protobuf::RepeatedField<Method>, + pub options: ::protobuf::RepeatedField<::protobuf::well_known_types::Option>, + pub version: ::std::string::String, + pub source_context: ::protobuf::SingularPtrField<::protobuf::well_known_types::SourceContext>, + pub mixins: ::protobuf::RepeatedField<Mixin>, + pub syntax: ::protobuf::well_known_types::Syntax, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Api { + fn default() -> &'a Api { + <Api as ::protobuf::Message>::default_instance() + } +} + +impl Api { + pub fn new() -> Api { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = 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 { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // repeated .google.protobuf.Method methods = 2; + + + pub fn get_methods(&self) -> &[Method] { + &self.methods + } + pub fn clear_methods(&mut self) { + self.methods.clear(); + } + + // Param is passed by value, moved + pub fn set_methods(&mut self, v: ::protobuf::RepeatedField<Method>) { + self.methods = v; + } + + // Mutable pointer to the field. + pub fn mut_methods(&mut self) -> &mut ::protobuf::RepeatedField<Method> { + &mut self.methods + } + + // Take field + pub fn take_methods(&mut self) -> ::protobuf::RepeatedField<Method> { + ::std::mem::replace(&mut self.methods, ::protobuf::RepeatedField::new()) + } + + // repeated .google.protobuf.Option options = 3; + + + pub fn get_options(&self) -> &[::protobuf::well_known_types::Option] { + &self.options + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::Option>) { + self.options = v; + } + + // Mutable pointer to the field. + pub fn mut_options(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::Option> { + &mut self.options + } + + // Take field + pub fn take_options(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::Option> { + ::std::mem::replace(&mut self.options, ::protobuf::RepeatedField::new()) + } + + // string version = 4; + + + pub fn get_version(&self) -> &str { + &self.version + } + pub fn clear_version(&mut self) { + self.version.clear(); + } + + // Param is passed by value, moved + pub fn set_version(&mut self, v: ::std::string::String) { + self.version = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_version(&mut self) -> &mut ::std::string::String { + &mut self.version + } + + // Take field + pub fn take_version(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.version, ::std::string::String::new()) + } + + // .google.protobuf.SourceContext source_context = 5; + + + pub fn get_source_context(&self) -> &::protobuf::well_known_types::SourceContext { + self.source_context.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::SourceContext::default_instance()) + } + pub fn clear_source_context(&mut self) { + self.source_context.clear(); + } + + pub fn has_source_context(&self) -> bool { + self.source_context.is_some() + } + + // Param is passed by value, moved + pub fn set_source_context(&mut self, v: ::protobuf::well_known_types::SourceContext) { + self.source_context = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_source_context(&mut self) -> &mut ::protobuf::well_known_types::SourceContext { + if self.source_context.is_none() { + self.source_context.set_default(); + } + self.source_context.as_mut().unwrap() + } + + // Take field + pub fn take_source_context(&mut self) -> ::protobuf::well_known_types::SourceContext { + self.source_context.take().unwrap_or_else(|| ::protobuf::well_known_types::SourceContext::new()) + } + + // repeated .google.protobuf.Mixin mixins = 6; + + + pub fn get_mixins(&self) -> &[Mixin] { + &self.mixins + } + pub fn clear_mixins(&mut self) { + self.mixins.clear(); + } + + // Param is passed by value, moved + pub fn set_mixins(&mut self, v: ::protobuf::RepeatedField<Mixin>) { + self.mixins = v; + } + + // Mutable pointer to the field. + pub fn mut_mixins(&mut self) -> &mut ::protobuf::RepeatedField<Mixin> { + &mut self.mixins + } + + // Take field + pub fn take_mixins(&mut self) -> ::protobuf::RepeatedField<Mixin> { + ::std::mem::replace(&mut self.mixins, ::protobuf::RepeatedField::new()) + } + + // .google.protobuf.Syntax syntax = 7; + + + pub fn get_syntax(&self) -> ::protobuf::well_known_types::Syntax { + self.syntax + } + pub fn clear_syntax(&mut self) { + self.syntax = ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2; + } + + // Param is passed by value, moved + pub fn set_syntax(&mut self, v: ::protobuf::well_known_types::Syntax) { + self.syntax = v; + } +} + +impl ::protobuf::Message for Api { + fn is_initialized(&self) -> bool { + for v in &self.methods { + if !v.is_initialized() { + return false; + } + }; + for v in &self.options { + if !v.is_initialized() { + return false; + } + }; + for v in &self.source_context { + if !v.is_initialized() { + return false; + } + }; + for v in &self.mixins { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.methods)?; + }, + 3 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.options)?; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.version)?; + }, + 5 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.source_context)?; + }, + 6 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mixins)?; + }, + 7 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 7, &mut self.unknown_fields)? + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + for value in &self.methods { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.options { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.version.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.version); + } + if let Some(ref v) = self.source_context.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + for value in &self.mixins { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if self.syntax != ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2 { + my_size += ::protobuf::rt::enum_size(7, self.syntax); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + for v in &self.methods { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.options { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.version.is_empty() { + os.write_string(4, &self.version)?; + } + if let Some(ref v) = self.source_context.as_ref() { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + for v in &self.mixins { + os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if self.syntax != ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2 { + os.write_enum(7, self.syntax.value())?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Api { + Api::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Api| { &m.name }, + |m: &mut Api| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Method>>( + "methods", + |m: &Api| { &m.methods }, + |m: &mut Api| { &mut m.methods }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Option>>( + "options", + |m: &Api| { &m.options }, + |m: &mut Api| { &mut m.options }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "version", + |m: &Api| { &m.version }, + |m: &mut Api| { &mut m.version }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::SourceContext>>( + "source_context", + |m: &Api| { &m.source_context }, + |m: &mut Api| { &mut m.source_context }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Mixin>>( + "mixins", + |m: &Api| { &m.mixins }, + |m: &mut Api| { &mut m.mixins }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<::protobuf::well_known_types::Syntax>>( + "syntax", + |m: &Api| { &m.syntax }, + |m: &mut Api| { &mut m.syntax }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Api>( + "Api", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Api { + static mut instance: ::protobuf::lazy::Lazy<Api> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Api::new) + } + } +} + +impl ::protobuf::Clear for Api { + fn clear(&mut self) { + self.name.clear(); + self.methods.clear(); + self.options.clear(); + self.version.clear(); + self.source_context.clear(); + self.mixins.clear(); + self.syntax = ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Api { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Api { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Method { + // message fields + pub name: ::std::string::String, + pub request_type_url: ::std::string::String, + pub request_streaming: bool, + pub response_type_url: ::std::string::String, + pub response_streaming: bool, + pub options: ::protobuf::RepeatedField<::protobuf::well_known_types::Option>, + pub syntax: ::protobuf::well_known_types::Syntax, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Method { + fn default() -> &'a Method { + <Method as ::protobuf::Message>::default_instance() + } +} + +impl Method { + pub fn new() -> Method { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = 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 { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string request_type_url = 2; + + + pub fn get_request_type_url(&self) -> &str { + &self.request_type_url + } + pub fn clear_request_type_url(&mut self) { + self.request_type_url.clear(); + } + + // Param is passed by value, moved + pub fn set_request_type_url(&mut self, v: ::std::string::String) { + self.request_type_url = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_request_type_url(&mut self) -> &mut ::std::string::String { + &mut self.request_type_url + } + + // Take field + pub fn take_request_type_url(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.request_type_url, ::std::string::String::new()) + } + + // bool request_streaming = 3; + + + pub fn get_request_streaming(&self) -> bool { + self.request_streaming + } + pub fn clear_request_streaming(&mut self) { + self.request_streaming = false; + } + + // Param is passed by value, moved + pub fn set_request_streaming(&mut self, v: bool) { + self.request_streaming = v; + } + + // string response_type_url = 4; + + + pub fn get_response_type_url(&self) -> &str { + &self.response_type_url + } + pub fn clear_response_type_url(&mut self) { + self.response_type_url.clear(); + } + + // Param is passed by value, moved + pub fn set_response_type_url(&mut self, v: ::std::string::String) { + self.response_type_url = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_response_type_url(&mut self) -> &mut ::std::string::String { + &mut self.response_type_url + } + + // Take field + pub fn take_response_type_url(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.response_type_url, ::std::string::String::new()) + } + + // bool response_streaming = 5; + + + pub fn get_response_streaming(&self) -> bool { + self.response_streaming + } + pub fn clear_response_streaming(&mut self) { + self.response_streaming = false; + } + + // Param is passed by value, moved + pub fn set_response_streaming(&mut self, v: bool) { + self.response_streaming = v; + } + + // repeated .google.protobuf.Option options = 6; + + + pub fn get_options(&self) -> &[::protobuf::well_known_types::Option] { + &self.options + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::Option>) { + self.options = v; + } + + // Mutable pointer to the field. + pub fn mut_options(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::Option> { + &mut self.options + } + + // Take field + pub fn take_options(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::Option> { + ::std::mem::replace(&mut self.options, ::protobuf::RepeatedField::new()) + } + + // .google.protobuf.Syntax syntax = 7; + + + pub fn get_syntax(&self) -> ::protobuf::well_known_types::Syntax { + self.syntax + } + pub fn clear_syntax(&mut self) { + self.syntax = ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2; + } + + // Param is passed by value, moved + pub fn set_syntax(&mut self, v: ::protobuf::well_known_types::Syntax) { + self.syntax = v; + } +} + +impl ::protobuf::Message for Method { + fn is_initialized(&self) -> bool { + for v in &self.options { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.request_type_url)?; + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.request_streaming = tmp; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.response_type_url)?; + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.response_streaming = tmp; + }, + 6 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.options)?; + }, + 7 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 7, &mut self.unknown_fields)? + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.request_type_url.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.request_type_url); + } + if self.request_streaming != false { + my_size += 2; + } + if !self.response_type_url.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.response_type_url); + } + if self.response_streaming != false { + my_size += 2; + } + for value in &self.options { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if self.syntax != ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2 { + my_size += ::protobuf::rt::enum_size(7, self.syntax); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.request_type_url.is_empty() { + os.write_string(2, &self.request_type_url)?; + } + if self.request_streaming != false { + os.write_bool(3, self.request_streaming)?; + } + if !self.response_type_url.is_empty() { + os.write_string(4, &self.response_type_url)?; + } + if self.response_streaming != false { + os.write_bool(5, self.response_streaming)?; + } + for v in &self.options { + os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if self.syntax != ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2 { + os.write_enum(7, self.syntax.value())?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Method { + Method::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Method| { &m.name }, + |m: &mut Method| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "request_type_url", + |m: &Method| { &m.request_type_url }, + |m: &mut Method| { &mut m.request_type_url }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "request_streaming", + |m: &Method| { &m.request_streaming }, + |m: &mut Method| { &mut m.request_streaming }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "response_type_url", + |m: &Method| { &m.response_type_url }, + |m: &mut Method| { &mut m.response_type_url }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "response_streaming", + |m: &Method| { &m.response_streaming }, + |m: &mut Method| { &mut m.response_streaming }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Option>>( + "options", + |m: &Method| { &m.options }, + |m: &mut Method| { &mut m.options }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<::protobuf::well_known_types::Syntax>>( + "syntax", + |m: &Method| { &m.syntax }, + |m: &mut Method| { &mut m.syntax }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Method>( + "Method", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Method { + static mut instance: ::protobuf::lazy::Lazy<Method> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Method::new) + } + } +} + +impl ::protobuf::Clear for Method { + fn clear(&mut self) { + self.name.clear(); + self.request_type_url.clear(); + self.request_streaming = false; + self.response_type_url.clear(); + self.response_streaming = false; + self.options.clear(); + self.syntax = ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Method { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Method { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Mixin { + // message fields + pub name: ::std::string::String, + pub root: ::std::string::String, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Mixin { + fn default() -> &'a Mixin { + <Mixin as ::protobuf::Message>::default_instance() + } +} + +impl Mixin { + pub fn new() -> Mixin { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = 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 { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string root = 2; + + + pub fn get_root(&self) -> &str { + &self.root + } + pub fn clear_root(&mut self) { + self.root.clear(); + } + + // Param is passed by value, moved + pub fn set_root(&mut self, v: ::std::string::String) { + self.root = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_root(&mut self) -> &mut ::std::string::String { + &mut self.root + } + + // Take field + pub fn take_root(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.root, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for Mixin { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.root)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if !self.root.is_empty() { + my_size += ::protobuf::rt::string_size(2, &self.root); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if !self.root.is_empty() { + os.write_string(2, &self.root)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Mixin { + Mixin::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Mixin| { &m.name }, + |m: &mut Mixin| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "root", + |m: &Mixin| { &m.root }, + |m: &mut Mixin| { &mut m.root }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Mixin>( + "Mixin", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Mixin { + static mut instance: ::protobuf::lazy::Lazy<Mixin> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Mixin::new) + } + } +} + +impl ::protobuf::Clear for Mixin { + fn clear(&mut self) { + self.name.clear(); + self.root.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Mixin { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Mixin { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x19google/protobuf/api.proto\x12\x0fgoogle.protobuf\x1a$google/protob\ + uf/source_context.proto\x1a\x1agoogle/protobuf/type.proto\"\xc1\x02\n\ + \x03Api\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x121\n\x07methods\ + \x18\x02\x20\x03(\x0b2\x17.google.protobuf.MethodR\x07methods\x121\n\x07\ + options\x18\x03\x20\x03(\x0b2\x17.google.protobuf.OptionR\x07options\x12\ + \x18\n\x07version\x18\x04\x20\x01(\tR\x07version\x12E\n\x0esource_contex\ + t\x18\x05\x20\x01(\x0b2\x1e.google.protobuf.SourceContextR\rsourceContex\ + t\x12.\n\x06mixins\x18\x06\x20\x03(\x0b2\x16.google.protobuf.MixinR\x06m\ + ixins\x12/\n\x06syntax\x18\x07\x20\x01(\x0e2\x17.google.protobuf.SyntaxR\ + \x06syntax\"\xb2\x02\n\x06Method\x12\x12\n\x04name\x18\x01\x20\x01(\tR\ + \x04name\x12(\n\x10request_type_url\x18\x02\x20\x01(\tR\x0erequestTypeUr\ + l\x12+\n\x11request_streaming\x18\x03\x20\x01(\x08R\x10requestStreaming\ + \x12*\n\x11response_type_url\x18\x04\x20\x01(\tR\x0fresponseTypeUrl\x12-\ + \n\x12response_streaming\x18\x05\x20\x01(\x08R\x11responseStreaming\x121\ + \n\x07options\x18\x06\x20\x03(\x0b2\x17.google.protobuf.OptionR\x07optio\ + ns\x12/\n\x06syntax\x18\x07\x20\x01(\x0e2\x17.google.protobuf.SyntaxR\ + \x06syntax\"/\n\x05Mixin\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\ + \x12\x12\n\x04root\x18\x02\x20\x01(\tR\x04rootBH\n\x13com.google.protobu\ + fB\x08ApiProtoP\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownT\ + ypesJ\xa97\n\x07\x12\x05\x1e\0\xc8\x01\x01\n\xcc\x0c\n\x01\x0c\x12\x03\ + \x1e\0\x122\xc1\x0c\x20Protocol\x20Buffers\x20-\x20Google's\x20data\x20i\ + nterchange\x20format\n\x20Copyright\x202008\x20Google\x20Inc.\x20\x20All\ + \x20rights\x20reserved.\n\x20https://developers.google.com/protocol-buff\ + ers/\n\n\x20Redistribution\x20and\x20use\x20in\x20source\x20and\x20binar\ + y\x20forms,\x20with\x20or\x20without\n\x20modification,\x20are\x20permit\ + ted\x20provided\x20that\x20the\x20following\x20conditions\x20are\n\x20me\ + t:\n\n\x20\x20\x20\x20\x20*\x20Redistributions\x20of\x20source\x20code\ + \x20must\x20retain\x20the\x20above\x20copyright\n\x20notice,\x20this\x20\ + list\x20of\x20conditions\x20and\x20the\x20following\x20disclaimer.\n\x20\ + \x20\x20\x20\x20*\x20Redistributions\x20in\x20binary\x20form\x20must\x20\ + reproduce\x20the\x20above\n\x20copyright\x20notice,\x20this\x20list\x20o\ + f\x20conditions\x20and\x20the\x20following\x20disclaimer\n\x20in\x20the\ + \x20documentation\x20and/or\x20other\x20materials\x20provided\x20with\ + \x20the\n\x20distribution.\n\x20\x20\x20\x20\x20*\x20Neither\x20the\x20n\ + ame\x20of\x20Google\x20Inc.\x20nor\x20the\x20names\x20of\x20its\n\x20con\ + tributors\x20may\x20be\x20used\x20to\x20endorse\x20or\x20promote\x20prod\ + ucts\x20derived\x20from\n\x20this\x20software\x20without\x20specific\x20\ + prior\x20written\x20permission.\n\n\x20THIS\x20SOFTWARE\x20IS\x20PROVIDE\ + D\x20BY\x20THE\x20COPYRIGHT\x20HOLDERS\x20AND\x20CONTRIBUTORS\n\x20\"AS\ + \x20IS\"\x20AND\x20ANY\x20EXPRESS\x20OR\x20IMPLIED\x20WARRANTIES,\x20INC\ + LUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\x20THE\x20IMPLIED\x20WARRANTIE\ + S\x20OF\x20MERCHANTABILITY\x20AND\x20FITNESS\x20FOR\n\x20A\x20PARTICULAR\ + \x20PURPOSE\x20ARE\x20DISCLAIMED.\x20IN\x20NO\x20EVENT\x20SHALL\x20THE\ + \x20COPYRIGHT\n\x20OWNER\x20OR\x20CONTRIBUTORS\x20BE\x20LIABLE\x20FOR\ + \x20ANY\x20DIRECT,\x20INDIRECT,\x20INCIDENTAL,\n\x20SPECIAL,\x20EXEMPLAR\ + Y,\x20OR\x20CONSEQUENTIAL\x20DAMAGES\x20(INCLUDING,\x20BUT\x20NOT\n\x20L\ + IMITED\x20TO,\x20PROCUREMENT\x20OF\x20SUBSTITUTE\x20GOODS\x20OR\x20SERVI\ + CES;\x20LOSS\x20OF\x20USE,\n\x20DATA,\x20OR\x20PROFITS;\x20OR\x20BUSINES\ + S\x20INTERRUPTION)\x20HOWEVER\x20CAUSED\x20AND\x20ON\x20ANY\n\x20THEORY\ + \x20OF\x20LIABILITY,\x20WHETHER\x20IN\x20CONTRACT,\x20STRICT\x20LIABILIT\ + Y,\x20OR\x20TORT\n\x20(INCLUDING\x20NEGLIGENCE\x20OR\x20OTHERWISE)\x20AR\ + ISING\x20IN\x20ANY\x20WAY\x20OUT\x20OF\x20THE\x20USE\n\x20OF\x20THIS\x20\ + SOFTWARE,\x20EVEN\x20IF\x20ADVISED\x20OF\x20THE\x20POSSIBILITY\x20OF\x20\ + SUCH\x20DAMAGE.\n\n\x08\n\x01\x02\x12\x03\x20\0\x18\n\t\n\x02\x03\0\x12\ + \x03\"\0.\n\t\n\x02\x03\x01\x12\x03#\0$\n\x08\n\x01\x08\x12\x03%\0;\n\t\ + \n\x02\x08%\x12\x03%\0;\n\x08\n\x01\x08\x12\x03&\0,\n\t\n\x02\x08\x01\ + \x12\x03&\0,\n\x08\n\x01\x08\x12\x03'\0)\n\t\n\x02\x08\x08\x12\x03'\0)\n\ + \x08\n\x01\x08\x12\x03(\0\"\n\t\n\x02\x08\n\x12\x03(\0\"\n\x08\n\x01\x08\ + \x12\x03)\0!\n\t\n\x02\x08$\x12\x03)\0!\nM\n\x02\x04\0\x12\x04,\0Y\x01\ + \x1aA\x20Api\x20is\x20a\x20light-weight\x20descriptor\x20for\x20a\x20pro\ + tocol\x20buffer\x20service.\n\n\n\n\x03\x04\0\x01\x12\x03,\x08\x0b\no\n\ + \x04\x04\0\x02\0\x12\x030\x02\x12\x1ab\x20The\x20fully\x20qualified\x20n\ + ame\x20of\x20this\x20api,\x20including\x20package\x20name\n\x20followed\ + \x20by\x20the\x20api's\x20simple\x20name.\n\n\x0c\n\x05\x04\0\x02\0\x05\ + \x12\x030\x02\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x030\t\r\n\x0c\n\x05\ + \x04\0\x02\0\x03\x12\x030\x10\x11\n=\n\x04\x04\0\x02\x01\x12\x033\x02\ + \x1e\x1a0\x20The\x20methods\x20of\x20this\x20api,\x20in\x20unspecified\ + \x20order.\n\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x033\x02\n\n\x0c\n\x05\ + \x04\0\x02\x01\x06\x12\x033\x0b\x11\n\x0c\n\x05\x04\0\x02\x01\x01\x12\ + \x033\x12\x19\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x033\x1c\x1d\n0\n\x04\ + \x04\0\x02\x02\x12\x036\x02\x1e\x1a#\x20Any\x20metadata\x20attached\x20t\ + o\x20the\x20API.\n\n\x0c\n\x05\x04\0\x02\x02\x04\x12\x036\x02\n\n\x0c\n\ + \x05\x04\0\x02\x02\x06\x12\x036\x0b\x11\n\x0c\n\x05\x04\0\x02\x02\x01\ + \x12\x036\x12\x19\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x036\x1c\x1d\n\xf2\ + \x07\n\x04\x04\0\x02\x03\x12\x03N\x02\x15\x1a\xe4\x07\x20A\x20version\ + \x20string\x20for\x20this\x20api.\x20If\x20specified,\x20must\x20have\ + \x20the\x20form\n\x20`major-version.minor-version`,\x20as\x20in\x20`1.10\ + `.\x20If\x20the\x20minor\x20version\n\x20is\x20omitted,\x20it\x20default\ + s\x20to\x20zero.\x20If\x20the\x20entire\x20version\x20field\x20is\n\x20e\ + mpty,\x20the\x20major\x20version\x20is\x20derived\x20from\x20the\x20pack\ + age\x20name,\x20as\n\x20outlined\x20below.\x20If\x20the\x20field\x20is\ + \x20not\x20empty,\x20the\x20version\x20in\x20the\n\x20package\x20name\ + \x20will\x20be\x20verified\x20to\x20be\x20consistent\x20with\x20what\x20\ + is\n\x20provided\x20here.\n\n\x20The\x20versioning\x20schema\x20uses\x20\ + [semantic\n\x20versioning](http://semver.org)\x20where\x20the\x20major\ + \x20version\x20number\n\x20indicates\x20a\x20breaking\x20change\x20and\ + \x20the\x20minor\x20version\x20an\x20additive,\n\x20non-breaking\x20chan\ + ge.\x20Both\x20version\x20numbers\x20are\x20signals\x20to\x20users\n\x20\ + what\x20to\x20expect\x20from\x20different\x20versions,\x20and\x20should\ + \x20be\x20carefully\n\x20chosen\x20based\x20on\x20the\x20product\x20plan\ + .\n\n\x20The\x20major\x20version\x20is\x20also\x20reflected\x20in\x20the\ + \x20package\x20name\x20of\x20the\n\x20API,\x20which\x20must\x20end\x20in\ + \x20`v<major-version>`,\x20as\x20in\n\x20`google.feature.v1`.\x20For\x20\ + major\x20versions\x200\x20and\x201,\x20the\x20suffix\x20can\n\x20be\x20o\ + mitted.\x20Zero\x20major\x20versions\x20must\x20only\x20be\x20used\x20fo\ + r\n\x20experimental,\x20none-GA\x20apis.\n\n\n\n\x0c\n\x05\x04\0\x02\x03\ + \x05\x12\x03N\x02\x08\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03N\t\x10\n\x0c\ + \n\x05\x04\0\x02\x03\x03\x12\x03N\x13\x14\n[\n\x04\x04\0\x02\x04\x12\x03\ + R\x02#\x1aN\x20Source\x20context\x20for\x20the\x20protocol\x20buffer\x20\ + service\x20represented\x20by\x20this\n\x20message.\n\n\x0c\n\x05\x04\0\ + \x02\x04\x06\x12\x03R\x02\x0f\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x03R\x10\ + \x1e\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03R!\"\n,\n\x04\x04\0\x02\x05\ + \x12\x03U\x02\x1c\x1a\x1f\x20Included\x20APIs.\x20See\x20[Mixin][].\n\n\ + \x0c\n\x05\x04\0\x02\x05\x04\x12\x03U\x02\n\n\x0c\n\x05\x04\0\x02\x05\ + \x06\x12\x03U\x0b\x10\n\x0c\n\x05\x04\0\x02\x05\x01\x12\x03U\x11\x17\n\ + \x0c\n\x05\x04\0\x02\x05\x03\x12\x03U\x1a\x1b\n0\n\x04\x04\0\x02\x06\x12\ + \x03X\x02\x14\x1a#\x20The\x20source\x20syntax\x20of\x20the\x20service.\n\ + \n\x0c\n\x05\x04\0\x02\x06\x06\x12\x03X\x02\x08\n\x0c\n\x05\x04\0\x02\ + \x06\x01\x12\x03X\t\x0f\n\x0c\n\x05\x04\0\x02\x06\x03\x12\x03X\x12\x13\n\ + 3\n\x02\x04\x01\x12\x04\\\0r\x01\x1a'\x20Method\x20represents\x20a\x20me\ + thod\x20of\x20an\x20api.\n\n\n\n\x03\x04\x01\x01\x12\x03\\\x08\x0e\n.\n\ + \x04\x04\x01\x02\0\x12\x03_\x02\x12\x1a!\x20The\x20simple\x20name\x20of\ + \x20this\x20method.\n\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03_\x02\x08\n\ + \x0c\n\x05\x04\x01\x02\0\x01\x12\x03_\t\r\n\x0c\n\x05\x04\x01\x02\0\x03\ + \x12\x03_\x10\x11\n/\n\x04\x04\x01\x02\x01\x12\x03b\x02\x1e\x1a\"\x20A\ + \x20URL\x20of\x20the\x20input\x20message\x20type.\n\n\x0c\n\x05\x04\x01\ + \x02\x01\x05\x12\x03b\x02\x08\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03b\t\ + \x19\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03b\x1c\x1d\n0\n\x04\x04\x01\ + \x02\x02\x12\x03e\x02\x1d\x1a#\x20If\x20true,\x20the\x20request\x20is\ + \x20streamed.\n\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03e\x02\x06\n\x0c\n\ + \x05\x04\x01\x02\x02\x01\x12\x03e\x07\x18\n\x0c\n\x05\x04\x01\x02\x02\ + \x03\x12\x03e\x1b\x1c\n2\n\x04\x04\x01\x02\x03\x12\x03h\x02\x1f\x1a%\x20\ + The\x20URL\x20of\x20the\x20output\x20message\x20type.\n\n\x0c\n\x05\x04\ + \x01\x02\x03\x05\x12\x03h\x02\x08\n\x0c\n\x05\x04\x01\x02\x03\x01\x12\ + \x03h\t\x1a\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03h\x1d\x1e\n1\n\x04\ + \x04\x01\x02\x04\x12\x03k\x02\x1e\x1a$\x20If\x20true,\x20the\x20response\ + \x20is\x20streamed.\n\n\x0c\n\x05\x04\x01\x02\x04\x05\x12\x03k\x02\x06\n\ + \x0c\n\x05\x04\x01\x02\x04\x01\x12\x03k\x07\x19\n\x0c\n\x05\x04\x01\x02\ + \x04\x03\x12\x03k\x1c\x1d\n3\n\x04\x04\x01\x02\x05\x12\x03n\x02\x1e\x1a&\ + \x20Any\x20metadata\x20attached\x20to\x20the\x20method.\n\n\x0c\n\x05\ + \x04\x01\x02\x05\x04\x12\x03n\x02\n\n\x0c\n\x05\x04\x01\x02\x05\x06\x12\ + \x03n\x0b\x11\n\x0c\n\x05\x04\x01\x02\x05\x01\x12\x03n\x12\x19\n\x0c\n\ + \x05\x04\x01\x02\x05\x03\x12\x03n\x1c\x1d\n0\n\x04\x04\x01\x02\x06\x12\ + \x03q\x02\x14\x1a#\x20The\x20source\x20syntax\x20of\x20this\x20method.\n\ + \n\x0c\n\x05\x04\x01\x02\x06\x06\x12\x03q\x02\x08\n\x0c\n\x05\x04\x01\ + \x02\x06\x01\x12\x03q\t\x0f\n\x0c\n\x05\x04\x01\x02\x06\x03\x12\x03q\x12\ + \x13\n\xa4\x13\n\x02\x04\x02\x12\x06\xc1\x01\0\xc8\x01\x01\x1a\x95\x13\ + \x20Declares\x20an\x20API\x20to\x20be\x20included\x20in\x20this\x20API.\ + \x20The\x20including\x20API\x20must\n\x20redeclare\x20all\x20the\x20meth\ + ods\x20from\x20the\x20included\x20API,\x20but\x20documentation\n\x20and\ + \x20options\x20are\x20inherited\x20as\x20follows:\n\n\x20-\x20If\x20afte\ + r\x20comment\x20and\x20whitespace\x20stripping,\x20the\x20documentation\ + \n\x20\x20\x20string\x20of\x20the\x20redeclared\x20method\x20is\x20empty\ + ,\x20it\x20will\x20be\x20inherited\n\x20\x20\x20from\x20the\x20original\ + \x20method.\n\n\x20-\x20Each\x20annotation\x20belonging\x20to\x20the\x20\ + service\x20config\x20(http,\n\x20\x20\x20visibility)\x20which\x20is\x20n\ + ot\x20set\x20in\x20the\x20redeclared\x20method\x20will\x20be\n\x20\x20\ + \x20inherited.\n\n\x20-\x20If\x20an\x20http\x20annotation\x20is\x20inher\ + ited,\x20the\x20path\x20pattern\x20will\x20be\n\x20\x20\x20modified\x20a\ + s\x20follows.\x20Any\x20version\x20prefix\x20will\x20be\x20replaced\x20b\ + y\x20the\n\x20\x20\x20version\x20of\x20the\x20including\x20API\x20plus\ + \x20the\x20[root][]\x20path\x20if\x20specified.\n\n\x20Example\x20of\x20\ + a\x20simple\x20mixin:\n\n\x20\x20\x20\x20\x20package\x20google.acl.v1;\n\ + \x20\x20\x20\x20\x20service\x20AccessControl\x20{\n\x20\x20\x20\x20\x20\ + \x20\x20//\x20Get\x20the\x20underlying\x20ACL\x20object.\n\x20\x20\x20\ + \x20\x20\x20\x20rpc\x20GetAcl(GetAclRequest)\x20returns\x20(Acl)\x20{\n\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20option\x20(google.api.http).get\x20=\ + \x20\"/v1/{resource=**}:getAcl\";\n\x20\x20\x20\x20\x20\x20\x20}\n\x20\ + \x20\x20\x20\x20}\n\n\x20\x20\x20\x20\x20package\x20google.storage.v2;\n\ + \x20\x20\x20\x20\x20service\x20Storage\x20{\n\x20\x20\x20\x20\x20\x20\ + \x20rpc\x20GetAcl(GetAclRequest)\x20returns\x20(Acl);\n\n\x20\x20\x20\ + \x20\x20\x20\x20//\x20Get\x20a\x20data\x20record.\n\x20\x20\x20\x20\x20\ + \x20\x20rpc\x20GetData(GetDataRequest)\x20returns\x20(Data)\x20{\n\x20\ + \x20\x20\x20\x20\x20\x20\x20\x20option\x20(google.api.http).get\x20=\x20\ + \"/v2/{resource=**}\";\n\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\ + \x20}\n\n\x20Example\x20of\x20a\x20mixin\x20configuration:\n\n\x20\x20\ + \x20\x20\x20apis:\n\x20\x20\x20\x20\x20-\x20name:\x20google.storage.v2.S\ + torage\n\x20\x20\x20\x20\x20\x20\x20mixins:\n\x20\x20\x20\x20\x20\x20\ + \x20-\x20name:\x20google.acl.v1.AccessControl\n\n\x20The\x20mixin\x20con\ + struct\x20implies\x20that\x20all\x20methods\x20in\x20`AccessControl`\x20\ + are\n\x20also\x20declared\x20with\x20same\x20name\x20and\x20request/resp\ + onse\x20types\x20in\n\x20`Storage`.\x20A\x20documentation\x20generator\ + \x20or\x20annotation\x20processor\x20will\n\x20see\x20the\x20effective\ + \x20`Storage.GetAcl`\x20method\x20after\x20inherting\n\x20documentation\ + \x20and\x20annotations\x20as\x20follows:\n\n\x20\x20\x20\x20\x20service\ + \x20Storage\x20{\n\x20\x20\x20\x20\x20\x20\x20//\x20Get\x20the\x20underl\ + ying\x20ACL\x20object.\n\x20\x20\x20\x20\x20\x20\x20rpc\x20GetAcl(GetAcl\ + Request)\x20returns\x20(Acl)\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20o\ + ption\x20(google.api.http).get\x20=\x20\"/v2/{resource=**}:getAcl\";\n\ + \x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20...\n\x20\x20\ + \x20\x20\x20}\n\n\x20Note\x20how\x20the\x20version\x20in\x20the\x20path\ + \x20pattern\x20changed\x20from\x20`v1`\x20to\x20`v2`.\n\n\x20If\x20the\ + \x20`root`\x20field\x20in\x20the\x20mixin\x20is\x20specified,\x20it\x20s\ + hould\x20be\x20a\n\x20relative\x20path\x20under\x20which\x20inherited\ + \x20HTTP\x20paths\x20are\x20placed.\x20Example:\n\n\x20\x20\x20\x20\x20a\ + pis:\n\x20\x20\x20\x20\x20-\x20name:\x20google.storage.v2.Storage\n\x20\ + \x20\x20\x20\x20\x20\x20mixins:\n\x20\x20\x20\x20\x20\x20\x20-\x20name:\ + \x20google.acl.v1.AccessControl\n\x20\x20\x20\x20\x20\x20\x20\x20\x20roo\ + t:\x20acls\n\n\x20This\x20implies\x20the\x20following\x20inherited\x20HT\ + TP\x20annotation:\n\n\x20\x20\x20\x20\x20service\x20Storage\x20{\n\x20\ + \x20\x20\x20\x20\x20\x20//\x20Get\x20the\x20underlying\x20ACL\x20object.\ + \n\x20\x20\x20\x20\x20\x20\x20rpc\x20GetAcl(GetAclRequest)\x20returns\ + \x20(Acl)\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20option\x20(google.ap\ + i.http).get\x20=\x20\"/v2/acls/{resource=**}:getAcl\";\n\x20\x20\x20\x20\ + \x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20...\n\x20\x20\x20\x20\x20}\n\ + \n\x0b\n\x03\x04\x02\x01\x12\x04\xc1\x01\x08\r\nF\n\x04\x04\x02\x02\0\ + \x12\x04\xc3\x01\x02\x12\x1a8\x20The\x20fully\x20qualified\x20name\x20of\ + \x20the\x20API\x20which\x20is\x20included.\n\n\r\n\x05\x04\x02\x02\0\x05\ + \x12\x04\xc3\x01\x02\x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\xc3\x01\t\r\ + \n\r\n\x05\x04\x02\x02\0\x03\x12\x04\xc3\x01\x10\x11\n[\n\x04\x04\x02\ + \x02\x01\x12\x04\xc7\x01\x02\x12\x1aM\x20If\x20non-empty\x20specifies\ + \x20a\x20path\x20under\x20which\x20inherited\x20HTTP\x20paths\n\x20are\ + \x20rooted.\n\n\r\n\x05\x04\x02\x02\x01\x05\x12\x04\xc7\x01\x02\x08\n\r\ + \n\x05\x04\x02\x02\x01\x01\x12\x04\xc7\x01\t\r\n\r\n\x05\x04\x02\x02\x01\ + \x03\x12\x04\xc7\x01\x10\x11b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/src/well_known_types/duration.rs b/src/well_known_types/duration.rs new file mode 100644 index 0000000..303173d --- /dev/null +++ b/src/well_known_types/duration.rs @@ -0,0 +1,332 @@ +// This file is generated by rust-protobuf 2.14.0-pre. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/protobuf/duration.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Duration { + // message fields + pub seconds: i64, + pub nanos: i32, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Duration { + fn default() -> &'a Duration { + <Duration as ::protobuf::Message>::default_instance() + } +} + +impl Duration { + pub fn new() -> Duration { + ::std::default::Default::default() + } + + // int64 seconds = 1; + + + pub fn get_seconds(&self) -> i64 { + self.seconds + } + pub fn clear_seconds(&mut self) { + self.seconds = 0; + } + + // Param is passed by value, moved + pub fn set_seconds(&mut self, v: i64) { + self.seconds = v; + } + + // int32 nanos = 2; + + + pub fn get_nanos(&self) -> i32 { + self.nanos + } + pub fn clear_nanos(&mut self) { + self.nanos = 0; + } + + // Param is passed by value, moved + pub fn set_nanos(&mut self, v: i32) { + self.nanos = v; + } +} + +impl ::protobuf::Message for Duration { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.seconds = tmp; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.nanos = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.seconds != 0 { + my_size += ::protobuf::rt::value_size(1, self.seconds, ::protobuf::wire_format::WireTypeVarint); + } + if self.nanos != 0 { + my_size += ::protobuf::rt::value_size(2, self.nanos, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if self.seconds != 0 { + os.write_int64(1, self.seconds)?; + } + if self.nanos != 0 { + os.write_int32(2, self.nanos)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Duration { + Duration::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "seconds", + |m: &Duration| { &m.seconds }, + |m: &mut Duration| { &mut m.seconds }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "nanos", + |m: &Duration| { &m.nanos }, + |m: &mut Duration| { &mut m.nanos }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Duration>( + "Duration", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Duration { + static mut instance: ::protobuf::lazy::Lazy<Duration> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Duration::new) + } + } +} + +impl ::protobuf::Clear for Duration { + fn clear(&mut self) { + self.seconds = 0; + self.nanos = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Duration { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Duration { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1egoogle/protobuf/duration.proto\x12\x0fgoogle.protobuf\":\n\x08Dura\ + tion\x12\x18\n\x07seconds\x18\x01\x20\x01(\x03R\x07seconds\x12\x14\n\x05\ + nanos\x18\x02\x20\x01(\x05R\x05nanosB|\n\x13com.google.protobufB\rDurati\ + onProtoP\x01Z*github.com/golang/protobuf/ptypes/duration\xf8\x01\x01\xa2\ + \x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesJ\xe1\x1e\n\x06\x12\ + \x04\x1e\0g\x01\n\xcc\x0c\n\x01\x0c\x12\x03\x1e\0\x122\xc1\x0c\x20Protoc\ + ol\x20Buffers\x20-\x20Google's\x20data\x20interchange\x20format\n\x20Cop\ + yright\x202008\x20Google\x20Inc.\x20\x20All\x20rights\x20reserved.\n\x20\ + https://developers.google.com/protocol-buffers/\n\n\x20Redistribution\ + \x20and\x20use\x20in\x20source\x20and\x20binary\x20forms,\x20with\x20or\ + \x20without\n\x20modification,\x20are\x20permitted\x20provided\x20that\ + \x20the\x20following\x20conditions\x20are\n\x20met:\n\n\x20\x20\x20\x20\ + \x20*\x20Redistributions\x20of\x20source\x20code\x20must\x20retain\x20th\ + e\x20above\x20copyright\n\x20notice,\x20this\x20list\x20of\x20conditions\ + \x20and\x20the\x20following\x20disclaimer.\n\x20\x20\x20\x20\x20*\x20Red\ + istributions\x20in\x20binary\x20form\x20must\x20reproduce\x20the\x20abov\ + e\n\x20copyright\x20notice,\x20this\x20list\x20of\x20conditions\x20and\ + \x20the\x20following\x20disclaimer\n\x20in\x20the\x20documentation\x20an\ + d/or\x20other\x20materials\x20provided\x20with\x20the\n\x20distribution.\ + \n\x20\x20\x20\x20\x20*\x20Neither\x20the\x20name\x20of\x20Google\x20Inc\ + .\x20nor\x20the\x20names\x20of\x20its\n\x20contributors\x20may\x20be\x20\ + used\x20to\x20endorse\x20or\x20promote\x20products\x20derived\x20from\n\ + \x20this\x20software\x20without\x20specific\x20prior\x20written\x20permi\ + ssion.\n\n\x20THIS\x20SOFTWARE\x20IS\x20PROVIDED\x20BY\x20THE\x20COPYRIG\ + HT\x20HOLDERS\x20AND\x20CONTRIBUTORS\n\x20\"AS\x20IS\"\x20AND\x20ANY\x20\ + EXPRESS\x20OR\x20IMPLIED\x20WARRANTIES,\x20INCLUDING,\x20BUT\x20NOT\n\ + \x20LIMITED\x20TO,\x20THE\x20IMPLIED\x20WARRANTIES\x20OF\x20MERCHANTABIL\ + ITY\x20AND\x20FITNESS\x20FOR\n\x20A\x20PARTICULAR\x20PURPOSE\x20ARE\x20D\ + ISCLAIMED.\x20IN\x20NO\x20EVENT\x20SHALL\x20THE\x20COPYRIGHT\n\x20OWNER\ + \x20OR\x20CONTRIBUTORS\x20BE\x20LIABLE\x20FOR\x20ANY\x20DIRECT,\x20INDIR\ + ECT,\x20INCIDENTAL,\n\x20SPECIAL,\x20EXEMPLARY,\x20OR\x20CONSEQUENTIAL\ + \x20DAMAGES\x20(INCLUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\x20PROCUREM\ + ENT\x20OF\x20SUBSTITUTE\x20GOODS\x20OR\x20SERVICES;\x20LOSS\x20OF\x20USE\ + ,\n\x20DATA,\x20OR\x20PROFITS;\x20OR\x20BUSINESS\x20INTERRUPTION)\x20HOW\ + EVER\x20CAUSED\x20AND\x20ON\x20ANY\n\x20THEORY\x20OF\x20LIABILITY,\x20WH\ + ETHER\x20IN\x20CONTRACT,\x20STRICT\x20LIABILITY,\x20OR\x20TORT\n\x20(INC\ + LUDING\x20NEGLIGENCE\x20OR\x20OTHERWISE)\x20ARISING\x20IN\x20ANY\x20WAY\ + \x20OUT\x20OF\x20THE\x20USE\n\x20OF\x20THIS\x20SOFTWARE,\x20EVEN\x20IF\ + \x20ADVISED\x20OF\x20THE\x20POSSIBILITY\x20OF\x20SUCH\x20DAMAGE.\n\n\x08\ + \n\x01\x02\x12\x03\x20\0\x18\n\x08\n\x01\x08\x12\x03\"\0;\n\t\n\x02\x08%\ + \x12\x03\"\0;\n\x08\n\x01\x08\x12\x03#\0\x1f\n\t\n\x02\x08\x1f\x12\x03#\ + \0\x1f\n\x08\n\x01\x08\x12\x03$\0A\n\t\n\x02\x08\x0b\x12\x03$\0A\n\x08\n\ + \x01\x08\x12\x03%\0,\n\t\n\x02\x08\x01\x12\x03%\0,\n\x08\n\x01\x08\x12\ + \x03&\0.\n\t\n\x02\x08\x08\x12\x03&\0.\n\x08\n\x01\x08\x12\x03'\0\"\n\t\ + \n\x02\x08\n\x12\x03'\0\"\n\x08\n\x01\x08\x12\x03(\0!\n\t\n\x02\x08$\x12\ + \x03(\0!\n\x92\x0c\n\x02\x04\0\x12\x04Z\0g\x01\x1a\x85\x0c\x20A\x20Durat\ + ion\x20represents\x20a\x20signed,\x20fixed-length\x20span\x20of\x20time\ + \x20represented\n\x20as\x20a\x20count\x20of\x20seconds\x20and\x20fractio\ + ns\x20of\x20seconds\x20at\x20nanosecond\n\x20resolution.\x20It\x20is\x20\ + independent\x20of\x20any\x20calendar\x20and\x20concepts\x20like\x20\"day\ + \"\n\x20or\x20\"month\".\x20It\x20is\x20related\x20to\x20Timestamp\x20in\ + \x20that\x20the\x20difference\x20between\n\x20two\x20Timestamp\x20values\ + \x20is\x20a\x20Duration\x20and\x20it\x20can\x20be\x20added\x20or\x20subt\ + racted\n\x20from\x20a\x20Timestamp.\x20Range\x20is\x20approximately\x20+\ + -10,000\x20years.\n\n\x20Example\x201:\x20Compute\x20Duration\x20from\ + \x20two\x20Timestamps\x20in\x20pseudo\x20code.\n\n\x20\x20\x20\x20\x20Ti\ + mestamp\x20start\x20=\x20...;\n\x20\x20\x20\x20\x20Timestamp\x20end\x20=\ + \x20...;\n\x20\x20\x20\x20\x20Duration\x20duration\x20=\x20...;\n\n\x20\ + \x20\x20\x20\x20duration.seconds\x20=\x20end.seconds\x20-\x20start.secon\ + ds;\n\x20\x20\x20\x20\x20duration.nanos\x20=\x20end.nanos\x20-\x20start.\ + nanos;\n\n\x20\x20\x20\x20\x20if\x20(duration.seconds\x20<\x200\x20&&\ + \x20duration.nanos\x20>\x200)\x20{\n\x20\x20\x20\x20\x20\x20\x20duration\ + .seconds\x20+=\x201;\n\x20\x20\x20\x20\x20\x20\x20duration.nanos\x20-=\ + \x201000000000;\n\x20\x20\x20\x20\x20}\x20else\x20if\x20(durations.secon\ + ds\x20>\x200\x20&&\x20duration.nanos\x20<\x200)\x20{\n\x20\x20\x20\x20\ + \x20\x20\x20duration.seconds\x20-=\x201;\n\x20\x20\x20\x20\x20\x20\x20du\ + ration.nanos\x20+=\x201000000000;\n\x20\x20\x20\x20\x20}\n\n\x20Example\ + \x202:\x20Compute\x20Timestamp\x20from\x20Timestamp\x20+\x20Duration\x20\ + in\x20pseudo\x20code.\n\n\x20\x20\x20\x20\x20Timestamp\x20start\x20=\x20\ + ...;\n\x20\x20\x20\x20\x20Duration\x20duration\x20=\x20...;\n\x20\x20\ + \x20\x20\x20Timestamp\x20end\x20=\x20...;\n\n\x20\x20\x20\x20\x20end.sec\ + onds\x20=\x20start.seconds\x20+\x20duration.seconds;\n\x20\x20\x20\x20\ + \x20end.nanos\x20=\x20start.nanos\x20+\x20duration.nanos;\n\n\x20\x20\ + \x20\x20\x20if\x20(end.nanos\x20<\x200)\x20{\n\x20\x20\x20\x20\x20\x20\ + \x20end.seconds\x20-=\x201;\n\x20\x20\x20\x20\x20\x20\x20end.nanos\x20+=\ + \x201000000000;\n\x20\x20\x20\x20\x20}\x20else\x20if\x20(end.nanos\x20>=\ + \x201000000000)\x20{\n\x20\x20\x20\x20\x20\x20\x20end.seconds\x20+=\x201\ + ;\n\x20\x20\x20\x20\x20\x20\x20end.nanos\x20-=\x201000000000;\n\x20\x20\ + \x20\x20\x20}\n\n\x20Example\x203:\x20Compute\x20Duration\x20from\x20dat\ + etime.timedelta\x20in\x20Python.\n\n\x20\x20\x20\x20\x20td\x20=\x20datet\ + ime.timedelta(days=3,\x20minutes=10)\n\x20\x20\x20\x20\x20duration\x20=\ + \x20Duration()\n\x20\x20\x20\x20\x20duration.FromTimedelta(td)\n\n\n\n\n\ + \n\x03\x04\0\x01\x12\x03Z\x08\x10\np\n\x04\x04\0\x02\0\x12\x03^\x02\x14\ + \x1ac\x20Signed\x20seconds\x20of\x20the\x20span\x20of\x20time.\x20Must\ + \x20be\x20from\x20-315,576,000,000\n\x20to\x20+315,576,000,000\x20inclus\ + ive.\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03^\x02\x07\n\x0c\n\x05\x04\0\ + \x02\0\x01\x12\x03^\x08\x0f\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03^\x12\x13\ + \n\x83\x03\n\x04\x04\0\x02\x01\x12\x03f\x02\x12\x1a\xf5\x02\x20Signed\ + \x20fractions\x20of\x20a\x20second\x20at\x20nanosecond\x20resolution\x20\ + of\x20the\x20span\n\x20of\x20time.\x20Durations\x20less\x20than\x20one\ + \x20second\x20are\x20represented\x20with\x20a\x200\n\x20`seconds`\x20fie\ + ld\x20and\x20a\x20positive\x20or\x20negative\x20`nanos`\x20field.\x20For\ + \x20durations\n\x20of\x20one\x20second\x20or\x20more,\x20a\x20non-zero\ + \x20value\x20for\x20the\x20`nanos`\x20field\x20must\x20be\n\x20of\x20the\ + \x20same\x20sign\x20as\x20the\x20`seconds`\x20field.\x20Must\x20be\x20fr\ + om\x20-999,999,999\n\x20to\x20+999,999,999\x20inclusive.\n\n\x0c\n\x05\ + \x04\0\x02\x01\x05\x12\x03f\x02\x07\n\x0c\n\x05\x04\0\x02\x01\x01\x12\ + \x03f\x08\r\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03f\x10\x11b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/src/well_known_types/empty.rs b/src/well_known_types/empty.rs new file mode 100644 index 0000000..df64a48 --- /dev/null +++ b/src/well_known_types/empty.rs @@ -0,0 +1,217 @@ +// This file is generated by rust-protobuf 2.14.0-pre. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/protobuf/empty.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Empty { + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Empty { + fn default() -> &'a Empty { + <Empty as ::protobuf::Message>::default_instance() + } +} + +impl Empty { + pub fn new() -> Empty { + ::std::default::Default::default() + } +} + +impl ::protobuf::Message for Empty { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Empty { + Empty::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let fields = ::std::vec::Vec::new(); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Empty>( + "Empty", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Empty { + static mut instance: ::protobuf::lazy::Lazy<Empty> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Empty::new) + } + } +} + +impl ::protobuf::Clear for Empty { + fn clear(&mut self) { + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Empty { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Empty { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1bgoogle/protobuf/empty.proto\x12\x0fgoogle.protobuf\"\x07\n\x05Empt\ + yBv\n\x13com.google.protobufB\nEmptyProtoP\x01Z'github.com/golang/protob\ + uf/ptypes/empty\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.We\ + llKnownTypesJ\xfe\x10\n\x06\x12\x04\x1e\03\x10\n\xcc\x0c\n\x01\x0c\x12\ + \x03\x1e\0\x122\xc1\x0c\x20Protocol\x20Buffers\x20-\x20Google's\x20data\ + \x20interchange\x20format\n\x20Copyright\x202008\x20Google\x20Inc.\x20\ + \x20All\x20rights\x20reserved.\n\x20https://developers.google.com/protoc\ + ol-buffers/\n\n\x20Redistribution\x20and\x20use\x20in\x20source\x20and\ + \x20binary\x20forms,\x20with\x20or\x20without\n\x20modification,\x20are\ + \x20permitted\x20provided\x20that\x20the\x20following\x20conditions\x20a\ + re\n\x20met:\n\n\x20\x20\x20\x20\x20*\x20Redistributions\x20of\x20source\ + \x20code\x20must\x20retain\x20the\x20above\x20copyright\n\x20notice,\x20\ + this\x20list\x20of\x20conditions\x20and\x20the\x20following\x20disclaime\ + r.\n\x20\x20\x20\x20\x20*\x20Redistributions\x20in\x20binary\x20form\x20\ + must\x20reproduce\x20the\x20above\n\x20copyright\x20notice,\x20this\x20l\ + ist\x20of\x20conditions\x20and\x20the\x20following\x20disclaimer\n\x20in\ + \x20the\x20documentation\x20and/or\x20other\x20materials\x20provided\x20\ + with\x20the\n\x20distribution.\n\x20\x20\x20\x20\x20*\x20Neither\x20the\ + \x20name\x20of\x20Google\x20Inc.\x20nor\x20the\x20names\x20of\x20its\n\ + \x20contributors\x20may\x20be\x20used\x20to\x20endorse\x20or\x20promote\ + \x20products\x20derived\x20from\n\x20this\x20software\x20without\x20spec\ + ific\x20prior\x20written\x20permission.\n\n\x20THIS\x20SOFTWARE\x20IS\ + \x20PROVIDED\x20BY\x20THE\x20COPYRIGHT\x20HOLDERS\x20AND\x20CONTRIBUTORS\ + \n\x20\"AS\x20IS\"\x20AND\x20ANY\x20EXPRESS\x20OR\x20IMPLIED\x20WARRANTI\ + ES,\x20INCLUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\x20THE\x20IMPLIED\ + \x20WARRANTIES\x20OF\x20MERCHANTABILITY\x20AND\x20FITNESS\x20FOR\n\x20A\ + \x20PARTICULAR\x20PURPOSE\x20ARE\x20DISCLAIMED.\x20IN\x20NO\x20EVENT\x20\ + SHALL\x20THE\x20COPYRIGHT\n\x20OWNER\x20OR\x20CONTRIBUTORS\x20BE\x20LIAB\ + LE\x20FOR\x20ANY\x20DIRECT,\x20INDIRECT,\x20INCIDENTAL,\n\x20SPECIAL,\ + \x20EXEMPLARY,\x20OR\x20CONSEQUENTIAL\x20DAMAGES\x20(INCLUDING,\x20BUT\ + \x20NOT\n\x20LIMITED\x20TO,\x20PROCUREMENT\x20OF\x20SUBSTITUTE\x20GOODS\ + \x20OR\x20SERVICES;\x20LOSS\x20OF\x20USE,\n\x20DATA,\x20OR\x20PROFITS;\ + \x20OR\x20BUSINESS\x20INTERRUPTION)\x20HOWEVER\x20CAUSED\x20AND\x20ON\ + \x20ANY\n\x20THEORY\x20OF\x20LIABILITY,\x20WHETHER\x20IN\x20CONTRACT,\ + \x20STRICT\x20LIABILITY,\x20OR\x20TORT\n\x20(INCLUDING\x20NEGLIGENCE\x20\ + OR\x20OTHERWISE)\x20ARISING\x20IN\x20ANY\x20WAY\x20OUT\x20OF\x20THE\x20U\ + SE\n\x20OF\x20THIS\x20SOFTWARE,\x20EVEN\x20IF\x20ADVISED\x20OF\x20THE\ + \x20POSSIBILITY\x20OF\x20SUCH\x20DAMAGE.\n\n\x08\n\x01\x02\x12\x03\x20\0\ + \x18\n\x08\n\x01\x08\x12\x03\"\0;\n\t\n\x02\x08%\x12\x03\"\0;\n\x08\n\ + \x01\x08\x12\x03#\0>\n\t\n\x02\x08\x0b\x12\x03#\0>\n\x08\n\x01\x08\x12\ + \x03$\0,\n\t\n\x02\x08\x01\x12\x03$\0,\n\x08\n\x01\x08\x12\x03%\0+\n\t\n\ + \x02\x08\x08\x12\x03%\0+\n\x08\n\x01\x08\x12\x03&\0\"\n\t\n\x02\x08\n\ + \x12\x03&\0\"\n\x08\n\x01\x08\x12\x03'\0!\n\t\n\x02\x08$\x12\x03'\0!\n\ + \x08\n\x01\x08\x12\x03(\0\x1f\n\t\n\x02\x08\x1f\x12\x03(\0\x1f\n\xfb\x02\ + \n\x02\x04\0\x12\x033\0\x10\x1a\xef\x02\x20A\x20generic\x20empty\x20mess\ + age\x20that\x20you\x20can\x20re-use\x20to\x20avoid\x20defining\x20duplic\ + ated\n\x20empty\x20messages\x20in\x20your\x20APIs.\x20A\x20typical\x20ex\ + ample\x20is\x20to\x20use\x20it\x20as\x20the\x20request\n\x20or\x20the\ + \x20response\x20type\x20of\x20an\x20API\x20method.\x20For\x20instance:\n\ + \n\x20\x20\x20\x20\x20service\x20Foo\x20{\n\x20\x20\x20\x20\x20\x20\x20r\ + pc\x20Bar(google.protobuf.Empty)\x20returns\x20(google.protobuf.Empty);\ + \n\x20\x20\x20\x20\x20}\n\n\x20The\x20JSON\x20representation\x20for\x20`\ + Empty`\x20is\x20empty\x20JSON\x20object\x20`{}`.\n\n\n\n\x03\x04\0\x01\ + \x12\x033\x08\rb\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/src/well_known_types/field_mask.rs b/src/well_known_types/field_mask.rs new file mode 100644 index 0000000..421d15c --- /dev/null +++ b/src/well_known_types/field_mask.rs @@ -0,0 +1,388 @@ +// This file is generated by rust-protobuf 2.14.0-pre. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/protobuf/field_mask.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct FieldMask { + // message fields + pub paths: ::protobuf::RepeatedField<::std::string::String>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a FieldMask { + fn default() -> &'a FieldMask { + <FieldMask as ::protobuf::Message>::default_instance() + } +} + +impl FieldMask { + pub fn new() -> FieldMask { + ::std::default::Default::default() + } + + // repeated string paths = 1; + + + pub fn get_paths(&self) -> &[::std::string::String] { + &self.paths + } + pub fn clear_paths(&mut self) { + self.paths.clear(); + } + + // Param is passed by value, moved + pub fn set_paths(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.paths = v; + } + + // Mutable pointer to the field. + pub fn mut_paths(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.paths + } + + // Take field + pub fn take_paths(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.paths, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for FieldMask { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.paths)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.paths { + my_size += ::protobuf::rt::string_size(1, &value); + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + for v in &self.paths { + os.write_string(1, &v)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> FieldMask { + FieldMask::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "paths", + |m: &FieldMask| { &m.paths }, + |m: &mut FieldMask| { &mut m.paths }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<FieldMask>( + "FieldMask", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static FieldMask { + static mut instance: ::protobuf::lazy::Lazy<FieldMask> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(FieldMask::new) + } + } +} + +impl ::protobuf::Clear for FieldMask { + fn clear(&mut self) { + self.paths.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for FieldMask { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for FieldMask { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x20google/protobuf/field_mask.proto\x12\x0fgoogle.protobuf\"!\n\tFiel\ + dMask\x12\x14\n\x05paths\x18\x01\x20\x03(\tR\x05pathsBN\n\x13com.google.\ + protobufB\x0eFieldMaskProtoP\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protob\ + uf.WellKnownTypesJ\x929\n\x07\x12\x05\x1e\0\xf4\x01\x01\n\xcc\x0c\n\x01\ + \x0c\x12\x03\x1e\0\x122\xc1\x0c\x20Protocol\x20Buffers\x20-\x20Google's\ + \x20data\x20interchange\x20format\n\x20Copyright\x202008\x20Google\x20In\ + c.\x20\x20All\x20rights\x20reserved.\n\x20https://developers.google.com/\ + protocol-buffers/\n\n\x20Redistribution\x20and\x20use\x20in\x20source\ + \x20and\x20binary\x20forms,\x20with\x20or\x20without\n\x20modification,\ + \x20are\x20permitted\x20provided\x20that\x20the\x20following\x20conditio\ + ns\x20are\n\x20met:\n\n\x20\x20\x20\x20\x20*\x20Redistributions\x20of\ + \x20source\x20code\x20must\x20retain\x20the\x20above\x20copyright\n\x20n\ + otice,\x20this\x20list\x20of\x20conditions\x20and\x20the\x20following\ + \x20disclaimer.\n\x20\x20\x20\x20\x20*\x20Redistributions\x20in\x20binar\ + y\x20form\x20must\x20reproduce\x20the\x20above\n\x20copyright\x20notice,\ + \x20this\x20list\x20of\x20conditions\x20and\x20the\x20following\x20discl\ + aimer\n\x20in\x20the\x20documentation\x20and/or\x20other\x20materials\ + \x20provided\x20with\x20the\n\x20distribution.\n\x20\x20\x20\x20\x20*\ + \x20Neither\x20the\x20name\x20of\x20Google\x20Inc.\x20nor\x20the\x20name\ + s\x20of\x20its\n\x20contributors\x20may\x20be\x20used\x20to\x20endorse\ + \x20or\x20promote\x20products\x20derived\x20from\n\x20this\x20software\ + \x20without\x20specific\x20prior\x20written\x20permission.\n\n\x20THIS\ + \x20SOFTWARE\x20IS\x20PROVIDED\x20BY\x20THE\x20COPYRIGHT\x20HOLDERS\x20A\ + ND\x20CONTRIBUTORS\n\x20\"AS\x20IS\"\x20AND\x20ANY\x20EXPRESS\x20OR\x20I\ + MPLIED\x20WARRANTIES,\x20INCLUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\ + \x20THE\x20IMPLIED\x20WARRANTIES\x20OF\x20MERCHANTABILITY\x20AND\x20FITN\ + ESS\x20FOR\n\x20A\x20PARTICULAR\x20PURPOSE\x20ARE\x20DISCLAIMED.\x20IN\ + \x20NO\x20EVENT\x20SHALL\x20THE\x20COPYRIGHT\n\x20OWNER\x20OR\x20CONTRIB\ + UTORS\x20BE\x20LIABLE\x20FOR\x20ANY\x20DIRECT,\x20INDIRECT,\x20INCIDENTA\ + L,\n\x20SPECIAL,\x20EXEMPLARY,\x20OR\x20CONSEQUENTIAL\x20DAMAGES\x20(INC\ + LUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\x20PROCUREMENT\x20OF\x20SUBSTI\ + TUTE\x20GOODS\x20OR\x20SERVICES;\x20LOSS\x20OF\x20USE,\n\x20DATA,\x20OR\ + \x20PROFITS;\x20OR\x20BUSINESS\x20INTERRUPTION)\x20HOWEVER\x20CAUSED\x20\ + AND\x20ON\x20ANY\n\x20THEORY\x20OF\x20LIABILITY,\x20WHETHER\x20IN\x20CON\ + TRACT,\x20STRICT\x20LIABILITY,\x20OR\x20TORT\n\x20(INCLUDING\x20NEGLIGEN\ + CE\x20OR\x20OTHERWISE)\x20ARISING\x20IN\x20ANY\x20WAY\x20OUT\x20OF\x20TH\ + E\x20USE\n\x20OF\x20THIS\x20SOFTWARE,\x20EVEN\x20IF\x20ADVISED\x20OF\x20\ + THE\x20POSSIBILITY\x20OF\x20SUCH\x20DAMAGE.\n\n\x08\n\x01\x02\x12\x03\ + \x20\0\x18\n\x08\n\x01\x08\x12\x03\"\0;\n\t\n\x02\x08%\x12\x03\"\0;\n\ + \x08\n\x01\x08\x12\x03#\0,\n\t\n\x02\x08\x01\x12\x03#\0,\n\x08\n\x01\x08\ + \x12\x03$\0/\n\t\n\x02\x08\x08\x12\x03$\0/\n\x08\n\x01\x08\x12\x03%\0\"\ + \n\t\n\x02\x08\n\x12\x03%\0\"\n\x08\n\x01\x08\x12\x03&\0!\n\t\n\x02\x08$\ + \x12\x03&\0!\n\xcd*\n\x02\x04\0\x12\x06\xf1\x01\0\xf4\x01\x01\x1a\xbe*\ + \x20`FieldMask`\x20represents\x20a\x20set\x20of\x20symbolic\x20field\x20\ + paths,\x20for\x20example:\n\n\x20\x20\x20\x20\x20paths:\x20\"f.a\"\n\x20\ + \x20\x20\x20\x20paths:\x20\"f.b.d\"\n\n\x20Here\x20`f`\x20represents\x20\ + a\x20field\x20in\x20some\x20root\x20message,\x20`a`\x20and\x20`b`\n\x20f\ + ields\x20in\x20the\x20message\x20found\x20in\x20`f`,\x20and\x20`d`\x20a\ + \x20field\x20found\x20in\x20the\n\x20message\x20in\x20`f.b`.\n\n\x20Fiel\ + d\x20masks\x20are\x20used\x20to\x20specify\x20a\x20subset\x20of\x20field\ + s\x20that\x20should\x20be\n\x20returned\x20by\x20a\x20get\x20operation\ + \x20or\x20modified\x20by\x20an\x20update\x20operation.\n\x20Field\x20mas\ + ks\x20also\x20have\x20a\x20custom\x20JSON\x20encoding\x20(see\x20below).\ + \n\n\x20#\x20Field\x20Masks\x20in\x20Projections\n\n\x20When\x20used\x20\ + in\x20the\x20context\x20of\x20a\x20projection,\x20a\x20response\x20messa\ + ge\x20or\n\x20sub-message\x20is\x20filtered\x20by\x20the\x20API\x20to\ + \x20only\x20contain\x20those\x20fields\x20as\n\x20specified\x20in\x20the\ + \x20mask.\x20For\x20example,\x20if\x20the\x20mask\x20in\x20the\x20previo\ + us\n\x20example\x20is\x20applied\x20to\x20a\x20response\x20message\x20as\ + \x20follows:\n\n\x20\x20\x20\x20\x20f\x20{\n\x20\x20\x20\x20\x20\x20\x20\ + a\x20:\x2022\n\x20\x20\x20\x20\x20\x20\x20b\x20{\n\x20\x20\x20\x20\x20\ + \x20\x20\x20\x20d\x20:\x201\n\x20\x20\x20\x20\x20\x20\x20\x20\x20x\x20:\ + \x202\n\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20y\x20:\ + \x2013\n\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20z:\x208\n\n\x20The\ + \x20result\x20will\x20not\x20contain\x20specific\x20values\x20for\x20fie\ + lds\x20x,y\x20and\x20z\n\x20(their\x20value\x20will\x20be\x20set\x20to\ + \x20the\x20default,\x20and\x20omitted\x20in\x20proto\x20text\n\x20output\ + ):\n\n\n\x20\x20\x20\x20\x20f\x20{\n\x20\x20\x20\x20\x20\x20\x20a\x20:\ + \x2022\n\x20\x20\x20\x20\x20\x20\x20b\x20{\n\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20d\x20:\x201\n\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\ + }\n\n\x20A\x20repeated\x20field\x20is\x20not\x20allowed\x20except\x20at\ + \x20the\x20last\x20position\x20of\x20a\n\x20paths\x20string.\n\n\x20If\ + \x20a\x20FieldMask\x20object\x20is\x20not\x20present\x20in\x20a\x20get\ + \x20operation,\x20the\n\x20operation\x20applies\x20to\x20all\x20fields\ + \x20(as\x20if\x20a\x20FieldMask\x20of\x20all\x20fields\n\x20had\x20been\ + \x20specified).\n\n\x20Note\x20that\x20a\x20field\x20mask\x20does\x20not\ + \x20necessarily\x20apply\x20to\x20the\n\x20top-level\x20response\x20mess\ + age.\x20In\x20case\x20of\x20a\x20REST\x20get\x20operation,\x20the\n\x20f\ + ield\x20mask\x20applies\x20directly\x20to\x20the\x20response,\x20but\x20\ + in\x20case\x20of\x20a\x20REST\n\x20list\x20operation,\x20the\x20mask\x20\ + instead\x20applies\x20to\x20each\x20individual\x20message\n\x20in\x20the\ + \x20returned\x20resource\x20list.\x20In\x20case\x20of\x20a\x20REST\x20cu\ + stom\x20method,\n\x20other\x20definitions\x20may\x20be\x20used.\x20Where\ + \x20the\x20mask\x20applies\x20will\x20be\n\x20clearly\x20documented\x20t\ + ogether\x20with\x20its\x20declaration\x20in\x20the\x20API.\x20\x20In\n\ + \x20any\x20case,\x20the\x20effect\x20on\x20the\x20returned\x20resource/r\ + esources\x20is\x20required\n\x20behavior\x20for\x20APIs.\n\n\x20#\x20Fie\ + ld\x20Masks\x20in\x20Update\x20Operations\n\n\x20A\x20field\x20mask\x20i\ + n\x20update\x20operations\x20specifies\x20which\x20fields\x20of\x20the\n\ + \x20targeted\x20resource\x20are\x20going\x20to\x20be\x20updated.\x20The\ + \x20API\x20is\x20required\n\x20to\x20only\x20change\x20the\x20values\x20\ + of\x20the\x20fields\x20as\x20specified\x20in\x20the\x20mask\n\x20and\x20\ + leave\x20the\x20others\x20untouched.\x20If\x20a\x20resource\x20is\x20pas\ + sed\x20in\x20to\n\x20describe\x20the\x20updated\x20values,\x20the\x20API\ + \x20ignores\x20the\x20values\x20of\x20all\n\x20fields\x20not\x20covered\ + \x20by\x20the\x20mask.\n\n\x20If\x20a\x20repeated\x20field\x20is\x20spec\ + ified\x20for\x20an\x20update\x20operation,\x20the\x20existing\n\x20repea\ + ted\x20values\x20in\x20the\x20target\x20resource\x20will\x20be\x20overwr\ + itten\x20by\x20the\x20new\x20values.\n\x20Note\x20that\x20a\x20repeated\ + \x20field\x20is\x20only\x20allowed\x20in\x20the\x20last\x20position\x20o\ + f\x20a\x20`paths`\n\x20string.\n\n\x20If\x20a\x20sub-message\x20is\x20sp\ + ecified\x20in\x20the\x20last\x20position\x20of\x20the\x20field\x20mask\ + \x20for\x20an\n\x20update\x20operation,\x20then\x20the\x20existing\x20su\ + b-message\x20in\x20the\x20target\x20resource\x20is\n\x20overwritten.\x20\ + Given\x20the\x20target\x20message:\n\n\x20\x20\x20\x20\x20f\x20{\n\x20\ + \x20\x20\x20\x20\x20\x20b\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20d\ + \x20:\x201\n\x20\x20\x20\x20\x20\x20\x20\x20\x20x\x20:\x202\n\x20\x20\ + \x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20c\x20:\x201\n\x20\x20\ + \x20\x20\x20}\n\n\x20And\x20an\x20update\x20message:\n\n\x20\x20\x20\x20\ + \x20f\x20{\n\x20\x20\x20\x20\x20\x20\x20b\x20{\n\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20d\x20:\x2010\n\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\ + \x20\x20}\n\n\x20then\x20if\x20the\x20field\x20mask\x20is:\n\n\x20\x20pa\ + ths:\x20\"f.b\"\n\n\x20then\x20the\x20result\x20will\x20be:\n\n\x20\x20\ + \x20\x20\x20f\x20{\n\x20\x20\x20\x20\x20\x20\x20b\x20{\n\x20\x20\x20\x20\ + \x20\x20\x20\x20\x20d\x20:\x2010\n\x20\x20\x20\x20\x20\x20\x20}\n\x20\ + \x20\x20\x20\x20\x20\x20c\x20:\x201\n\x20\x20\x20\x20\x20}\n\n\x20Howeve\ + r,\x20if\x20the\x20update\x20mask\x20was:\n\n\x20\x20paths:\x20\"f.b.d\"\ + \n\n\x20then\x20the\x20result\x20would\x20be:\n\n\x20\x20\x20\x20\x20f\ + \x20{\n\x20\x20\x20\x20\x20\x20\x20b\x20{\n\x20\x20\x20\x20\x20\x20\x20\ + \x20\x20d\x20:\x2010\n\x20\x20\x20\x20\x20\x20\x20\x20\x20x\x20:\x202\n\ + \x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20c\x20:\x201\n\ + \x20\x20\x20\x20\x20}\n\n\x20In\x20order\x20to\x20reset\x20a\x20field's\ + \x20value\x20to\x20the\x20default,\x20the\x20field\x20must\n\x20be\x20in\ + \x20the\x20mask\x20and\x20set\x20to\x20the\x20default\x20value\x20in\x20\ + the\x20provided\x20resource.\n\x20Hence,\x20in\x20order\x20to\x20reset\ + \x20all\x20fields\x20of\x20a\x20resource,\x20provide\x20a\x20default\n\ + \x20instance\x20of\x20the\x20resource\x20and\x20set\x20all\x20fields\x20\ + in\x20the\x20mask,\x20or\x20do\n\x20not\x20provide\x20a\x20mask\x20as\ + \x20described\x20below.\n\n\x20If\x20a\x20field\x20mask\x20is\x20not\x20\ + present\x20on\x20update,\x20the\x20operation\x20applies\x20to\n\x20all\ + \x20fields\x20(as\x20if\x20a\x20field\x20mask\x20of\x20all\x20fields\x20\ + has\x20been\x20specified).\n\x20Note\x20that\x20in\x20the\x20presence\ + \x20of\x20schema\x20evolution,\x20this\x20may\x20mean\x20that\n\x20field\ + s\x20the\x20client\x20does\x20not\x20know\x20and\x20has\x20therefore\x20\ + not\x20filled\x20into\n\x20the\x20request\x20will\x20be\x20reset\x20to\ + \x20their\x20default.\x20If\x20this\x20is\x20unwanted\n\x20behavior,\x20\ + a\x20specific\x20service\x20may\x20require\x20a\x20client\x20to\x20alway\ + s\x20specify\n\x20a\x20field\x20mask,\x20producing\x20an\x20error\x20if\ + \x20not.\n\n\x20As\x20with\x20get\x20operations,\x20the\x20location\x20o\ + f\x20the\x20resource\x20which\n\x20describes\x20the\x20updated\x20values\ + \x20in\x20the\x20request\x20message\x20depends\x20on\x20the\n\x20operati\ + on\x20kind.\x20In\x20any\x20case,\x20the\x20effect\x20of\x20the\x20field\ + \x20mask\x20is\n\x20required\x20to\x20be\x20honored\x20by\x20the\x20API.\ + \n\n\x20##\x20Considerations\x20for\x20HTTP\x20REST\n\n\x20The\x20HTTP\ + \x20kind\x20of\x20an\x20update\x20operation\x20which\x20uses\x20a\x20fie\ + ld\x20mask\x20must\n\x20be\x20set\x20to\x20PATCH\x20instead\x20of\x20PUT\ + \x20in\x20order\x20to\x20satisfy\x20HTTP\x20semantics\n\x20(PUT\x20must\ + \x20only\x20be\x20used\x20for\x20full\x20updates).\n\n\x20#\x20JSON\x20E\ + ncoding\x20of\x20Field\x20Masks\n\n\x20In\x20JSON,\x20a\x20field\x20mask\ + \x20is\x20encoded\x20as\x20a\x20single\x20string\x20where\x20paths\x20ar\ + e\n\x20separated\x20by\x20a\x20comma.\x20Fields\x20name\x20in\x20each\ + \x20path\x20are\x20converted\n\x20to/from\x20lower-camel\x20naming\x20co\ + nventions.\n\n\x20As\x20an\x20example,\x20consider\x20the\x20following\ + \x20message\x20declarations:\n\n\x20\x20\x20\x20\x20message\x20Profile\ + \x20{\n\x20\x20\x20\x20\x20\x20\x20User\x20user\x20=\x201;\n\x20\x20\x20\ + \x20\x20\x20\x20Photo\x20photo\x20=\x202;\n\x20\x20\x20\x20\x20}\n\x20\ + \x20\x20\x20\x20message\x20User\x20{\n\x20\x20\x20\x20\x20\x20\x20string\ + \x20display_name\x20=\x201;\n\x20\x20\x20\x20\x20\x20\x20string\x20addre\ + ss\x20=\x202;\n\x20\x20\x20\x20\x20}\n\n\x20In\x20proto\x20a\x20field\ + \x20mask\x20for\x20`Profile`\x20may\x20look\x20as\x20such:\n\n\x20\x20\ + \x20\x20\x20mask\x20{\n\x20\x20\x20\x20\x20\x20\x20paths:\x20\"user.disp\ + lay_name\"\n\x20\x20\x20\x20\x20\x20\x20paths:\x20\"photo\"\n\x20\x20\ + \x20\x20\x20}\n\n\x20In\x20JSON,\x20the\x20same\x20mask\x20is\x20represe\ + nted\x20as\x20below:\n\n\x20\x20\x20\x20\x20{\n\x20\x20\x20\x20\x20\x20\ + \x20mask:\x20\"user.displayName,photo\"\n\x20\x20\x20\x20\x20}\n\n\x20#\ + \x20Field\x20Masks\x20and\x20Oneof\x20Fields\n\n\x20Field\x20masks\x20tr\ + eat\x20fields\x20in\x20oneofs\x20just\x20as\x20regular\x20fields.\x20Con\ + sider\x20the\n\x20following\x20message:\n\n\x20\x20\x20\x20\x20message\ + \x20SampleMessage\x20{\n\x20\x20\x20\x20\x20\x20\x20oneof\x20test_oneof\ + \x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20string\x20name\x20=\x204;\n\ + \x20\x20\x20\x20\x20\x20\x20\x20\x20SubMessage\x20sub_message\x20=\x209;\ + \n\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20}\n\n\x20The\x20fie\ + ld\x20mask\x20can\x20be:\n\n\x20\x20\x20\x20\x20mask\x20{\n\x20\x20\x20\ + \x20\x20\x20\x20paths:\x20\"name\"\n\x20\x20\x20\x20\x20}\n\n\x20Or:\n\n\ + \x20\x20\x20\x20\x20mask\x20{\n\x20\x20\x20\x20\x20\x20\x20paths:\x20\"s\ + ub_message\"\n\x20\x20\x20\x20\x20}\n\n\x20Note\x20that\x20oneof\x20type\ + \x20names\x20(\"test_oneof\"\x20in\x20this\x20case)\x20cannot\x20be\x20u\ + sed\x20in\n\x20paths.\n\n\x0b\n\x03\x04\0\x01\x12\x04\xf1\x01\x08\x11\n,\ + \n\x04\x04\0\x02\0\x12\x04\xf3\x01\x02\x1c\x1a\x1e\x20The\x20set\x20of\ + \x20field\x20mask\x20paths.\n\n\r\n\x05\x04\0\x02\0\x04\x12\x04\xf3\x01\ + \x02\n\n\r\n\x05\x04\0\x02\0\x05\x12\x04\xf3\x01\x0b\x11\n\r\n\x05\x04\0\ + \x02\0\x01\x12\x04\xf3\x01\x12\x17\n\r\n\x05\x04\0\x02\0\x03\x12\x04\xf3\ + \x01\x1a\x1bb\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/src/well_known_types/mod.rs b/src/well_known_types/mod.rs new file mode 100644 index 0000000..9ecf8fb --- /dev/null +++ b/src/well_known_types/mod.rs @@ -0,0 +1,26 @@ +// This file is generated. Do not edit +//! Generated code for "well known types" +//! +//! [This document](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf) describes these types. + +mod any; +mod api; +mod duration; +mod empty; +mod field_mask; +mod source_context; +mod struct_pb; +mod timestamp; +mod type_pb; +mod wrappers; + +pub use self::any::*; +pub use self::api::*; +pub use self::duration::*; +pub use self::empty::*; +pub use self::field_mask::*; +pub use self::source_context::*; +pub use self::struct_pb::*; +pub use self::timestamp::*; +pub use self::type_pb::*; +pub use self::wrappers::*; diff --git a/src/well_known_types/source_context.rs b/src/well_known_types/source_context.rs new file mode 100644 index 0000000..c9a9e26 --- /dev/null +++ b/src/well_known_types/source_context.rs @@ -0,0 +1,258 @@ +// This file is generated by rust-protobuf 2.14.0-pre. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/protobuf/source_context.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct SourceContext { + // message fields + pub file_name: ::std::string::String, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a SourceContext { + fn default() -> &'a SourceContext { + <SourceContext as ::protobuf::Message>::default_instance() + } +} + +impl SourceContext { + pub fn new() -> SourceContext { + ::std::default::Default::default() + } + + // string file_name = 1; + + + pub fn get_file_name(&self) -> &str { + &self.file_name + } + pub fn clear_file_name(&mut self) { + self.file_name.clear(); + } + + // Param is passed by value, moved + pub fn set_file_name(&mut self, v: ::std::string::String) { + self.file_name = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_file_name(&mut self) -> &mut ::std::string::String { + &mut self.file_name + } + + // Take field + pub fn take_file_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.file_name, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for SourceContext { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.file_name)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.file_name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.file_name); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.file_name.is_empty() { + os.write_string(1, &self.file_name)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> SourceContext { + SourceContext::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "file_name", + |m: &SourceContext| { &m.file_name }, + |m: &mut SourceContext| { &mut m.file_name }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<SourceContext>( + "SourceContext", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static SourceContext { + static mut instance: ::protobuf::lazy::Lazy<SourceContext> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(SourceContext::new) + } + } +} + +impl ::protobuf::Clear for SourceContext { + fn clear(&mut self) { + self.file_name.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for SourceContext { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for SourceContext { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n$google/protobuf/source_context.proto\x12\x0fgoogle.protobuf\",\n\rSou\ + rceContext\x12\x1b\n\tfile_name\x18\x01\x20\x01(\tR\x08fileNameBR\n\x13c\ + om.google.protobufB\x12SourceContextProtoP\x01\xa2\x02\x03GPB\xaa\x02\ + \x1eGoogle.Protobuf.WellKnownTypesJ\xac\x10\n\x06\x12\x04\x1e\0.\x01\n\ + \xcc\x0c\n\x01\x0c\x12\x03\x1e\0\x122\xc1\x0c\x20Protocol\x20Buffers\x20\ + -\x20Google's\x20data\x20interchange\x20format\n\x20Copyright\x202008\ + \x20Google\x20Inc.\x20\x20All\x20rights\x20reserved.\n\x20https://develo\ + pers.google.com/protocol-buffers/\n\n\x20Redistribution\x20and\x20use\ + \x20in\x20source\x20and\x20binary\x20forms,\x20with\x20or\x20without\n\ + \x20modification,\x20are\x20permitted\x20provided\x20that\x20the\x20foll\ + owing\x20conditions\x20are\n\x20met:\n\n\x20\x20\x20\x20\x20*\x20Redistr\ + ibutions\x20of\x20source\x20code\x20must\x20retain\x20the\x20above\x20co\ + pyright\n\x20notice,\x20this\x20list\x20of\x20conditions\x20and\x20the\ + \x20following\x20disclaimer.\n\x20\x20\x20\x20\x20*\x20Redistributions\ + \x20in\x20binary\x20form\x20must\x20reproduce\x20the\x20above\n\x20copyr\ + ight\x20notice,\x20this\x20list\x20of\x20conditions\x20and\x20the\x20fol\ + lowing\x20disclaimer\n\x20in\x20the\x20documentation\x20and/or\x20other\ + \x20materials\x20provided\x20with\x20the\n\x20distribution.\n\x20\x20\ + \x20\x20\x20*\x20Neither\x20the\x20name\x20of\x20Google\x20Inc.\x20nor\ + \x20the\x20names\x20of\x20its\n\x20contributors\x20may\x20be\x20used\x20\ + to\x20endorse\x20or\x20promote\x20products\x20derived\x20from\n\x20this\ + \x20software\x20without\x20specific\x20prior\x20written\x20permission.\n\ + \n\x20THIS\x20SOFTWARE\x20IS\x20PROVIDED\x20BY\x20THE\x20COPYRIGHT\x20HO\ + LDERS\x20AND\x20CONTRIBUTORS\n\x20\"AS\x20IS\"\x20AND\x20ANY\x20EXPRESS\ + \x20OR\x20IMPLIED\x20WARRANTIES,\x20INCLUDING,\x20BUT\x20NOT\n\x20LIMITE\ + D\x20TO,\x20THE\x20IMPLIED\x20WARRANTIES\x20OF\x20MERCHANTABILITY\x20AND\ + \x20FITNESS\x20FOR\n\x20A\x20PARTICULAR\x20PURPOSE\x20ARE\x20DISCLAIMED.\ + \x20IN\x20NO\x20EVENT\x20SHALL\x20THE\x20COPYRIGHT\n\x20OWNER\x20OR\x20C\ + ONTRIBUTORS\x20BE\x20LIABLE\x20FOR\x20ANY\x20DIRECT,\x20INDIRECT,\x20INC\ + IDENTAL,\n\x20SPECIAL,\x20EXEMPLARY,\x20OR\x20CONSEQUENTIAL\x20DAMAGES\ + \x20(INCLUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\x20PROCUREMENT\x20OF\ + \x20SUBSTITUTE\x20GOODS\x20OR\x20SERVICES;\x20LOSS\x20OF\x20USE,\n\x20DA\ + TA,\x20OR\x20PROFITS;\x20OR\x20BUSINESS\x20INTERRUPTION)\x20HOWEVER\x20C\ + AUSED\x20AND\x20ON\x20ANY\n\x20THEORY\x20OF\x20LIABILITY,\x20WHETHER\x20\ + IN\x20CONTRACT,\x20STRICT\x20LIABILITY,\x20OR\x20TORT\n\x20(INCLUDING\ + \x20NEGLIGENCE\x20OR\x20OTHERWISE)\x20ARISING\x20IN\x20ANY\x20WAY\x20OUT\ + \x20OF\x20THE\x20USE\n\x20OF\x20THIS\x20SOFTWARE,\x20EVEN\x20IF\x20ADVIS\ + ED\x20OF\x20THE\x20POSSIBILITY\x20OF\x20SUCH\x20DAMAGE.\n\n\x08\n\x01\ + \x02\x12\x03\x20\0\x18\n\x08\n\x01\x08\x12\x03\"\0;\n\t\n\x02\x08%\x12\ + \x03\"\0;\n\x08\n\x01\x08\x12\x03#\0,\n\t\n\x02\x08\x01\x12\x03#\0,\n\ + \x08\n\x01\x08\x12\x03$\03\n\t\n\x02\x08\x08\x12\x03$\03\n\x08\n\x01\x08\ + \x12\x03%\0\"\n\t\n\x02\x08\n\x12\x03%\0\"\n\x08\n\x01\x08\x12\x03&\0!\n\ + \t\n\x02\x08$\x12\x03&\0!\n\x83\x01\n\x02\x04\0\x12\x04*\0.\x01\x1aw\x20\ + `SourceContext`\x20represents\x20information\x20about\x20the\x20source\ + \x20of\x20a\n\x20protobuf\x20element,\x20like\x20the\x20file\x20in\x20wh\ + ich\x20it\x20is\x20defined.\n\n\n\n\x03\x04\0\x01\x12\x03*\x08\x15\n\xa3\ + \x01\n\x04\x04\0\x02\0\x12\x03-\x02\x17\x1a\x95\x01\x20The\x20path-quali\ + fied\x20name\x20of\x20the\x20.proto\x20file\x20that\x20contained\x20the\ + \x20associated\n\x20protobuf\x20element.\x20\x20For\x20example:\x20`\"go\ + ogle/protobuf/source_context.proto\"`.\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\ + \x03-\x02\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03-\t\x12\n\x0c\n\x05\x04\ + \0\x02\0\x03\x12\x03-\x15\x16b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/src/well_known_types/struct_pb.rs b/src/well_known_types/struct_pb.rs new file mode 100644 index 0000000..f644b20 --- /dev/null +++ b/src/well_known_types/struct_pb.rs @@ -0,0 +1,1028 @@ +// This file is generated by rust-protobuf 2.14.0-pre. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/protobuf/struct.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Struct { + // message fields + pub fields: ::std::collections::HashMap<::std::string::String, Value>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Struct { + fn default() -> &'a Struct { + <Struct as ::protobuf::Message>::default_instance() + } +} + +impl Struct { + pub fn new() -> Struct { + ::std::default::Default::default() + } + + // repeated .google.protobuf.Struct.FieldsEntry fields = 1; + + + pub fn get_fields(&self) -> &::std::collections::HashMap<::std::string::String, Value> { + &self.fields + } + pub fn clear_fields(&mut self) { + self.fields.clear(); + } + + // Param is passed by value, moved + pub fn set_fields(&mut self, v: ::std::collections::HashMap<::std::string::String, Value>) { + self.fields = v; + } + + // Mutable pointer to the field. + pub fn mut_fields(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, Value> { + &mut self.fields + } + + // Take field + pub fn take_fields(&mut self) -> ::std::collections::HashMap<::std::string::String, Value> { + ::std::mem::replace(&mut self.fields, ::std::collections::HashMap::new()) + } +} + +impl ::protobuf::Message for Struct { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<Value>>(wire_type, is, &mut self.fields)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<Value>>(1, &self.fields); + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<Value>>(1, &self.fields, os)?; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Struct { + Struct::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<Value>>( + "fields", + |m: &Struct| { &m.fields }, + |m: &mut Struct| { &mut m.fields }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Struct>( + "Struct", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Struct { + static mut instance: ::protobuf::lazy::Lazy<Struct> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Struct::new) + } + } +} + +impl ::protobuf::Clear for Struct { + fn clear(&mut self) { + self.fields.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Struct { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Struct { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Value { + // message oneof groups + pub kind: ::std::option::Option<Value_oneof_kind>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Value { + fn default() -> &'a Value { + <Value as ::protobuf::Message>::default_instance() + } +} + +#[derive(Clone,PartialEq,Debug)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub enum Value_oneof_kind { + null_value(NullValue), + number_value(f64), + string_value(::std::string::String), + bool_value(bool), + struct_value(Struct), + list_value(ListValue), +} + +impl Value { + pub fn new() -> Value { + ::std::default::Default::default() + } + + // .google.protobuf.NullValue null_value = 1; + + + pub fn get_null_value(&self) -> NullValue { + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::null_value(v)) => v, + _ => NullValue::NULL_VALUE, + } + } + pub fn clear_null_value(&mut self) { + self.kind = ::std::option::Option::None; + } + + pub fn has_null_value(&self) -> bool { + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::null_value(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_null_value(&mut self, v: NullValue) { + self.kind = ::std::option::Option::Some(Value_oneof_kind::null_value(v)) + } + + // double number_value = 2; + + + pub fn get_number_value(&self) -> f64 { + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::number_value(v)) => v, + _ => 0., + } + } + pub fn clear_number_value(&mut self) { + self.kind = ::std::option::Option::None; + } + + pub fn has_number_value(&self) -> bool { + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::number_value(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_number_value(&mut self, v: f64) { + self.kind = ::std::option::Option::Some(Value_oneof_kind::number_value(v)) + } + + // string string_value = 3; + + + pub fn get_string_value(&self) -> &str { + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::string_value(ref v)) => v, + _ => "", + } + } + pub fn clear_string_value(&mut self) { + self.kind = ::std::option::Option::None; + } + + pub fn has_string_value(&self) -> bool { + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::string_value(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_string_value(&mut self, v: ::std::string::String) { + self.kind = ::std::option::Option::Some(Value_oneof_kind::string_value(v)) + } + + // Mutable pointer to the field. + pub fn mut_string_value(&mut self) -> &mut ::std::string::String { + if let ::std::option::Option::Some(Value_oneof_kind::string_value(_)) = self.kind { + } else { + self.kind = ::std::option::Option::Some(Value_oneof_kind::string_value(::std::string::String::new())); + } + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::string_value(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_string_value(&mut self) -> ::std::string::String { + if self.has_string_value() { + match self.kind.take() { + ::std::option::Option::Some(Value_oneof_kind::string_value(v)) => v, + _ => panic!(), + } + } else { + ::std::string::String::new() + } + } + + // bool bool_value = 4; + + + pub fn get_bool_value(&self) -> bool { + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::bool_value(v)) => v, + _ => false, + } + } + pub fn clear_bool_value(&mut self) { + self.kind = ::std::option::Option::None; + } + + pub fn has_bool_value(&self) -> bool { + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::bool_value(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_bool_value(&mut self, v: bool) { + self.kind = ::std::option::Option::Some(Value_oneof_kind::bool_value(v)) + } + + // .google.protobuf.Struct struct_value = 5; + + + pub fn get_struct_value(&self) -> &Struct { + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::struct_value(ref v)) => v, + _ => Struct::default_instance(), + } + } + pub fn clear_struct_value(&mut self) { + self.kind = ::std::option::Option::None; + } + + pub fn has_struct_value(&self) -> bool { + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::struct_value(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_struct_value(&mut self, v: Struct) { + self.kind = ::std::option::Option::Some(Value_oneof_kind::struct_value(v)) + } + + // Mutable pointer to the field. + pub fn mut_struct_value(&mut self) -> &mut Struct { + if let ::std::option::Option::Some(Value_oneof_kind::struct_value(_)) = self.kind { + } else { + self.kind = ::std::option::Option::Some(Value_oneof_kind::struct_value(Struct::new())); + } + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::struct_value(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_struct_value(&mut self) -> Struct { + if self.has_struct_value() { + match self.kind.take() { + ::std::option::Option::Some(Value_oneof_kind::struct_value(v)) => v, + _ => panic!(), + } + } else { + Struct::new() + } + } + + // .google.protobuf.ListValue list_value = 6; + + + pub fn get_list_value(&self) -> &ListValue { + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::list_value(ref v)) => v, + _ => ListValue::default_instance(), + } + } + pub fn clear_list_value(&mut self) { + self.kind = ::std::option::Option::None; + } + + pub fn has_list_value(&self) -> bool { + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::list_value(..)) => true, + _ => false, + } + } + + // Param is passed by value, moved + pub fn set_list_value(&mut self, v: ListValue) { + self.kind = ::std::option::Option::Some(Value_oneof_kind::list_value(v)) + } + + // Mutable pointer to the field. + pub fn mut_list_value(&mut self) -> &mut ListValue { + if let ::std::option::Option::Some(Value_oneof_kind::list_value(_)) = self.kind { + } else { + self.kind = ::std::option::Option::Some(Value_oneof_kind::list_value(ListValue::new())); + } + match self.kind { + ::std::option::Option::Some(Value_oneof_kind::list_value(ref mut v)) => v, + _ => panic!(), + } + } + + // Take field + pub fn take_list_value(&mut self) -> ListValue { + if self.has_list_value() { + match self.kind.take() { + ::std::option::Option::Some(Value_oneof_kind::list_value(v)) => v, + _ => panic!(), + } + } else { + ListValue::new() + } + } +} + +impl ::protobuf::Message for Value { + fn is_initialized(&self) -> bool { + if let Some(Value_oneof_kind::struct_value(ref v)) = self.kind { + if !v.is_initialized() { + return false; + } + } + if let Some(Value_oneof_kind::list_value(ref v)) = self.kind { + if !v.is_initialized() { + return false; + } + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.kind = ::std::option::Option::Some(Value_oneof_kind::null_value(is.read_enum()?)); + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeFixed64 { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.kind = ::std::option::Option::Some(Value_oneof_kind::number_value(is.read_double()?)); + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.kind = ::std::option::Option::Some(Value_oneof_kind::string_value(is.read_string()?)); + }, + 4 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.kind = ::std::option::Option::Some(Value_oneof_kind::bool_value(is.read_bool()?)); + }, + 5 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.kind = ::std::option::Option::Some(Value_oneof_kind::struct_value(is.read_message()?)); + }, + 6 => { + if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + self.kind = ::std::option::Option::Some(Value_oneof_kind::list_value(is.read_message()?)); + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if let ::std::option::Option::Some(ref v) = self.kind { + match v { + &Value_oneof_kind::null_value(v) => { + my_size += ::protobuf::rt::enum_size(1, v); + }, + &Value_oneof_kind::number_value(v) => { + my_size += 9; + }, + &Value_oneof_kind::string_value(ref v) => { + my_size += ::protobuf::rt::string_size(3, &v); + }, + &Value_oneof_kind::bool_value(v) => { + my_size += 2; + }, + &Value_oneof_kind::struct_value(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + &Value_oneof_kind::list_value(ref v) => { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }, + }; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if let ::std::option::Option::Some(ref v) = self.kind { + match v { + &Value_oneof_kind::null_value(v) => { + os.write_enum(1, v.value())?; + }, + &Value_oneof_kind::number_value(v) => { + os.write_double(2, v)?; + }, + &Value_oneof_kind::string_value(ref v) => { + os.write_string(3, v)?; + }, + &Value_oneof_kind::bool_value(v) => { + os.write_bool(4, v)?; + }, + &Value_oneof_kind::struct_value(ref v) => { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + &Value_oneof_kind::list_value(ref v) => { + os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }, + }; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Value { + Value::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor::<_, NullValue>( + "null_value", + Value::has_null_value, + Value::get_null_value, + )); + fields.push(::protobuf::reflect::accessor::make_singular_f64_accessor::<_>( + "number_value", + Value::has_number_value, + Value::get_number_value, + )); + fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>( + "string_value", + Value::has_string_value, + Value::get_string_value, + )); + fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>( + "bool_value", + Value::has_bool_value, + Value::get_bool_value, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Struct>( + "struct_value", + Value::has_struct_value, + Value::get_struct_value, + )); + fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ListValue>( + "list_value", + Value::has_list_value, + Value::get_list_value, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Value>( + "Value", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Value { + static mut instance: ::protobuf::lazy::Lazy<Value> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Value::new) + } + } +} + +impl ::protobuf::Clear for Value { + fn clear(&mut self) { + self.kind = ::std::option::Option::None; + self.kind = ::std::option::Option::None; + self.kind = ::std::option::Option::None; + self.kind = ::std::option::Option::None; + self.kind = ::std::option::Option::None; + self.kind = ::std::option::Option::None; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Value { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Value { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct ListValue { + // message fields + pub values: ::protobuf::RepeatedField<Value>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a ListValue { + fn default() -> &'a ListValue { + <ListValue as ::protobuf::Message>::default_instance() + } +} + +impl ListValue { + pub fn new() -> ListValue { + ::std::default::Default::default() + } + + // repeated .google.protobuf.Value values = 1; + + + pub fn get_values(&self) -> &[Value] { + &self.values + } + pub fn clear_values(&mut self) { + self.values.clear(); + } + + // Param is passed by value, moved + pub fn set_values(&mut self, v: ::protobuf::RepeatedField<Value>) { + self.values = v; + } + + // Mutable pointer to the field. + pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<Value> { + &mut self.values + } + + // Take field + pub fn take_values(&mut self) -> ::protobuf::RepeatedField<Value> { + ::std::mem::replace(&mut self.values, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for ListValue { + fn is_initialized(&self) -> bool { + for v in &self.values { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.values)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + for value in &self.values { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + for v in &self.values { + os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> ListValue { + ListValue::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Value>>( + "values", + |m: &ListValue| { &m.values }, + |m: &mut ListValue| { &mut m.values }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListValue>( + "ListValue", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static ListValue { + static mut instance: ::protobuf::lazy::Lazy<ListValue> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(ListValue::new) + } + } +} + +impl ::protobuf::Clear for ListValue { + fn clear(&mut self) { + self.values.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for ListValue { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for ListValue { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub enum NullValue { + NULL_VALUE = 0, +} + +impl ::protobuf::ProtobufEnum for NullValue { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option<NullValue> { + match value { + 0 => ::std::option::Option::Some(NullValue::NULL_VALUE), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [NullValue] = &[ + NullValue::NULL_VALUE, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new_pb_name::<NullValue>("NullValue", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for NullValue { +} + +impl ::std::default::Default for NullValue { + fn default() -> Self { + NullValue::NULL_VALUE + } +} + +impl ::protobuf::reflect::ProtobufValue for NullValue { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor()) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1cgoogle/protobuf/struct.proto\x12\x0fgoogle.protobuf\"\x98\x01\n\ + \x06Struct\x12;\n\x06fields\x18\x01\x20\x03(\x0b2#.google.protobuf.Struc\ + t.FieldsEntryR\x06fields\x1aQ\n\x0bFieldsEntry\x12\x10\n\x03key\x18\x01\ + \x20\x01(\tR\x03key\x12,\n\x05value\x18\x02\x20\x01(\x0b2\x16.google.pro\ + tobuf.ValueR\x05value:\x028\x01\"\xb2\x02\n\x05Value\x12;\n\nnull_value\ + \x18\x01\x20\x01(\x0e2\x1a.google.protobuf.NullValueH\0R\tnullValue\x12#\ + \n\x0cnumber_value\x18\x02\x20\x01(\x01H\0R\x0bnumberValue\x12#\n\x0cstr\ + ing_value\x18\x03\x20\x01(\tH\0R\x0bstringValue\x12\x1f\n\nbool_value\ + \x18\x04\x20\x01(\x08H\0R\tboolValue\x12<\n\x0cstruct_value\x18\x05\x20\ + \x01(\x0b2\x17.google.protobuf.StructH\0R\x0bstructValue\x12;\n\nlist_va\ + lue\x18\x06\x20\x01(\x0b2\x1a.google.protobuf.ListValueH\0R\tlistValueB\ + \x06\n\x04kind\";\n\tListValue\x12.\n\x06values\x18\x01\x20\x03(\x0b2\ + \x16.google.protobuf.ValueR\x06values*\x1b\n\tNullValue\x12\x0e\n\nNULL_\ + VALUE\x10\0B\x81\x01\n\x13com.google.protobufB\x0bStructProtoP\x01Z1gith\ + ub.com/golang/protobuf/ptypes/struct;structpb\xf8\x01\x01\xa2\x02\x03GPB\ + \xaa\x02\x1eGoogle.Protobuf.WellKnownTypesJ\x99\x1d\n\x06\x12\x04\x1e\0_\ + \x01\n\xcc\x0c\n\x01\x0c\x12\x03\x1e\0\x122\xc1\x0c\x20Protocol\x20Buffe\ + rs\x20-\x20Google's\x20data\x20interchange\x20format\n\x20Copyright\x202\ + 008\x20Google\x20Inc.\x20\x20All\x20rights\x20reserved.\n\x20https://dev\ + elopers.google.com/protocol-buffers/\n\n\x20Redistribution\x20and\x20use\ + \x20in\x20source\x20and\x20binary\x20forms,\x20with\x20or\x20without\n\ + \x20modification,\x20are\x20permitted\x20provided\x20that\x20the\x20foll\ + owing\x20conditions\x20are\n\x20met:\n\n\x20\x20\x20\x20\x20*\x20Redistr\ + ibutions\x20of\x20source\x20code\x20must\x20retain\x20the\x20above\x20co\ + pyright\n\x20notice,\x20this\x20list\x20of\x20conditions\x20and\x20the\ + \x20following\x20disclaimer.\n\x20\x20\x20\x20\x20*\x20Redistributions\ + \x20in\x20binary\x20form\x20must\x20reproduce\x20the\x20above\n\x20copyr\ + ight\x20notice,\x20this\x20list\x20of\x20conditions\x20and\x20the\x20fol\ + lowing\x20disclaimer\n\x20in\x20the\x20documentation\x20and/or\x20other\ + \x20materials\x20provided\x20with\x20the\n\x20distribution.\n\x20\x20\ + \x20\x20\x20*\x20Neither\x20the\x20name\x20of\x20Google\x20Inc.\x20nor\ + \x20the\x20names\x20of\x20its\n\x20contributors\x20may\x20be\x20used\x20\ + to\x20endorse\x20or\x20promote\x20products\x20derived\x20from\n\x20this\ + \x20software\x20without\x20specific\x20prior\x20written\x20permission.\n\ + \n\x20THIS\x20SOFTWARE\x20IS\x20PROVIDED\x20BY\x20THE\x20COPYRIGHT\x20HO\ + LDERS\x20AND\x20CONTRIBUTORS\n\x20\"AS\x20IS\"\x20AND\x20ANY\x20EXPRESS\ + \x20OR\x20IMPLIED\x20WARRANTIES,\x20INCLUDING,\x20BUT\x20NOT\n\x20LIMITE\ + D\x20TO,\x20THE\x20IMPLIED\x20WARRANTIES\x20OF\x20MERCHANTABILITY\x20AND\ + \x20FITNESS\x20FOR\n\x20A\x20PARTICULAR\x20PURPOSE\x20ARE\x20DISCLAIMED.\ + \x20IN\x20NO\x20EVENT\x20SHALL\x20THE\x20COPYRIGHT\n\x20OWNER\x20OR\x20C\ + ONTRIBUTORS\x20BE\x20LIABLE\x20FOR\x20ANY\x20DIRECT,\x20INDIRECT,\x20INC\ + IDENTAL,\n\x20SPECIAL,\x20EXEMPLARY,\x20OR\x20CONSEQUENTIAL\x20DAMAGES\ + \x20(INCLUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\x20PROCUREMENT\x20OF\ + \x20SUBSTITUTE\x20GOODS\x20OR\x20SERVICES;\x20LOSS\x20OF\x20USE,\n\x20DA\ + TA,\x20OR\x20PROFITS;\x20OR\x20BUSINESS\x20INTERRUPTION)\x20HOWEVER\x20C\ + AUSED\x20AND\x20ON\x20ANY\n\x20THEORY\x20OF\x20LIABILITY,\x20WHETHER\x20\ + IN\x20CONTRACT,\x20STRICT\x20LIABILITY,\x20OR\x20TORT\n\x20(INCLUDING\ + \x20NEGLIGENCE\x20OR\x20OTHERWISE)\x20ARISING\x20IN\x20ANY\x20WAY\x20OUT\ + \x20OF\x20THE\x20USE\n\x20OF\x20THIS\x20SOFTWARE,\x20EVEN\x20IF\x20ADVIS\ + ED\x20OF\x20THE\x20POSSIBILITY\x20OF\x20SUCH\x20DAMAGE.\n\n\x08\n\x01\ + \x02\x12\x03\x20\0\x18\n\x08\n\x01\x08\x12\x03\"\0;\n\t\n\x02\x08%\x12\ + \x03\"\0;\n\x08\n\x01\x08\x12\x03#\0\x1f\n\t\n\x02\x08\x1f\x12\x03#\0\ + \x1f\n\x08\n\x01\x08\x12\x03$\0H\n\t\n\x02\x08\x0b\x12\x03$\0H\n\x08\n\ + \x01\x08\x12\x03%\0,\n\t\n\x02\x08\x01\x12\x03%\0,\n\x08\n\x01\x08\x12\ + \x03&\0,\n\t\n\x02\x08\x08\x12\x03&\0,\n\x08\n\x01\x08\x12\x03'\0\"\n\t\ + \n\x02\x08\n\x12\x03'\0\"\n\x08\n\x01\x08\x12\x03(\0!\n\t\n\x02\x08$\x12\ + \x03(\0!\n\xb3\x03\n\x02\x04\0\x12\x043\06\x01\x1a\xa6\x03\x20`Struct`\ + \x20represents\x20a\x20structured\x20data\x20value,\x20consisting\x20of\ + \x20fields\n\x20which\x20map\x20to\x20dynamically\x20typed\x20values.\ + \x20In\x20some\x20languages,\x20`Struct`\n\x20might\x20be\x20supported\ + \x20by\x20a\x20native\x20representation.\x20For\x20example,\x20in\n\x20s\ + cripting\x20languages\x20like\x20JS\x20a\x20struct\x20is\x20represented\ + \x20as\x20an\n\x20object.\x20The\x20details\x20of\x20that\x20representat\ + ion\x20are\x20described\x20together\n\x20with\x20the\x20proto\x20support\ + \x20for\x20the\x20language.\n\n\x20The\x20JSON\x20representation\x20for\ + \x20`Struct`\x20is\x20JSON\x20object.\n\n\n\n\x03\x04\0\x01\x12\x033\x08\ + \x0e\n9\n\x04\x04\0\x02\0\x12\x035\x02\x20\x1a,\x20Unordered\x20map\x20o\ + f\x20dynamically\x20typed\x20values.\n\n\x0c\n\x05\x04\0\x02\0\x06\x12\ + \x035\x02\x14\n\x0c\n\x05\x04\0\x02\0\x01\x12\x035\x15\x1b\n\x0c\n\x05\ + \x04\0\x02\0\x03\x12\x035\x1e\x1f\n\xc3\x02\n\x02\x04\x01\x12\x04>\0N\ + \x01\x1a\xb6\x02\x20`Value`\x20represents\x20a\x20dynamically\x20typed\ + \x20value\x20which\x20can\x20be\x20either\n\x20null,\x20a\x20number,\x20\ + a\x20string,\x20a\x20boolean,\x20a\x20recursive\x20struct\x20value,\x20o\ + r\x20a\n\x20list\x20of\x20values.\x20A\x20producer\x20of\x20value\x20is\ + \x20expected\x20to\x20set\x20one\x20of\x20that\n\x20variants,\x20absence\ + \x20of\x20any\x20variant\x20indicates\x20an\x20error.\n\n\x20The\x20JSON\ + \x20representation\x20for\x20`Value`\x20is\x20JSON\x20value.\n\n\n\n\x03\ + \x04\x01\x01\x12\x03>\x08\r\n\"\n\x04\x04\x01\x08\0\x12\x04@\x02M\x03\ + \x1a\x14\x20The\x20kind\x20of\x20value.\n\n\x0c\n\x05\x04\x01\x08\0\x01\ + \x12\x03@\x08\x0c\n'\n\x04\x04\x01\x02\0\x12\x03B\x04\x1d\x1a\x1a\x20Rep\ + resents\x20a\x20null\x20value.\n\n\x0c\n\x05\x04\x01\x02\0\x06\x12\x03B\ + \x04\r\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03B\x0e\x18\n\x0c\n\x05\x04\ + \x01\x02\0\x03\x12\x03B\x1b\x1c\n)\n\x04\x04\x01\x02\x01\x12\x03D\x04\ + \x1c\x1a\x1c\x20Represents\x20a\x20double\x20value.\n\n\x0c\n\x05\x04\ + \x01\x02\x01\x05\x12\x03D\x04\n\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03D\ + \x0b\x17\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03D\x1a\x1b\n)\n\x04\x04\ + \x01\x02\x02\x12\x03F\x04\x1c\x1a\x1c\x20Represents\x20a\x20string\x20va\ + lue.\n\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03F\x04\n\n\x0c\n\x05\x04\ + \x01\x02\x02\x01\x12\x03F\x0b\x17\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\ + \x03F\x1a\x1b\n*\n\x04\x04\x01\x02\x03\x12\x03H\x04\x18\x1a\x1d\x20Repre\ + sents\x20a\x20boolean\x20value.\n\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\ + \x03H\x04\x08\n\x0c\n\x05\x04\x01\x02\x03\x01\x12\x03H\t\x13\n\x0c\n\x05\ + \x04\x01\x02\x03\x03\x12\x03H\x16\x17\n-\n\x04\x04\x01\x02\x04\x12\x03J\ + \x04\x1c\x1a\x20\x20Represents\x20a\x20structured\x20value.\n\n\x0c\n\ + \x05\x04\x01\x02\x04\x06\x12\x03J\x04\n\n\x0c\n\x05\x04\x01\x02\x04\x01\ + \x12\x03J\x0b\x17\n\x0c\n\x05\x04\x01\x02\x04\x03\x12\x03J\x1a\x1b\n-\n\ + \x04\x04\x01\x02\x05\x12\x03L\x04\x1d\x1a\x20\x20Represents\x20a\x20repe\ + ated\x20`Value`.\n\n\x0c\n\x05\x04\x01\x02\x05\x06\x12\x03L\x04\r\n\x0c\ + \n\x05\x04\x01\x02\x05\x01\x12\x03L\x0e\x18\n\x0c\n\x05\x04\x01\x02\x05\ + \x03\x12\x03L\x1b\x1c\n\xa9\x01\n\x02\x05\0\x12\x04T\0W\x01\x1a\x9c\x01\ + \x20`NullValue`\x20is\x20a\x20singleton\x20enumeration\x20to\x20represen\ + t\x20the\x20null\x20value\x20for\x20the\n\x20`Value`\x20type\x20union.\n\ + \n\x20\x20The\x20JSON\x20representation\x20for\x20`NullValue`\x20is\x20J\ + SON\x20`null`.\n\n\n\n\x03\x05\0\x01\x12\x03T\x05\x0e\n\x1a\n\x04\x05\0\ + \x02\0\x12\x03V\x02\x11\x1a\r\x20Null\x20value.\n\n\x0c\n\x05\x05\0\x02\ + \0\x01\x12\x03V\x02\x0c\n\x0c\n\x05\x05\0\x02\0\x02\x12\x03V\x0f\x10\n\ + \x82\x01\n\x02\x04\x02\x12\x04\\\0_\x01\x1av\x20`ListValue`\x20is\x20a\ + \x20wrapper\x20around\x20a\x20repeated\x20field\x20of\x20values.\n\n\x20\ + The\x20JSON\x20representation\x20for\x20`ListValue`\x20is\x20JSON\x20arr\ + ay.\n\n\n\n\x03\x04\x02\x01\x12\x03\\\x08\x11\n:\n\x04\x04\x02\x02\0\x12\ + \x03^\x02\x1c\x1a-\x20Repeated\x20field\x20of\x20dynamically\x20typed\ + \x20values.\n\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03^\x02\n\n\x0c\n\x05\ + \x04\x02\x02\0\x06\x12\x03^\x0b\x10\n\x0c\n\x05\x04\x02\x02\0\x01\x12\ + \x03^\x11\x17\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03^\x1a\x1bb\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/src/well_known_types/timestamp.rs b/src/well_known_types/timestamp.rs new file mode 100644 index 0000000..2fed143 --- /dev/null +++ b/src/well_known_types/timestamp.rs @@ -0,0 +1,335 @@ +// This file is generated by rust-protobuf 2.14.0-pre. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/protobuf/timestamp.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Timestamp { + // message fields + pub seconds: i64, + pub nanos: i32, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Timestamp { + fn default() -> &'a Timestamp { + <Timestamp as ::protobuf::Message>::default_instance() + } +} + +impl Timestamp { + pub fn new() -> Timestamp { + ::std::default::Default::default() + } + + // int64 seconds = 1; + + + pub fn get_seconds(&self) -> i64 { + self.seconds + } + pub fn clear_seconds(&mut self) { + self.seconds = 0; + } + + // Param is passed by value, moved + pub fn set_seconds(&mut self, v: i64) { + self.seconds = v; + } + + // int32 nanos = 2; + + + pub fn get_nanos(&self) -> i32 { + self.nanos + } + pub fn clear_nanos(&mut self) { + self.nanos = 0; + } + + // Param is passed by value, moved + pub fn set_nanos(&mut self, v: i32) { + self.nanos = v; + } +} + +impl ::protobuf::Message for Timestamp { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.seconds = tmp; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.nanos = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.seconds != 0 { + my_size += ::protobuf::rt::value_size(1, self.seconds, ::protobuf::wire_format::WireTypeVarint); + } + if self.nanos != 0 { + my_size += ::protobuf::rt::value_size(2, self.nanos, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if self.seconds != 0 { + os.write_int64(1, self.seconds)?; + } + if self.nanos != 0 { + os.write_int32(2, self.nanos)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Timestamp { + Timestamp::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "seconds", + |m: &Timestamp| { &m.seconds }, + |m: &mut Timestamp| { &mut m.seconds }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "nanos", + |m: &Timestamp| { &m.nanos }, + |m: &mut Timestamp| { &mut m.nanos }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Timestamp>( + "Timestamp", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Timestamp { + static mut instance: ::protobuf::lazy::Lazy<Timestamp> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Timestamp::new) + } + } +} + +impl ::protobuf::Clear for Timestamp { + fn clear(&mut self) { + self.seconds = 0; + self.nanos = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Timestamp { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Timestamp { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1fgoogle/protobuf/timestamp.proto\x12\x0fgoogle.protobuf\";\n\tTimes\ + tamp\x12\x18\n\x07seconds\x18\x01\x20\x01(\x03R\x07seconds\x12\x14\n\x05\ + nanos\x18\x02\x20\x01(\x05R\x05nanosB~\n\x13com.google.protobufB\x0eTime\ + stampProtoP\x01Z+github.com/golang/protobuf/ptypes/timestamp\xf8\x01\x01\ + \xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesJ\x95!\n\x06\ + \x12\x04\x1e\0k\x01\n\xcc\x0c\n\x01\x0c\x12\x03\x1e\0\x122\xc1\x0c\x20Pr\ + otocol\x20Buffers\x20-\x20Google's\x20data\x20interchange\x20format\n\ + \x20Copyright\x202008\x20Google\x20Inc.\x20\x20All\x20rights\x20reserved\ + .\n\x20https://developers.google.com/protocol-buffers/\n\n\x20Redistribu\ + tion\x20and\x20use\x20in\x20source\x20and\x20binary\x20forms,\x20with\ + \x20or\x20without\n\x20modification,\x20are\x20permitted\x20provided\x20\ + that\x20the\x20following\x20conditions\x20are\n\x20met:\n\n\x20\x20\x20\ + \x20\x20*\x20Redistributions\x20of\x20source\x20code\x20must\x20retain\ + \x20the\x20above\x20copyright\n\x20notice,\x20this\x20list\x20of\x20cond\ + itions\x20and\x20the\x20following\x20disclaimer.\n\x20\x20\x20\x20\x20*\ + \x20Redistributions\x20in\x20binary\x20form\x20must\x20reproduce\x20the\ + \x20above\n\x20copyright\x20notice,\x20this\x20list\x20of\x20conditions\ + \x20and\x20the\x20following\x20disclaimer\n\x20in\x20the\x20documentatio\ + n\x20and/or\x20other\x20materials\x20provided\x20with\x20the\n\x20distri\ + bution.\n\x20\x20\x20\x20\x20*\x20Neither\x20the\x20name\x20of\x20Google\ + \x20Inc.\x20nor\x20the\x20names\x20of\x20its\n\x20contributors\x20may\ + \x20be\x20used\x20to\x20endorse\x20or\x20promote\x20products\x20derived\ + \x20from\n\x20this\x20software\x20without\x20specific\x20prior\x20writte\ + n\x20permission.\n\n\x20THIS\x20SOFTWARE\x20IS\x20PROVIDED\x20BY\x20THE\ + \x20COPYRIGHT\x20HOLDERS\x20AND\x20CONTRIBUTORS\n\x20\"AS\x20IS\"\x20AND\ + \x20ANY\x20EXPRESS\x20OR\x20IMPLIED\x20WARRANTIES,\x20INCLUDING,\x20BUT\ + \x20NOT\n\x20LIMITED\x20TO,\x20THE\x20IMPLIED\x20WARRANTIES\x20OF\x20MER\ + CHANTABILITY\x20AND\x20FITNESS\x20FOR\n\x20A\x20PARTICULAR\x20PURPOSE\ + \x20ARE\x20DISCLAIMED.\x20IN\x20NO\x20EVENT\x20SHALL\x20THE\x20COPYRIGHT\ + \n\x20OWNER\x20OR\x20CONTRIBUTORS\x20BE\x20LIABLE\x20FOR\x20ANY\x20DIREC\ + T,\x20INDIRECT,\x20INCIDENTAL,\n\x20SPECIAL,\x20EXEMPLARY,\x20OR\x20CONS\ + EQUENTIAL\x20DAMAGES\x20(INCLUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\ + \x20PROCUREMENT\x20OF\x20SUBSTITUTE\x20GOODS\x20OR\x20SERVICES;\x20LOSS\ + \x20OF\x20USE,\n\x20DATA,\x20OR\x20PROFITS;\x20OR\x20BUSINESS\x20INTERRU\ + PTION)\x20HOWEVER\x20CAUSED\x20AND\x20ON\x20ANY\n\x20THEORY\x20OF\x20LIA\ + BILITY,\x20WHETHER\x20IN\x20CONTRACT,\x20STRICT\x20LIABILITY,\x20OR\x20T\ + ORT\n\x20(INCLUDING\x20NEGLIGENCE\x20OR\x20OTHERWISE)\x20ARISING\x20IN\ + \x20ANY\x20WAY\x20OUT\x20OF\x20THE\x20USE\n\x20OF\x20THIS\x20SOFTWARE,\ + \x20EVEN\x20IF\x20ADVISED\x20OF\x20THE\x20POSSIBILITY\x20OF\x20SUCH\x20D\ + AMAGE.\n\n\x08\n\x01\x02\x12\x03\x20\0\x18\n\x08\n\x01\x08\x12\x03\"\0;\ + \n\t\n\x02\x08%\x12\x03\"\0;\n\x08\n\x01\x08\x12\x03#\0\x1f\n\t\n\x02\ + \x08\x1f\x12\x03#\0\x1f\n\x08\n\x01\x08\x12\x03$\0B\n\t\n\x02\x08\x0b\ + \x12\x03$\0B\n\x08\n\x01\x08\x12\x03%\0,\n\t\n\x02\x08\x01\x12\x03%\0,\n\ + \x08\n\x01\x08\x12\x03&\0/\n\t\n\x02\x08\x08\x12\x03&\0/\n\x08\n\x01\x08\ + \x12\x03'\0\"\n\t\n\x02\x08\n\x12\x03'\0\"\n\x08\n\x01\x08\x12\x03(\0!\n\ + \t\n\x02\x08$\x12\x03(\0!\n\xb8\x0f\n\x02\x04\0\x12\x04_\0k\x01\x1a\xab\ + \x0f\x20A\x20Timestamp\x20represents\x20a\x20point\x20in\x20time\x20inde\ + pendent\x20of\x20any\x20time\x20zone\n\x20or\x20calendar,\x20represented\ + \x20as\x20seconds\x20and\x20fractions\x20of\x20seconds\x20at\n\x20nanose\ + cond\x20resolution\x20in\x20UTC\x20Epoch\x20time.\x20It\x20is\x20encoded\ + \x20using\x20the\n\x20Proleptic\x20Gregorian\x20Calendar\x20which\x20ext\ + ends\x20the\x20Gregorian\x20calendar\n\x20backwards\x20to\x20year\x20one\ + .\x20It\x20is\x20encoded\x20assuming\x20all\x20minutes\x20are\x2060\n\ + \x20seconds\x20long,\x20i.e.\x20leap\x20seconds\x20are\x20\"smeared\"\ + \x20so\x20that\x20no\x20leap\x20second\n\x20table\x20is\x20needed\x20for\ + \x20interpretation.\x20Range\x20is\x20from\n\x200001-01-01T00:00:00Z\x20\ + to\x209999-12-31T23:59:59.999999999Z.\n\x20By\x20restricting\x20to\x20th\ + at\x20range,\x20we\x20ensure\x20that\x20we\x20can\x20convert\x20to\n\x20\ + and\x20from\x20\x20RFC\x203339\x20date\x20strings.\n\x20See\x20[https://\ + www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).\n\n\ + \x20Example\x201:\x20Compute\x20Timestamp\x20from\x20POSIX\x20`time()`.\ + \n\n\x20\x20\x20\x20\x20Timestamp\x20timestamp;\n\x20\x20\x20\x20\x20tim\ + estamp.set_seconds(time(NULL));\n\x20\x20\x20\x20\x20timestamp.set_nanos\ + (0);\n\n\x20Example\x202:\x20Compute\x20Timestamp\x20from\x20POSIX\x20`g\ + ettimeofday()`.\n\n\x20\x20\x20\x20\x20struct\x20timeval\x20tv;\n\x20\ + \x20\x20\x20\x20gettimeofday(&tv,\x20NULL);\n\n\x20\x20\x20\x20\x20Times\ + tamp\x20timestamp;\n\x20\x20\x20\x20\x20timestamp.set_seconds(tv.tv_sec)\ + ;\n\x20\x20\x20\x20\x20timestamp.set_nanos(tv.tv_usec\x20*\x201000);\n\n\ + \x20Example\x203:\x20Compute\x20Timestamp\x20from\x20Win32\x20`GetSystem\ + TimeAsFileTime()`.\n\n\x20\x20\x20\x20\x20FILETIME\x20ft;\n\x20\x20\x20\ + \x20\x20GetSystemTimeAsFileTime(&ft);\n\x20\x20\x20\x20\x20UINT64\x20tic\ + ks\x20=\x20(((UINT64)ft.dwHighDateTime)\x20<<\x2032)\x20|\x20ft.dwLowDat\ + eTime;\n\n\x20\x20\x20\x20\x20//\x20A\x20Windows\x20tick\x20is\x20100\ + \x20nanoseconds.\x20Windows\x20epoch\x201601-01-01T00:00:00Z\n\x20\x20\ + \x20\x20\x20//\x20is\x2011644473600\x20seconds\x20before\x20Unix\x20epoc\ + h\x201970-01-01T00:00:00Z.\n\x20\x20\x20\x20\x20Timestamp\x20timestamp;\ + \n\x20\x20\x20\x20\x20timestamp.set_seconds((INT64)\x20((ticks\x20/\x201\ + 0000000)\x20-\x2011644473600LL));\n\x20\x20\x20\x20\x20timestamp.set_nan\ + os((INT32)\x20((ticks\x20%\x2010000000)\x20*\x20100));\n\n\x20Example\ + \x204:\x20Compute\x20Timestamp\x20from\x20Java\x20`System.currentTimeMil\ + lis()`.\n\n\x20\x20\x20\x20\x20long\x20millis\x20=\x20System.currentTime\ + Millis();\n\n\x20\x20\x20\x20\x20Timestamp\x20timestamp\x20=\x20Timestam\ + p.newBuilder().setSeconds(millis\x20/\x201000)\n\x20\x20\x20\x20\x20\x20\ + \x20\x20\x20.setNanos((int)\x20((millis\x20%\x201000)\x20*\x201000000)).\ + build();\n\n\n\x20Example\x205:\x20Compute\x20Timestamp\x20from\x20curre\ + nt\x20time\x20in\x20Python.\n\n\x20\x20\x20\x20\x20timestamp\x20=\x20Tim\ + estamp()\n\x20\x20\x20\x20\x20timestamp.GetCurrentTime()\n\n\n\n\n\n\x03\ + \x04\0\x01\x12\x03_\x08\x11\n\x9c\x01\n\x04\x04\0\x02\0\x12\x03d\x02\x14\ + \x1a\x8e\x01\x20Represents\x20seconds\x20of\x20UTC\x20time\x20since\x20U\ + nix\x20epoch\n\x201970-01-01T00:00:00Z.\x20Must\x20be\x20from\x200001-01\ + -01T00:00:00Z\x20to\n\x209999-12-31T23:59:59Z\x20inclusive.\n\n\x0c\n\ + \x05\x04\0\x02\0\x05\x12\x03d\x02\x07\n\x0c\n\x05\x04\0\x02\0\x01\x12\ + \x03d\x08\x0f\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03d\x12\x13\n\xe4\x01\n\ + \x04\x04\0\x02\x01\x12\x03j\x02\x12\x1a\xd6\x01\x20Non-negative\x20fract\ + ions\x20of\x20a\x20second\x20at\x20nanosecond\x20resolution.\x20Negative\ + \n\x20second\x20values\x20with\x20fractions\x20must\x20still\x20have\x20\ + non-negative\x20nanos\x20values\n\x20that\x20count\x20forward\x20in\x20t\ + ime.\x20Must\x20be\x20from\x200\x20to\x20999,999,999\n\x20inclusive.\n\n\ + \x0c\n\x05\x04\0\x02\x01\x05\x12\x03j\x02\x07\n\x0c\n\x05\x04\0\x02\x01\ + \x01\x12\x03j\x08\r\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03j\x10\x11b\x06p\ + roto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/src/well_known_types/type_pb.rs b/src/well_known_types/type_pb.rs new file mode 100644 index 0000000..23df582 --- /dev/null +++ b/src/well_known_types/type_pb.rs @@ -0,0 +1,2254 @@ +// This file is generated by rust-protobuf 2.14.0-pre. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/protobuf/type.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Type { + // message fields + pub name: ::std::string::String, + pub fields: ::protobuf::RepeatedField<Field>, + pub oneofs: ::protobuf::RepeatedField<::std::string::String>, + pub options: ::protobuf::RepeatedField<Option>, + pub source_context: ::protobuf::SingularPtrField<::protobuf::well_known_types::SourceContext>, + pub syntax: Syntax, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Type { + fn default() -> &'a Type { + <Type as ::protobuf::Message>::default_instance() + } +} + +impl Type { + pub fn new() -> Type { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = 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 { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // repeated .google.protobuf.Field fields = 2; + + + pub fn get_fields(&self) -> &[Field] { + &self.fields + } + pub fn clear_fields(&mut self) { + self.fields.clear(); + } + + // Param is passed by value, moved + pub fn set_fields(&mut self, v: ::protobuf::RepeatedField<Field>) { + self.fields = v; + } + + // Mutable pointer to the field. + pub fn mut_fields(&mut self) -> &mut ::protobuf::RepeatedField<Field> { + &mut self.fields + } + + // Take field + pub fn take_fields(&mut self) -> ::protobuf::RepeatedField<Field> { + ::std::mem::replace(&mut self.fields, ::protobuf::RepeatedField::new()) + } + + // repeated string oneofs = 3; + + + pub fn get_oneofs(&self) -> &[::std::string::String] { + &self.oneofs + } + pub fn clear_oneofs(&mut self) { + self.oneofs.clear(); + } + + // Param is passed by value, moved + pub fn set_oneofs(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { + self.oneofs = v; + } + + // Mutable pointer to the field. + pub fn mut_oneofs(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { + &mut self.oneofs + } + + // Take field + pub fn take_oneofs(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { + ::std::mem::replace(&mut self.oneofs, ::protobuf::RepeatedField::new()) + } + + // repeated .google.protobuf.Option options = 4; + + + pub fn get_options(&self) -> &[Option] { + &self.options + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: ::protobuf::RepeatedField<Option>) { + self.options = v; + } + + // Mutable pointer to the field. + pub fn mut_options(&mut self) -> &mut ::protobuf::RepeatedField<Option> { + &mut self.options + } + + // Take field + pub fn take_options(&mut self) -> ::protobuf::RepeatedField<Option> { + ::std::mem::replace(&mut self.options, ::protobuf::RepeatedField::new()) + } + + // .google.protobuf.SourceContext source_context = 5; + + + pub fn get_source_context(&self) -> &::protobuf::well_known_types::SourceContext { + self.source_context.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::SourceContext::default_instance()) + } + pub fn clear_source_context(&mut self) { + self.source_context.clear(); + } + + pub fn has_source_context(&self) -> bool { + self.source_context.is_some() + } + + // Param is passed by value, moved + pub fn set_source_context(&mut self, v: ::protobuf::well_known_types::SourceContext) { + self.source_context = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_source_context(&mut self) -> &mut ::protobuf::well_known_types::SourceContext { + if self.source_context.is_none() { + self.source_context.set_default(); + } + self.source_context.as_mut().unwrap() + } + + // Take field + pub fn take_source_context(&mut self) -> ::protobuf::well_known_types::SourceContext { + self.source_context.take().unwrap_or_else(|| ::protobuf::well_known_types::SourceContext::new()) + } + + // .google.protobuf.Syntax syntax = 6; + + + pub fn get_syntax(&self) -> Syntax { + self.syntax + } + pub fn clear_syntax(&mut self) { + self.syntax = Syntax::SYNTAX_PROTO2; + } + + // Param is passed by value, moved + pub fn set_syntax(&mut self, v: Syntax) { + self.syntax = v; + } +} + +impl ::protobuf::Message for Type { + fn is_initialized(&self) -> bool { + for v in &self.fields { + if !v.is_initialized() { + return false; + } + }; + for v in &self.options { + if !v.is_initialized() { + return false; + } + }; + for v in &self.source_context { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.fields)?; + }, + 3 => { + ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.oneofs)?; + }, + 4 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.options)?; + }, + 5 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.source_context)?; + }, + 6 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 6, &mut self.unknown_fields)? + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + for value in &self.fields { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.oneofs { + my_size += ::protobuf::rt::string_size(3, &value); + }; + for value in &self.options { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if let Some(ref v) = self.source_context.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if self.syntax != Syntax::SYNTAX_PROTO2 { + my_size += ::protobuf::rt::enum_size(6, self.syntax); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + for v in &self.fields { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.oneofs { + os.write_string(3, &v)?; + }; + for v in &self.options { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if let Some(ref v) = self.source_context.as_ref() { + os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if self.syntax != Syntax::SYNTAX_PROTO2 { + os.write_enum(6, self.syntax.value())?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Type { + Type::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Type| { &m.name }, + |m: &mut Type| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Field>>( + "fields", + |m: &Type| { &m.fields }, + |m: &mut Type| { &mut m.fields }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "oneofs", + |m: &Type| { &m.oneofs }, + |m: &mut Type| { &mut m.oneofs }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Option>>( + "options", + |m: &Type| { &m.options }, + |m: &mut Type| { &mut m.options }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::SourceContext>>( + "source_context", + |m: &Type| { &m.source_context }, + |m: &mut Type| { &mut m.source_context }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Syntax>>( + "syntax", + |m: &Type| { &m.syntax }, + |m: &mut Type| { &mut m.syntax }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Type>( + "Type", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Type { + static mut instance: ::protobuf::lazy::Lazy<Type> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Type::new) + } + } +} + +impl ::protobuf::Clear for Type { + fn clear(&mut self) { + self.name.clear(); + self.fields.clear(); + self.oneofs.clear(); + self.options.clear(); + self.source_context.clear(); + self.syntax = Syntax::SYNTAX_PROTO2; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Type { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Type { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Field { + // message fields + pub kind: Field_Kind, + pub cardinality: Field_Cardinality, + pub number: i32, + pub name: ::std::string::String, + pub type_url: ::std::string::String, + pub oneof_index: i32, + pub packed: bool, + pub options: ::protobuf::RepeatedField<Option>, + pub json_name: ::std::string::String, + pub default_value: ::std::string::String, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Field { + fn default() -> &'a Field { + <Field as ::protobuf::Message>::default_instance() + } +} + +impl Field { + pub fn new() -> Field { + ::std::default::Default::default() + } + + // .google.protobuf.Field.Kind kind = 1; + + + pub fn get_kind(&self) -> Field_Kind { + self.kind + } + pub fn clear_kind(&mut self) { + self.kind = Field_Kind::TYPE_UNKNOWN; + } + + // Param is passed by value, moved + pub fn set_kind(&mut self, v: Field_Kind) { + self.kind = v; + } + + // .google.protobuf.Field.Cardinality cardinality = 2; + + + pub fn get_cardinality(&self) -> Field_Cardinality { + self.cardinality + } + pub fn clear_cardinality(&mut self) { + self.cardinality = Field_Cardinality::CARDINALITY_UNKNOWN; + } + + // Param is passed by value, moved + pub fn set_cardinality(&mut self, v: Field_Cardinality) { + self.cardinality = v; + } + + // int32 number = 3; + + + pub fn get_number(&self) -> i32 { + self.number + } + pub fn clear_number(&mut self) { + self.number = 0; + } + + // Param is passed by value, moved + pub fn set_number(&mut self, v: i32) { + self.number = v; + } + + // string name = 4; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = 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 { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // string type_url = 6; + + + pub fn get_type_url(&self) -> &str { + &self.type_url + } + pub fn clear_type_url(&mut self) { + self.type_url.clear(); + } + + // Param is passed by value, moved + pub fn set_type_url(&mut self, v: ::std::string::String) { + self.type_url = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_type_url(&mut self) -> &mut ::std::string::String { + &mut self.type_url + } + + // Take field + pub fn take_type_url(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.type_url, ::std::string::String::new()) + } + + // int32 oneof_index = 7; + + + pub fn get_oneof_index(&self) -> i32 { + self.oneof_index + } + pub fn clear_oneof_index(&mut self) { + self.oneof_index = 0; + } + + // Param is passed by value, moved + pub fn set_oneof_index(&mut self, v: i32) { + self.oneof_index = v; + } + + // bool packed = 8; + + + pub fn get_packed(&self) -> bool { + self.packed + } + pub fn clear_packed(&mut self) { + self.packed = false; + } + + // Param is passed by value, moved + pub fn set_packed(&mut self, v: bool) { + self.packed = v; + } + + // repeated .google.protobuf.Option options = 9; + + + pub fn get_options(&self) -> &[Option] { + &self.options + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: ::protobuf::RepeatedField<Option>) { + self.options = v; + } + + // Mutable pointer to the field. + pub fn mut_options(&mut self) -> &mut ::protobuf::RepeatedField<Option> { + &mut self.options + } + + // Take field + pub fn take_options(&mut self) -> ::protobuf::RepeatedField<Option> { + ::std::mem::replace(&mut self.options, ::protobuf::RepeatedField::new()) + } + + // string json_name = 10; + + + pub fn get_json_name(&self) -> &str { + &self.json_name + } + pub fn clear_json_name(&mut self) { + self.json_name.clear(); + } + + // Param is passed by value, moved + pub fn set_json_name(&mut self, v: ::std::string::String) { + self.json_name = 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 { + &mut self.json_name + } + + // Take field + pub fn take_json_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.json_name, ::std::string::String::new()) + } + + // string default_value = 11; + + + pub fn get_default_value(&self) -> &str { + &self.default_value + } + pub fn clear_default_value(&mut self) { + self.default_value.clear(); + } + + // Param is passed by value, moved + pub fn set_default_value(&mut self, v: ::std::string::String) { + self.default_value = 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 { + &mut self.default_value + } + + // Take field + pub fn take_default_value(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.default_value, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for Field { + fn is_initialized(&self) -> bool { + for v in &self.options { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.kind, 1, &mut self.unknown_fields)? + }, + 2 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.cardinality, 2, &mut self.unknown_fields)? + }, + 3 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.number = tmp; + }, + 4 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 6 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.type_url)?; + }, + 7 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.oneof_index = tmp; + }, + 8 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.packed = tmp; + }, + 9 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.options)?; + }, + 10 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.json_name)?; + }, + 11 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.default_value)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.kind != Field_Kind::TYPE_UNKNOWN { + my_size += ::protobuf::rt::enum_size(1, self.kind); + } + if self.cardinality != Field_Cardinality::CARDINALITY_UNKNOWN { + my_size += ::protobuf::rt::enum_size(2, self.cardinality); + } + if self.number != 0 { + my_size += ::protobuf::rt::value_size(3, self.number, ::protobuf::wire_format::WireTypeVarint); + } + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(4, &self.name); + } + if !self.type_url.is_empty() { + my_size += ::protobuf::rt::string_size(6, &self.type_url); + } + if self.oneof_index != 0 { + my_size += ::protobuf::rt::value_size(7, self.oneof_index, ::protobuf::wire_format::WireTypeVarint); + } + if self.packed != false { + my_size += 2; + } + for value in &self.options { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if !self.json_name.is_empty() { + my_size += ::protobuf::rt::string_size(10, &self.json_name); + } + if !self.default_value.is_empty() { + my_size += ::protobuf::rt::string_size(11, &self.default_value); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if self.kind != Field_Kind::TYPE_UNKNOWN { + os.write_enum(1, self.kind.value())?; + } + if self.cardinality != Field_Cardinality::CARDINALITY_UNKNOWN { + os.write_enum(2, self.cardinality.value())?; + } + if self.number != 0 { + os.write_int32(3, self.number)?; + } + if !self.name.is_empty() { + os.write_string(4, &self.name)?; + } + if !self.type_url.is_empty() { + os.write_string(6, &self.type_url)?; + } + if self.oneof_index != 0 { + os.write_int32(7, self.oneof_index)?; + } + if self.packed != false { + os.write_bool(8, self.packed)?; + } + for v in &self.options { + os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if !self.json_name.is_empty() { + os.write_string(10, &self.json_name)?; + } + if !self.default_value.is_empty() { + os.write_string(11, &self.default_value)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Field { + Field::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Field_Kind>>( + "kind", + |m: &Field| { &m.kind }, + |m: &mut Field| { &mut m.kind }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Field_Cardinality>>( + "cardinality", + |m: &Field| { &m.cardinality }, + |m: &mut Field| { &mut m.cardinality }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "number", + |m: &Field| { &m.number }, + |m: &mut Field| { &mut m.number }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Field| { &m.name }, + |m: &mut Field| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "type_url", + |m: &Field| { &m.type_url }, + |m: &mut Field| { &mut m.type_url }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "oneof_index", + |m: &Field| { &m.oneof_index }, + |m: &mut Field| { &mut m.oneof_index }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "packed", + |m: &Field| { &m.packed }, + |m: &mut Field| { &mut m.packed }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Option>>( + "options", + |m: &Field| { &m.options }, + |m: &mut Field| { &mut m.options }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "json_name", + |m: &Field| { &m.json_name }, + |m: &mut Field| { &mut m.json_name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "default_value", + |m: &Field| { &m.default_value }, + |m: &mut Field| { &mut m.default_value }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Field>( + "Field", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Field { + static mut instance: ::protobuf::lazy::Lazy<Field> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Field::new) + } + } +} + +impl ::protobuf::Clear for Field { + fn clear(&mut self) { + self.kind = Field_Kind::TYPE_UNKNOWN; + self.cardinality = Field_Cardinality::CARDINALITY_UNKNOWN; + self.number = 0; + self.name.clear(); + self.type_url.clear(); + self.oneof_index = 0; + self.packed = false; + self.options.clear(); + self.json_name.clear(); + self.default_value.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Field { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Field { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub enum Field_Kind { + TYPE_UNKNOWN = 0, + TYPE_DOUBLE = 1, + TYPE_FLOAT = 2, + TYPE_INT64 = 3, + TYPE_UINT64 = 4, + TYPE_INT32 = 5, + TYPE_FIXED64 = 6, + TYPE_FIXED32 = 7, + TYPE_BOOL = 8, + TYPE_STRING = 9, + TYPE_GROUP = 10, + TYPE_MESSAGE = 11, + TYPE_BYTES = 12, + TYPE_UINT32 = 13, + TYPE_ENUM = 14, + TYPE_SFIXED32 = 15, + TYPE_SFIXED64 = 16, + TYPE_SINT32 = 17, + TYPE_SINT64 = 18, +} + +impl ::protobuf::ProtobufEnum for Field_Kind { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option<Field_Kind> { + match value { + 0 => ::std::option::Option::Some(Field_Kind::TYPE_UNKNOWN), + 1 => ::std::option::Option::Some(Field_Kind::TYPE_DOUBLE), + 2 => ::std::option::Option::Some(Field_Kind::TYPE_FLOAT), + 3 => ::std::option::Option::Some(Field_Kind::TYPE_INT64), + 4 => ::std::option::Option::Some(Field_Kind::TYPE_UINT64), + 5 => ::std::option::Option::Some(Field_Kind::TYPE_INT32), + 6 => ::std::option::Option::Some(Field_Kind::TYPE_FIXED64), + 7 => ::std::option::Option::Some(Field_Kind::TYPE_FIXED32), + 8 => ::std::option::Option::Some(Field_Kind::TYPE_BOOL), + 9 => ::std::option::Option::Some(Field_Kind::TYPE_STRING), + 10 => ::std::option::Option::Some(Field_Kind::TYPE_GROUP), + 11 => ::std::option::Option::Some(Field_Kind::TYPE_MESSAGE), + 12 => ::std::option::Option::Some(Field_Kind::TYPE_BYTES), + 13 => ::std::option::Option::Some(Field_Kind::TYPE_UINT32), + 14 => ::std::option::Option::Some(Field_Kind::TYPE_ENUM), + 15 => ::std::option::Option::Some(Field_Kind::TYPE_SFIXED32), + 16 => ::std::option::Option::Some(Field_Kind::TYPE_SFIXED64), + 17 => ::std::option::Option::Some(Field_Kind::TYPE_SINT32), + 18 => ::std::option::Option::Some(Field_Kind::TYPE_SINT64), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Field_Kind] = &[ + Field_Kind::TYPE_UNKNOWN, + Field_Kind::TYPE_DOUBLE, + Field_Kind::TYPE_FLOAT, + Field_Kind::TYPE_INT64, + Field_Kind::TYPE_UINT64, + Field_Kind::TYPE_INT32, + Field_Kind::TYPE_FIXED64, + Field_Kind::TYPE_FIXED32, + Field_Kind::TYPE_BOOL, + Field_Kind::TYPE_STRING, + Field_Kind::TYPE_GROUP, + Field_Kind::TYPE_MESSAGE, + Field_Kind::TYPE_BYTES, + Field_Kind::TYPE_UINT32, + Field_Kind::TYPE_ENUM, + Field_Kind::TYPE_SFIXED32, + Field_Kind::TYPE_SFIXED64, + Field_Kind::TYPE_SINT32, + Field_Kind::TYPE_SINT64, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new_pb_name::<Field_Kind>("Field.Kind", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Field_Kind { +} + +impl ::std::default::Default for Field_Kind { + fn default() -> Self { + Field_Kind::TYPE_UNKNOWN + } +} + +impl ::protobuf::reflect::ProtobufValue for Field_Kind { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor()) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub enum Field_Cardinality { + CARDINALITY_UNKNOWN = 0, + CARDINALITY_OPTIONAL = 1, + CARDINALITY_REQUIRED = 2, + CARDINALITY_REPEATED = 3, +} + +impl ::protobuf::ProtobufEnum for Field_Cardinality { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option<Field_Cardinality> { + match value { + 0 => ::std::option::Option::Some(Field_Cardinality::CARDINALITY_UNKNOWN), + 1 => ::std::option::Option::Some(Field_Cardinality::CARDINALITY_OPTIONAL), + 2 => ::std::option::Option::Some(Field_Cardinality::CARDINALITY_REQUIRED), + 3 => ::std::option::Option::Some(Field_Cardinality::CARDINALITY_REPEATED), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Field_Cardinality] = &[ + Field_Cardinality::CARDINALITY_UNKNOWN, + Field_Cardinality::CARDINALITY_OPTIONAL, + Field_Cardinality::CARDINALITY_REQUIRED, + Field_Cardinality::CARDINALITY_REPEATED, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new_pb_name::<Field_Cardinality>("Field.Cardinality", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Field_Cardinality { +} + +impl ::std::default::Default for Field_Cardinality { + fn default() -> Self { + Field_Cardinality::CARDINALITY_UNKNOWN + } +} + +impl ::protobuf::reflect::ProtobufValue for Field_Cardinality { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor()) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Enum { + // message fields + pub name: ::std::string::String, + pub enumvalue: ::protobuf::RepeatedField<EnumValue>, + pub options: ::protobuf::RepeatedField<Option>, + pub source_context: ::protobuf::SingularPtrField<::protobuf::well_known_types::SourceContext>, + pub syntax: Syntax, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Enum { + fn default() -> &'a Enum { + <Enum as ::protobuf::Message>::default_instance() + } +} + +impl Enum { + pub fn new() -> Enum { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = 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 { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // repeated .google.protobuf.EnumValue enumvalue = 2; + + + pub fn get_enumvalue(&self) -> &[EnumValue] { + &self.enumvalue + } + pub fn clear_enumvalue(&mut self) { + self.enumvalue.clear(); + } + + // Param is passed by value, moved + pub fn set_enumvalue(&mut self, v: ::protobuf::RepeatedField<EnumValue>) { + self.enumvalue = v; + } + + // Mutable pointer to the field. + pub fn mut_enumvalue(&mut self) -> &mut ::protobuf::RepeatedField<EnumValue> { + &mut self.enumvalue + } + + // Take field + pub fn take_enumvalue(&mut self) -> ::protobuf::RepeatedField<EnumValue> { + ::std::mem::replace(&mut self.enumvalue, ::protobuf::RepeatedField::new()) + } + + // repeated .google.protobuf.Option options = 3; + + + pub fn get_options(&self) -> &[Option] { + &self.options + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: ::protobuf::RepeatedField<Option>) { + self.options = v; + } + + // Mutable pointer to the field. + pub fn mut_options(&mut self) -> &mut ::protobuf::RepeatedField<Option> { + &mut self.options + } + + // Take field + pub fn take_options(&mut self) -> ::protobuf::RepeatedField<Option> { + ::std::mem::replace(&mut self.options, ::protobuf::RepeatedField::new()) + } + + // .google.protobuf.SourceContext source_context = 4; + + + pub fn get_source_context(&self) -> &::protobuf::well_known_types::SourceContext { + self.source_context.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::SourceContext::default_instance()) + } + pub fn clear_source_context(&mut self) { + self.source_context.clear(); + } + + pub fn has_source_context(&self) -> bool { + self.source_context.is_some() + } + + // Param is passed by value, moved + pub fn set_source_context(&mut self, v: ::protobuf::well_known_types::SourceContext) { + self.source_context = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_source_context(&mut self) -> &mut ::protobuf::well_known_types::SourceContext { + if self.source_context.is_none() { + self.source_context.set_default(); + } + self.source_context.as_mut().unwrap() + } + + // Take field + pub fn take_source_context(&mut self) -> ::protobuf::well_known_types::SourceContext { + self.source_context.take().unwrap_or_else(|| ::protobuf::well_known_types::SourceContext::new()) + } + + // .google.protobuf.Syntax syntax = 5; + + + pub fn get_syntax(&self) -> Syntax { + self.syntax + } + pub fn clear_syntax(&mut self) { + self.syntax = Syntax::SYNTAX_PROTO2; + } + + // Param is passed by value, moved + pub fn set_syntax(&mut self, v: Syntax) { + self.syntax = v; + } +} + +impl ::protobuf::Message for Enum { + fn is_initialized(&self) -> bool { + for v in &self.enumvalue { + if !v.is_initialized() { + return false; + } + }; + for v in &self.options { + if !v.is_initialized() { + return false; + } + }; + for v in &self.source_context { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.enumvalue)?; + }, + 3 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.options)?; + }, + 4 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.source_context)?; + }, + 5 => { + ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 5, &mut self.unknown_fields)? + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + for value in &self.enumvalue { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + for value in &self.options { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + if let Some(ref v) = self.source_context.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + if self.syntax != Syntax::SYNTAX_PROTO2 { + my_size += ::protobuf::rt::enum_size(5, self.syntax); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + for v in &self.enumvalue { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + for v in &self.options { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + if let Some(ref v) = self.source_context.as_ref() { + os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + if self.syntax != Syntax::SYNTAX_PROTO2 { + os.write_enum(5, self.syntax.value())?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Enum { + Enum::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Enum| { &m.name }, + |m: &mut Enum| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EnumValue>>( + "enumvalue", + |m: &Enum| { &m.enumvalue }, + |m: &mut Enum| { &mut m.enumvalue }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Option>>( + "options", + |m: &Enum| { &m.options }, + |m: &mut Enum| { &mut m.options }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::SourceContext>>( + "source_context", + |m: &Enum| { &m.source_context }, + |m: &mut Enum| { &mut m.source_context }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Syntax>>( + "syntax", + |m: &Enum| { &m.syntax }, + |m: &mut Enum| { &mut m.syntax }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Enum>( + "Enum", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Enum { + static mut instance: ::protobuf::lazy::Lazy<Enum> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Enum::new) + } + } +} + +impl ::protobuf::Clear for Enum { + fn clear(&mut self) { + self.name.clear(); + self.enumvalue.clear(); + self.options.clear(); + self.source_context.clear(); + self.syntax = Syntax::SYNTAX_PROTO2; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Enum { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Enum { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct EnumValue { + // message fields + pub name: ::std::string::String, + pub number: i32, + pub options: ::protobuf::RepeatedField<Option>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a EnumValue { + fn default() -> &'a EnumValue { + <EnumValue as ::protobuf::Message>::default_instance() + } +} + +impl EnumValue { + pub fn new() -> EnumValue { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = 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 { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // int32 number = 2; + + + pub fn get_number(&self) -> i32 { + self.number + } + pub fn clear_number(&mut self) { + self.number = 0; + } + + // Param is passed by value, moved + pub fn set_number(&mut self, v: i32) { + self.number = v; + } + + // repeated .google.protobuf.Option options = 3; + + + pub fn get_options(&self) -> &[Option] { + &self.options + } + pub fn clear_options(&mut self) { + self.options.clear(); + } + + // Param is passed by value, moved + pub fn set_options(&mut self, v: ::protobuf::RepeatedField<Option>) { + self.options = v; + } + + // Mutable pointer to the field. + pub fn mut_options(&mut self) -> &mut ::protobuf::RepeatedField<Option> { + &mut self.options + } + + // Take field + pub fn take_options(&mut self) -> ::protobuf::RepeatedField<Option> { + ::std::mem::replace(&mut self.options, ::protobuf::RepeatedField::new()) + } +} + +impl ::protobuf::Message for EnumValue { + fn is_initialized(&self) -> bool { + for v in &self.options { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.number = tmp; + }, + 3 => { + ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.options)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if self.number != 0 { + my_size += ::protobuf::rt::value_size(2, self.number, ::protobuf::wire_format::WireTypeVarint); + } + for value in &self.options { + let len = value.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + }; + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if self.number != 0 { + os.write_int32(2, self.number)?; + } + for v in &self.options { + os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + }; + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> EnumValue { + EnumValue::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &EnumValue| { &m.name }, + |m: &mut EnumValue| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "number", + |m: &EnumValue| { &m.number }, + |m: &mut EnumValue| { &mut m.number }, + )); + fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Option>>( + "options", + |m: &EnumValue| { &m.options }, + |m: &mut EnumValue| { &mut m.options }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<EnumValue>( + "EnumValue", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static EnumValue { + static mut instance: ::protobuf::lazy::Lazy<EnumValue> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(EnumValue::new) + } + } +} + +impl ::protobuf::Clear for EnumValue { + fn clear(&mut self) { + self.name.clear(); + self.number = 0; + self.options.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for EnumValue { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for EnumValue { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Option { + // message fields + pub name: ::std::string::String, + pub value: ::protobuf::SingularPtrField<::protobuf::well_known_types::Any>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Option { + fn default() -> &'a Option { + <Option as ::protobuf::Message>::default_instance() + } +} + +impl Option { + pub fn new() -> Option { + ::std::default::Default::default() + } + + // string name = 1; + + + pub fn get_name(&self) -> &str { + &self.name + } + pub fn clear_name(&mut self) { + self.name.clear(); + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = 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 { + &mut self.name + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.name, ::std::string::String::new()) + } + + // .google.protobuf.Any value = 2; + + + pub fn get_value(&self) -> &::protobuf::well_known_types::Any { + self.value.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Any::default_instance()) + } + pub fn clear_value(&mut self) { + self.value.clear(); + } + + pub fn has_value(&self) -> bool { + self.value.is_some() + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: ::protobuf::well_known_types::Any) { + self.value = ::protobuf::SingularPtrField::some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_value(&mut self) -> &mut ::protobuf::well_known_types::Any { + if self.value.is_none() { + self.value.set_default(); + } + self.value.as_mut().unwrap() + } + + // Take field + pub fn take_value(&mut self) -> ::protobuf::well_known_types::Any { + self.value.take().unwrap_or_else(|| ::protobuf::well_known_types::Any::new()) + } +} + +impl ::protobuf::Message for Option { + fn is_initialized(&self) -> bool { + for v in &self.value { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?; + }, + 2 => { + ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.value)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.name.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.name); + } + if let Some(ref v) = self.value.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.name.is_empty() { + os.write_string(1, &self.name)?; + } + if let Some(ref v) = self.value.as_ref() { + os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; + os.write_raw_varint32(v.get_cached_size())?; + v.write_to_with_cached_sizes(os)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Option { + Option::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "name", + |m: &Option| { &m.name }, + |m: &mut Option| { &mut m.name }, + )); + fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Any>>( + "value", + |m: &Option| { &m.value }, + |m: &mut Option| { &mut m.value }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Option>( + "Option", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Option { + static mut instance: ::protobuf::lazy::Lazy<Option> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Option::new) + } + } +} + +impl ::protobuf::Clear for Option { + fn clear(&mut self) { + self.name.clear(); + self.value.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Option { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Option { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(Clone,PartialEq,Eq,Debug,Hash)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub enum Syntax { + SYNTAX_PROTO2 = 0, + SYNTAX_PROTO3 = 1, +} + +impl ::protobuf::ProtobufEnum for Syntax { + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option<Syntax> { + match value { + 0 => ::std::option::Option::Some(Syntax::SYNTAX_PROTO2), + 1 => ::std::option::Option::Some(Syntax::SYNTAX_PROTO3), + _ => ::std::option::Option::None + } + } + + fn values() -> &'static [Self] { + static values: &'static [Syntax] = &[ + Syntax::SYNTAX_PROTO2, + Syntax::SYNTAX_PROTO3, + ]; + values + } + + fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + ::protobuf::reflect::EnumDescriptor::new_pb_name::<Syntax>("Syntax", file_descriptor_proto()) + }) + } + } +} + +impl ::std::marker::Copy for Syntax { +} + +impl ::std::default::Default for Syntax { + fn default() -> Self { + Syntax::SYNTAX_PROTO2 + } +} + +impl ::protobuf::reflect::ProtobufValue for Syntax { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor()) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1agoogle/protobuf/type.proto\x12\x0fgoogle.protobuf\x1a\x19google/pr\ + otobuf/any.proto\x1a$google/protobuf/source_context.proto\"\x8d\x02\n\ + \x04Type\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12.\n\x06fields\ + \x18\x02\x20\x03(\x0b2\x16.google.protobuf.FieldR\x06fields\x12\x16\n\ + \x06oneofs\x18\x03\x20\x03(\tR\x06oneofs\x121\n\x07options\x18\x04\x20\ + \x03(\x0b2\x17.google.protobuf.OptionR\x07options\x12E\n\x0esource_conte\ + xt\x18\x05\x20\x01(\x0b2\x1e.google.protobuf.SourceContextR\rsourceConte\ + xt\x12/\n\x06syntax\x18\x06\x20\x01(\x0e2\x17.google.protobuf.SyntaxR\ + \x06syntax\"\xb4\x06\n\x05Field\x12/\n\x04kind\x18\x01\x20\x01(\x0e2\x1b\ + .google.protobuf.Field.KindR\x04kind\x12D\n\x0bcardinality\x18\x02\x20\ + \x01(\x0e2\".google.protobuf.Field.CardinalityR\x0bcardinality\x12\x16\n\ + \x06number\x18\x03\x20\x01(\x05R\x06number\x12\x12\n\x04name\x18\x04\x20\ + \x01(\tR\x04name\x12\x19\n\x08type_url\x18\x06\x20\x01(\tR\x07typeUrl\ + \x12\x1f\n\x0boneof_index\x18\x07\x20\x01(\x05R\noneofIndex\x12\x16\n\ + \x06packed\x18\x08\x20\x01(\x08R\x06packed\x121\n\x07options\x18\t\x20\ + \x03(\x0b2\x17.google.protobuf.OptionR\x07options\x12\x1b\n\tjson_name\ + \x18\n\x20\x01(\tR\x08jsonName\x12#\n\rdefault_value\x18\x0b\x20\x01(\tR\ + \x0cdefaultValue\"\xc8\x02\n\x04Kind\x12\x10\n\x0cTYPE_UNKNOWN\x10\0\x12\ + \x0f\n\x0bTYPE_DOUBLE\x10\x01\x12\x0e\n\nTYPE_FLOAT\x10\x02\x12\x0e\n\nT\ + YPE_INT64\x10\x03\x12\x0f\n\x0bTYPE_UINT64\x10\x04\x12\x0e\n\nTYPE_INT32\ + \x10\x05\x12\x10\n\x0cTYPE_FIXED64\x10\x06\x12\x10\n\x0cTYPE_FIXED32\x10\ + \x07\x12\r\n\tTYPE_BOOL\x10\x08\x12\x0f\n\x0bTYPE_STRING\x10\t\x12\x0e\n\ + \nTYPE_GROUP\x10\n\x12\x10\n\x0cTYPE_MESSAGE\x10\x0b\x12\x0e\n\nTYPE_BYT\ + ES\x10\x0c\x12\x0f\n\x0bTYPE_UINT32\x10\r\x12\r\n\tTYPE_ENUM\x10\x0e\x12\ + \x11\n\rTYPE_SFIXED32\x10\x0f\x12\x11\n\rTYPE_SFIXED64\x10\x10\x12\x0f\n\ + \x0bTYPE_SINT32\x10\x11\x12\x0f\n\x0bTYPE_SINT64\x10\x12\"t\n\x0bCardina\ + lity\x12\x17\n\x13CARDINALITY_UNKNOWN\x10\0\x12\x18\n\x14CARDINALITY_OPT\ + IONAL\x10\x01\x12\x18\n\x14CARDINALITY_REQUIRED\x10\x02\x12\x18\n\x14CAR\ + DINALITY_REPEATED\x10\x03\"\xff\x01\n\x04Enum\x12\x12\n\x04name\x18\x01\ + \x20\x01(\tR\x04name\x128\n\tenumvalue\x18\x02\x20\x03(\x0b2\x1a.google.\ + protobuf.EnumValueR\tenumvalue\x121\n\x07options\x18\x03\x20\x03(\x0b2\ + \x17.google.protobuf.OptionR\x07options\x12E\n\x0esource_context\x18\x04\ + \x20\x01(\x0b2\x1e.google.protobuf.SourceContextR\rsourceContext\x12/\n\ + \x06syntax\x18\x05\x20\x01(\x0e2\x17.google.protobuf.SyntaxR\x06syntax\"\ + j\n\tEnumValue\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x16\n\ + \x06number\x18\x02\x20\x01(\x05R\x06number\x121\n\x07options\x18\x03\x20\ + \x03(\x0b2\x17.google.protobuf.OptionR\x07options\"H\n\x06Option\x12\x12\ + \n\x04name\x18\x01\x20\x01(\tR\x04name\x12*\n\x05value\x18\x02\x20\x01(\ + \x0b2\x14.google.protobuf.AnyR\x05value*.\n\x06Syntax\x12\x11\n\rSYNTAX_\ + PROTO2\x10\0\x12\x11\n\rSYNTAX_PROTO3\x10\x01BL\n\x13com.google.protobuf\ + B\tTypeProtoP\x01\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.\ + WellKnownTypesJ\x9a5\n\x07\x12\x05\x1e\0\xb3\x01\x01\n\xcc\x0c\n\x01\x0c\ + \x12\x03\x1e\0\x122\xc1\x0c\x20Protocol\x20Buffers\x20-\x20Google's\x20d\ + ata\x20interchange\x20format\n\x20Copyright\x202008\x20Google\x20Inc.\ + \x20\x20All\x20rights\x20reserved.\n\x20https://developers.google.com/pr\ + otocol-buffers/\n\n\x20Redistribution\x20and\x20use\x20in\x20source\x20a\ + nd\x20binary\x20forms,\x20with\x20or\x20without\n\x20modification,\x20ar\ + e\x20permitted\x20provided\x20that\x20the\x20following\x20conditions\x20\ + are\n\x20met:\n\n\x20\x20\x20\x20\x20*\x20Redistributions\x20of\x20sourc\ + e\x20code\x20must\x20retain\x20the\x20above\x20copyright\n\x20notice,\ + \x20this\x20list\x20of\x20conditions\x20and\x20the\x20following\x20discl\ + aimer.\n\x20\x20\x20\x20\x20*\x20Redistributions\x20in\x20binary\x20form\ + \x20must\x20reproduce\x20the\x20above\n\x20copyright\x20notice,\x20this\ + \x20list\x20of\x20conditions\x20and\x20the\x20following\x20disclaimer\n\ + \x20in\x20the\x20documentation\x20and/or\x20other\x20materials\x20provid\ + ed\x20with\x20the\n\x20distribution.\n\x20\x20\x20\x20\x20*\x20Neither\ + \x20the\x20name\x20of\x20Google\x20Inc.\x20nor\x20the\x20names\x20of\x20\ + its\n\x20contributors\x20may\x20be\x20used\x20to\x20endorse\x20or\x20pro\ + mote\x20products\x20derived\x20from\n\x20this\x20software\x20without\x20\ + specific\x20prior\x20written\x20permission.\n\n\x20THIS\x20SOFTWARE\x20I\ + S\x20PROVIDED\x20BY\x20THE\x20COPYRIGHT\x20HOLDERS\x20AND\x20CONTRIBUTOR\ + S\n\x20\"AS\x20IS\"\x20AND\x20ANY\x20EXPRESS\x20OR\x20IMPLIED\x20WARRANT\ + IES,\x20INCLUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\x20THE\x20IMPLIED\ + \x20WARRANTIES\x20OF\x20MERCHANTABILITY\x20AND\x20FITNESS\x20FOR\n\x20A\ + \x20PARTICULAR\x20PURPOSE\x20ARE\x20DISCLAIMED.\x20IN\x20NO\x20EVENT\x20\ + SHALL\x20THE\x20COPYRIGHT\n\x20OWNER\x20OR\x20CONTRIBUTORS\x20BE\x20LIAB\ + LE\x20FOR\x20ANY\x20DIRECT,\x20INDIRECT,\x20INCIDENTAL,\n\x20SPECIAL,\ + \x20EXEMPLARY,\x20OR\x20CONSEQUENTIAL\x20DAMAGES\x20(INCLUDING,\x20BUT\ + \x20NOT\n\x20LIMITED\x20TO,\x20PROCUREMENT\x20OF\x20SUBSTITUTE\x20GOODS\ + \x20OR\x20SERVICES;\x20LOSS\x20OF\x20USE,\n\x20DATA,\x20OR\x20PROFITS;\ + \x20OR\x20BUSINESS\x20INTERRUPTION)\x20HOWEVER\x20CAUSED\x20AND\x20ON\ + \x20ANY\n\x20THEORY\x20OF\x20LIABILITY,\x20WHETHER\x20IN\x20CONTRACT,\ + \x20STRICT\x20LIABILITY,\x20OR\x20TORT\n\x20(INCLUDING\x20NEGLIGENCE\x20\ + OR\x20OTHERWISE)\x20ARISING\x20IN\x20ANY\x20WAY\x20OUT\x20OF\x20THE\x20U\ + SE\n\x20OF\x20THIS\x20SOFTWARE,\x20EVEN\x20IF\x20ADVISED\x20OF\x20THE\ + \x20POSSIBILITY\x20OF\x20SUCH\x20DAMAGE.\n\n\x08\n\x01\x02\x12\x03\x20\0\ + \x18\n\t\n\x02\x03\0\x12\x03\"\0#\n\t\n\x02\x03\x01\x12\x03#\0.\n\x08\n\ + \x01\x08\x12\x03%\0;\n\t\n\x02\x08%\x12\x03%\0;\n\x08\n\x01\x08\x12\x03&\ + \0\x1f\n\t\n\x02\x08\x1f\x12\x03&\0\x1f\n\x08\n\x01\x08\x12\x03'\0,\n\t\ + \n\x02\x08\x01\x12\x03'\0,\n\x08\n\x01\x08\x12\x03(\0*\n\t\n\x02\x08\x08\ + \x12\x03(\0*\n\x08\n\x01\x08\x12\x03)\0\"\n\t\n\x02\x08\n\x12\x03)\0\"\n\ + \x08\n\x01\x08\x12\x03*\0!\n\t\n\x02\x08$\x12\x03*\0!\n-\n\x02\x04\0\x12\ + \x04-\0:\x01\x1a!\x20A\x20protocol\x20buffer\x20message\x20type.\n\n\n\n\ + \x03\x04\0\x01\x12\x03-\x08\x0c\n0\n\x04\x04\0\x02\0\x12\x03/\x02\x12\ + \x1a#\x20The\x20fully\x20qualified\x20message\x20name.\n\n\x0c\n\x05\x04\ + \0\x02\0\x05\x12\x03/\x02\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03/\t\r\n\ + \x0c\n\x05\x04\0\x02\0\x03\x12\x03/\x10\x11\n\"\n\x04\x04\0\x02\x01\x12\ + \x031\x02\x1c\x1a\x15\x20The\x20list\x20of\x20fields.\n\n\x0c\n\x05\x04\ + \0\x02\x01\x04\x12\x031\x02\n\n\x0c\n\x05\x04\0\x02\x01\x06\x12\x031\x0b\ + \x10\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x031\x11\x17\n\x0c\n\x05\x04\0\ + \x02\x01\x03\x12\x031\x1a\x1b\nO\n\x04\x04\0\x02\x02\x12\x033\x02\x1d\ + \x1aB\x20The\x20list\x20of\x20types\x20appearing\x20in\x20`oneof`\x20def\ + initions\x20in\x20this\x20type.\n\n\x0c\n\x05\x04\0\x02\x02\x04\x12\x033\ + \x02\n\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x033\x0b\x11\n\x0c\n\x05\x04\0\ + \x02\x02\x01\x12\x033\x12\x18\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x033\x1b\ + \x1c\n+\n\x04\x04\0\x02\x03\x12\x035\x02\x1e\x1a\x1e\x20The\x20protocol\ + \x20buffer\x20options.\n\n\x0c\n\x05\x04\0\x02\x03\x04\x12\x035\x02\n\n\ + \x0c\n\x05\x04\0\x02\x03\x06\x12\x035\x0b\x11\n\x0c\n\x05\x04\0\x02\x03\ + \x01\x12\x035\x12\x19\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x035\x1c\x1d\n\"\ + \n\x04\x04\0\x02\x04\x12\x037\x02#\x1a\x15\x20The\x20source\x20context.\ + \n\n\x0c\n\x05\x04\0\x02\x04\x06\x12\x037\x02\x0f\n\x0c\n\x05\x04\0\x02\ + \x04\x01\x12\x037\x10\x1e\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x037!\"\n!\n\ + \x04\x04\0\x02\x05\x12\x039\x02\x14\x1a\x14\x20The\x20source\x20syntax.\ + \n\n\x0c\n\x05\x04\0\x02\x05\x06\x12\x039\x02\x08\n\x0c\n\x05\x04\0\x02\ + \x05\x01\x12\x039\t\x0f\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x039\x12\x13\n\ + 0\n\x02\x04\x01\x12\x05=\0\x8a\x01\x01\x1a#\x20A\x20single\x20field\x20o\ + f\x20a\x20message\x20type.\n\n\n\n\x03\x04\x01\x01\x12\x03=\x08\r\n\"\n\ + \x04\x04\x01\x04\0\x12\x04?\x02f\x03\x1a\x14\x20Basic\x20field\x20types.\ + \n\n\x0c\n\x05\x04\x01\x04\0\x01\x12\x03?\x07\x0b\n$\n\x06\x04\x01\x04\0\ + \x02\0\x12\x03A\x04\x1c\x1a\x15\x20Field\x20type\x20unknown.\n\n\x0e\n\ + \x07\x04\x01\x04\0\x02\0\x01\x12\x03A\x04\x10\n\x0e\n\x07\x04\x01\x04\0\ + \x02\0\x02\x12\x03A\x1a\x1b\n#\n\x06\x04\x01\x04\0\x02\x01\x12\x03C\x04\ + \x1c\x1a\x14\x20Field\x20type\x20double.\n\n\x0e\n\x07\x04\x01\x04\0\x02\ + \x01\x01\x12\x03C\x04\x0f\n\x0e\n\x07\x04\x01\x04\0\x02\x01\x02\x12\x03C\ + \x1a\x1b\n\"\n\x06\x04\x01\x04\0\x02\x02\x12\x03E\x04\x1c\x1a\x13\x20Fie\ + ld\x20type\x20float.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x02\x01\x12\x03E\ + \x04\x0e\n\x0e\n\x07\x04\x01\x04\0\x02\x02\x02\x12\x03E\x1a\x1b\n\"\n\ + \x06\x04\x01\x04\0\x02\x03\x12\x03G\x04\x1c\x1a\x13\x20Field\x20type\x20\ + int64.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x03\x01\x12\x03G\x04\x0e\n\x0e\n\ + \x07\x04\x01\x04\0\x02\x03\x02\x12\x03G\x1a\x1b\n#\n\x06\x04\x01\x04\0\ + \x02\x04\x12\x03I\x04\x1c\x1a\x14\x20Field\x20type\x20uint64.\n\n\x0e\n\ + \x07\x04\x01\x04\0\x02\x04\x01\x12\x03I\x04\x0f\n\x0e\n\x07\x04\x01\x04\ + \0\x02\x04\x02\x12\x03I\x1a\x1b\n\"\n\x06\x04\x01\x04\0\x02\x05\x12\x03K\ + \x04\x1c\x1a\x13\x20Field\x20type\x20int32.\n\n\x0e\n\x07\x04\x01\x04\0\ + \x02\x05\x01\x12\x03K\x04\x0e\n\x0e\n\x07\x04\x01\x04\0\x02\x05\x02\x12\ + \x03K\x1a\x1b\n$\n\x06\x04\x01\x04\0\x02\x06\x12\x03M\x04\x1c\x1a\x15\ + \x20Field\x20type\x20fixed64.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x06\x01\ + \x12\x03M\x04\x10\n\x0e\n\x07\x04\x01\x04\0\x02\x06\x02\x12\x03M\x1a\x1b\ + \n$\n\x06\x04\x01\x04\0\x02\x07\x12\x03O\x04\x1c\x1a\x15\x20Field\x20typ\ + e\x20fixed32.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x07\x01\x12\x03O\x04\x10\n\ + \x0e\n\x07\x04\x01\x04\0\x02\x07\x02\x12\x03O\x1a\x1b\n!\n\x06\x04\x01\ + \x04\0\x02\x08\x12\x03Q\x04\x1c\x1a\x12\x20Field\x20type\x20bool.\n\n\ + \x0e\n\x07\x04\x01\x04\0\x02\x08\x01\x12\x03Q\x04\r\n\x0e\n\x07\x04\x01\ + \x04\0\x02\x08\x02\x12\x03Q\x1a\x1b\n#\n\x06\x04\x01\x04\0\x02\t\x12\x03\ + S\x04\x1c\x1a\x14\x20Field\x20type\x20string.\n\n\x0e\n\x07\x04\x01\x04\ + \0\x02\t\x01\x12\x03S\x04\x0f\n\x0e\n\x07\x04\x01\x04\0\x02\t\x02\x12\ + \x03S\x1a\x1b\nF\n\x06\x04\x01\x04\0\x02\n\x12\x03U\x04\x1d\x1a7\x20Fiel\ + d\x20type\x20group.\x20Proto2\x20syntax\x20only,\x20and\x20deprecated.\n\ + \n\x0e\n\x07\x04\x01\x04\0\x02\n\x01\x12\x03U\x04\x0e\n\x0e\n\x07\x04\ + \x01\x04\0\x02\n\x02\x12\x03U\x1a\x1c\n$\n\x06\x04\x01\x04\0\x02\x0b\x12\ + \x03W\x04\x1d\x1a\x15\x20Field\x20type\x20message.\n\n\x0e\n\x07\x04\x01\ + \x04\0\x02\x0b\x01\x12\x03W\x04\x10\n\x0e\n\x07\x04\x01\x04\0\x02\x0b\ + \x02\x12\x03W\x1a\x1c\n\"\n\x06\x04\x01\x04\0\x02\x0c\x12\x03Y\x04\x1d\ + \x1a\x13\x20Field\x20type\x20bytes.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x0c\ + \x01\x12\x03Y\x04\x0e\n\x0e\n\x07\x04\x01\x04\0\x02\x0c\x02\x12\x03Y\x1a\ + \x1c\n#\n\x06\x04\x01\x04\0\x02\r\x12\x03[\x04\x1d\x1a\x14\x20Field\x20t\ + ype\x20uint32.\n\n\x0e\n\x07\x04\x01\x04\0\x02\r\x01\x12\x03[\x04\x0f\n\ + \x0e\n\x07\x04\x01\x04\0\x02\r\x02\x12\x03[\x1a\x1c\n!\n\x06\x04\x01\x04\ + \0\x02\x0e\x12\x03]\x04\x1d\x1a\x12\x20Field\x20type\x20enum.\n\n\x0e\n\ + \x07\x04\x01\x04\0\x02\x0e\x01\x12\x03]\x04\r\n\x0e\n\x07\x04\x01\x04\0\ + \x02\x0e\x02\x12\x03]\x1a\x1c\n%\n\x06\x04\x01\x04\0\x02\x0f\x12\x03_\ + \x04\x1d\x1a\x16\x20Field\x20type\x20sfixed32.\n\n\x0e\n\x07\x04\x01\x04\ + \0\x02\x0f\x01\x12\x03_\x04\x11\n\x0e\n\x07\x04\x01\x04\0\x02\x0f\x02\ + \x12\x03_\x1a\x1c\n%\n\x06\x04\x01\x04\0\x02\x10\x12\x03a\x04\x1d\x1a\ + \x16\x20Field\x20type\x20sfixed64.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x10\ + \x01\x12\x03a\x04\x11\n\x0e\n\x07\x04\x01\x04\0\x02\x10\x02\x12\x03a\x1a\ + \x1c\n#\n\x06\x04\x01\x04\0\x02\x11\x12\x03c\x04\x1d\x1a\x14\x20Field\ + \x20type\x20sint32.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x11\x01\x12\x03c\x04\ + \x0f\n\x0e\n\x07\x04\x01\x04\0\x02\x11\x02\x12\x03c\x1a\x1c\n#\n\x06\x04\ + \x01\x04\0\x02\x12\x12\x03e\x04\x1d\x1a\x14\x20Field\x20type\x20sint64.\ + \n\n\x0e\n\x07\x04\x01\x04\0\x02\x12\x01\x12\x03e\x04\x0f\n\x0e\n\x07\ + \x04\x01\x04\0\x02\x12\x02\x12\x03e\x1a\x1c\nC\n\x04\x04\x01\x04\x01\x12\ + \x04i\x02r\x03\x1a5\x20Whether\x20a\x20field\x20is\x20optional,\x20requi\ + red,\x20or\x20repeated.\n\n\x0c\n\x05\x04\x01\x04\x01\x01\x12\x03i\x07\ + \x12\n5\n\x06\x04\x01\x04\x01\x02\0\x12\x03k\x04\x1c\x1a&\x20For\x20fiel\ + ds\x20with\x20unknown\x20cardinality.\n\n\x0e\n\x07\x04\x01\x04\x01\x02\ + \0\x01\x12\x03k\x04\x17\n\x0e\n\x07\x04\x01\x04\x01\x02\0\x02\x12\x03k\ + \x1a\x1b\n%\n\x06\x04\x01\x04\x01\x02\x01\x12\x03m\x04\x1d\x1a\x16\x20Fo\ + r\x20optional\x20fields.\n\n\x0e\n\x07\x04\x01\x04\x01\x02\x01\x01\x12\ + \x03m\x04\x18\n\x0e\n\x07\x04\x01\x04\x01\x02\x01\x02\x12\x03m\x1b\x1c\n\ + 9\n\x06\x04\x01\x04\x01\x02\x02\x12\x03o\x04\x1d\x1a*\x20For\x20required\ + \x20fields.\x20Proto2\x20syntax\x20only.\n\n\x0e\n\x07\x04\x01\x04\x01\ + \x02\x02\x01\x12\x03o\x04\x18\n\x0e\n\x07\x04\x01\x04\x01\x02\x02\x02\ + \x12\x03o\x1b\x1c\n%\n\x06\x04\x01\x04\x01\x02\x03\x12\x03q\x04\x1d\x1a\ + \x16\x20For\x20repeated\x20fields.\n\n\x0e\n\x07\x04\x01\x04\x01\x02\x03\ + \x01\x12\x03q\x04\x18\n\x0e\n\x07\x04\x01\x04\x01\x02\x03\x02\x12\x03q\ + \x1b\x1c\n\x1e\n\x04\x04\x01\x02\0\x12\x03u\x02\x10\x1a\x11\x20The\x20fi\ + eld\x20type.\n\n\x0c\n\x05\x04\x01\x02\0\x06\x12\x03u\x02\x06\n\x0c\n\ + \x05\x04\x01\x02\0\x01\x12\x03u\x07\x0b\n\x0c\n\x05\x04\x01\x02\0\x03\ + \x12\x03u\x0e\x0f\n%\n\x04\x04\x01\x02\x01\x12\x03w\x02\x1e\x1a\x18\x20T\ + he\x20field\x20cardinality.\n\n\x0c\n\x05\x04\x01\x02\x01\x06\x12\x03w\ + \x02\r\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03w\x0e\x19\n\x0c\n\x05\x04\ + \x01\x02\x01\x03\x12\x03w\x1c\x1d\n\x20\n\x04\x04\x01\x02\x02\x12\x03y\ + \x02\x13\x1a\x13\x20The\x20field\x20number.\n\n\x0c\n\x05\x04\x01\x02\ + \x02\x05\x12\x03y\x02\x07\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03y\x08\ + \x0e\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03y\x11\x12\n\x1e\n\x04\x04\ + \x01\x02\x03\x12\x03{\x02\x12\x1a\x11\x20The\x20field\x20name.\n\n\x0c\n\ + \x05\x04\x01\x02\x03\x05\x12\x03{\x02\x08\n\x0c\n\x05\x04\x01\x02\x03\ + \x01\x12\x03{\t\r\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03{\x10\x11\n\x96\ + \x01\n\x04\x04\x01\x02\x04\x12\x03~\x02\x16\x1a\x88\x01\x20The\x20field\ + \x20type\x20URL,\x20without\x20the\x20scheme,\x20for\x20message\x20or\ + \x20enumeration\n\x20types.\x20Example:\x20`\"type.googleapis.com/google\ + .protobuf.Timestamp\"`.\n\n\x0c\n\x05\x04\x01\x02\x04\x05\x12\x03~\x02\ + \x08\n\x0c\n\x05\x04\x01\x02\x04\x01\x12\x03~\t\x11\n\x0c\n\x05\x04\x01\ + \x02\x04\x03\x12\x03~\x14\x15\n\xa5\x01\n\x04\x04\x01\x02\x05\x12\x04\ + \x81\x01\x02\x18\x1a\x96\x01\x20The\x20index\x20of\x20the\x20field\x20ty\ + pe\x20in\x20`Type.oneofs`,\x20for\x20message\x20or\x20enumeration\n\x20t\ + ypes.\x20The\x20first\x20type\x20has\x20index\x201;\x20zero\x20means\x20\ + the\x20type\x20is\x20not\x20in\x20the\x20list.\n\n\r\n\x05\x04\x01\x02\ + \x05\x05\x12\x04\x81\x01\x02\x07\n\r\n\x05\x04\x01\x02\x05\x01\x12\x04\ + \x81\x01\x08\x13\n\r\n\x05\x04\x01\x02\x05\x03\x12\x04\x81\x01\x16\x17\n\ + F\n\x04\x04\x01\x02\x06\x12\x04\x83\x01\x02\x12\x1a8\x20Whether\x20to\ + \x20use\x20alternative\x20packed\x20wire\x20representation.\n\n\r\n\x05\ + \x04\x01\x02\x06\x05\x12\x04\x83\x01\x02\x06\n\r\n\x05\x04\x01\x02\x06\ + \x01\x12\x04\x83\x01\x07\r\n\r\n\x05\x04\x01\x02\x06\x03\x12\x04\x83\x01\ + \x10\x11\n,\n\x04\x04\x01\x02\x07\x12\x04\x85\x01\x02\x1e\x1a\x1e\x20The\ + \x20protocol\x20buffer\x20options.\n\n\r\n\x05\x04\x01\x02\x07\x04\x12\ + \x04\x85\x01\x02\n\n\r\n\x05\x04\x01\x02\x07\x06\x12\x04\x85\x01\x0b\x11\ + \n\r\n\x05\x04\x01\x02\x07\x01\x12\x04\x85\x01\x12\x19\n\r\n\x05\x04\x01\ + \x02\x07\x03\x12\x04\x85\x01\x1c\x1d\n$\n\x04\x04\x01\x02\x08\x12\x04\ + \x87\x01\x02\x18\x1a\x16\x20The\x20field\x20JSON\x20name.\n\n\r\n\x05\ + \x04\x01\x02\x08\x05\x12\x04\x87\x01\x02\x08\n\r\n\x05\x04\x01\x02\x08\ + \x01\x12\x04\x87\x01\t\x12\n\r\n\x05\x04\x01\x02\x08\x03\x12\x04\x87\x01\ + \x15\x17\nX\n\x04\x04\x01\x02\t\x12\x04\x89\x01\x02\x1c\x1aJ\x20The\x20s\ + tring\x20value\x20of\x20the\x20default\x20value\x20of\x20this\x20field.\ + \x20Proto2\x20syntax\x20only.\n\n\r\n\x05\x04\x01\x02\t\x05\x12\x04\x89\ + \x01\x02\x08\n\r\n\x05\x04\x01\x02\t\x01\x12\x04\x89\x01\t\x16\n\r\n\x05\ + \x04\x01\x02\t\x03\x12\x04\x89\x01\x19\x1b\n%\n\x02\x04\x02\x12\x06\x8d\ + \x01\0\x98\x01\x01\x1a\x17\x20Enum\x20type\x20definition.\n\n\x0b\n\x03\ + \x04\x02\x01\x12\x04\x8d\x01\x08\x0c\n\x1f\n\x04\x04\x02\x02\0\x12\x04\ + \x8f\x01\x02\x12\x1a\x11\x20Enum\x20type\x20name.\n\n\r\n\x05\x04\x02\ + \x02\0\x05\x12\x04\x8f\x01\x02\x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\ + \x8f\x01\t\r\n\r\n\x05\x04\x02\x02\0\x03\x12\x04\x8f\x01\x10\x11\n'\n\ + \x04\x04\x02\x02\x01\x12\x04\x91\x01\x02#\x1a\x19\x20Enum\x20value\x20de\ + finitions.\n\n\r\n\x05\x04\x02\x02\x01\x04\x12\x04\x91\x01\x02\n\n\r\n\ + \x05\x04\x02\x02\x01\x06\x12\x04\x91\x01\x0b\x14\n\r\n\x05\x04\x02\x02\ + \x01\x01\x12\x04\x91\x01\x15\x1e\n\r\n\x05\x04\x02\x02\x01\x03\x12\x04\ + \x91\x01!\"\n(\n\x04\x04\x02\x02\x02\x12\x04\x93\x01\x02\x1e\x1a\x1a\x20\ + Protocol\x20buffer\x20options.\n\n\r\n\x05\x04\x02\x02\x02\x04\x12\x04\ + \x93\x01\x02\n\n\r\n\x05\x04\x02\x02\x02\x06\x12\x04\x93\x01\x0b\x11\n\r\ + \n\x05\x04\x02\x02\x02\x01\x12\x04\x93\x01\x12\x19\n\r\n\x05\x04\x02\x02\ + \x02\x03\x12\x04\x93\x01\x1c\x1d\n#\n\x04\x04\x02\x02\x03\x12\x04\x95\ + \x01\x02#\x1a\x15\x20The\x20source\x20context.\n\n\r\n\x05\x04\x02\x02\ + \x03\x06\x12\x04\x95\x01\x02\x0f\n\r\n\x05\x04\x02\x02\x03\x01\x12\x04\ + \x95\x01\x10\x1e\n\r\n\x05\x04\x02\x02\x03\x03\x12\x04\x95\x01!\"\n\"\n\ + \x04\x04\x02\x02\x04\x12\x04\x97\x01\x02\x14\x1a\x14\x20The\x20source\ + \x20syntax.\n\n\r\n\x05\x04\x02\x02\x04\x06\x12\x04\x97\x01\x02\x08\n\r\ + \n\x05\x04\x02\x02\x04\x01\x12\x04\x97\x01\t\x0f\n\r\n\x05\x04\x02\x02\ + \x04\x03\x12\x04\x97\x01\x12\x13\n&\n\x02\x04\x03\x12\x06\x9b\x01\0\xa2\ + \x01\x01\x1a\x18\x20Enum\x20value\x20definition.\n\n\x0b\n\x03\x04\x03\ + \x01\x12\x04\x9b\x01\x08\x11\n\x20\n\x04\x04\x03\x02\0\x12\x04\x9d\x01\ + \x02\x12\x1a\x12\x20Enum\x20value\x20name.\n\n\r\n\x05\x04\x03\x02\0\x05\ + \x12\x04\x9d\x01\x02\x08\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\x9d\x01\t\r\ + \n\r\n\x05\x04\x03\x02\0\x03\x12\x04\x9d\x01\x10\x11\n\"\n\x04\x04\x03\ + \x02\x01\x12\x04\x9f\x01\x02\x13\x1a\x14\x20Enum\x20value\x20number.\n\n\ + \r\n\x05\x04\x03\x02\x01\x05\x12\x04\x9f\x01\x02\x07\n\r\n\x05\x04\x03\ + \x02\x01\x01\x12\x04\x9f\x01\x08\x0e\n\r\n\x05\x04\x03\x02\x01\x03\x12\ + \x04\x9f\x01\x11\x12\n(\n\x04\x04\x03\x02\x02\x12\x04\xa1\x01\x02\x1e\ + \x1a\x1a\x20Protocol\x20buffer\x20options.\n\n\r\n\x05\x04\x03\x02\x02\ + \x04\x12\x04\xa1\x01\x02\n\n\r\n\x05\x04\x03\x02\x02\x06\x12\x04\xa1\x01\ + \x0b\x11\n\r\n\x05\x04\x03\x02\x02\x01\x12\x04\xa1\x01\x12\x19\n\r\n\x05\ + \x04\x03\x02\x02\x03\x12\x04\xa1\x01\x1c\x1d\ng\n\x02\x04\x04\x12\x06\ + \xa6\x01\0\xab\x01\x01\x1aY\x20A\x20protocol\x20buffer\x20option,\x20whi\ + ch\x20can\x20be\x20attached\x20to\x20a\x20message,\x20field,\n\x20enumer\ + ation,\x20etc.\n\n\x0b\n\x03\x04\x04\x01\x12\x04\xa6\x01\x08\x0e\nA\n\ + \x04\x04\x04\x02\0\x12\x04\xa8\x01\x02\x12\x1a3\x20The\x20option's\x20na\ + me.\x20For\x20example,\x20`\"java_package\"`.\n\n\r\n\x05\x04\x04\x02\0\ + \x05\x12\x04\xa8\x01\x02\x08\n\r\n\x05\x04\x04\x02\0\x01\x12\x04\xa8\x01\ + \t\r\n\r\n\x05\x04\x04\x02\0\x03\x12\x04\xa8\x01\x10\x11\nI\n\x04\x04\ + \x04\x02\x01\x12\x04\xaa\x01\x02\x10\x1a;\x20The\x20option's\x20value.\ + \x20For\x20example,\x20`\"com.google.protobuf\"`.\n\n\r\n\x05\x04\x04\ + \x02\x01\x06\x12\x04\xaa\x01\x02\x05\n\r\n\x05\x04\x04\x02\x01\x01\x12\ + \x04\xaa\x01\x06\x0b\n\r\n\x05\x04\x04\x02\x01\x03\x12\x04\xaa\x01\x0e\ + \x0f\nI\n\x02\x05\0\x12\x06\xae\x01\0\xb3\x01\x01\x1a;\x20The\x20syntax\ + \x20in\x20which\x20a\x20protocol\x20buffer\x20element\x20is\x20defined.\ + \n\n\x0b\n\x03\x05\0\x01\x12\x04\xae\x01\x05\x0b\n\x20\n\x04\x05\0\x02\0\ + \x12\x04\xb0\x01\x02\x14\x1a\x12\x20Syntax\x20`proto2`.\n\n\r\n\x05\x05\ + \0\x02\0\x01\x12\x04\xb0\x01\x02\x0f\n\r\n\x05\x05\0\x02\0\x02\x12\x04\ + \xb0\x01\x12\x13\n\x20\n\x04\x05\0\x02\x01\x12\x04\xb2\x01\x02\x14\x1a\ + \x12\x20Syntax\x20`proto3`.\n\n\r\n\x05\x05\0\x02\x01\x01\x12\x04\xb2\ + \x01\x02\x0f\n\r\n\x05\x05\0\x02\x01\x02\x12\x04\xb2\x01\x12\x13b\x06pro\ + to3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/src/well_known_types/wrappers.rs b/src/well_known_types/wrappers.rs new file mode 100644 index 0000000..35015fd --- /dev/null +++ b/src/well_known_types/wrappers.rs @@ -0,0 +1,1597 @@ +// This file is generated by rust-protobuf 2.14.0-pre. Do not edit +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![cfg_attr(rustfmt, rustfmt_skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unsafe_code)] +#![allow(unused_imports)] +#![allow(unused_results)] +//! Generated file from `google/protobuf/wrappers.proto` + +use protobuf::Message as Message_imported_for_functions; +use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct DoubleValue { + // message fields + pub value: f64, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a DoubleValue { + fn default() -> &'a DoubleValue { + <DoubleValue as ::protobuf::Message>::default_instance() + } +} + +impl DoubleValue { + pub fn new() -> DoubleValue { + ::std::default::Default::default() + } + + // double value = 1; + + + pub fn get_value(&self) -> f64 { + self.value + } + pub fn clear_value(&mut self) { + self.value = 0.; + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: f64) { + self.value = v; + } +} + +impl ::protobuf::Message for DoubleValue { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeFixed64 { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_double()?; + self.value = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.value != 0. { + my_size += 9; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if self.value != 0. { + os.write_double(1, self.value)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> DoubleValue { + DoubleValue::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>( + "value", + |m: &DoubleValue| { &m.value }, + |m: &mut DoubleValue| { &mut m.value }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<DoubleValue>( + "DoubleValue", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static DoubleValue { + static mut instance: ::protobuf::lazy::Lazy<DoubleValue> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(DoubleValue::new) + } + } +} + +impl ::protobuf::Clear for DoubleValue { + fn clear(&mut self) { + self.value = 0.; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for DoubleValue { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for DoubleValue { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct FloatValue { + // message fields + pub value: f32, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a FloatValue { + fn default() -> &'a FloatValue { + <FloatValue as ::protobuf::Message>::default_instance() + } +} + +impl FloatValue { + pub fn new() -> FloatValue { + ::std::default::Default::default() + } + + // float value = 1; + + + pub fn get_value(&self) -> f32 { + self.value + } + pub fn clear_value(&mut self) { + self.value = 0.; + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: f32) { + self.value = v; + } +} + +impl ::protobuf::Message for FloatValue { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeFixed32 { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_float()?; + self.value = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.value != 0. { + my_size += 5; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if self.value != 0. { + os.write_float(1, self.value)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> FloatValue { + FloatValue::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>( + "value", + |m: &FloatValue| { &m.value }, + |m: &mut FloatValue| { &mut m.value }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<FloatValue>( + "FloatValue", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static FloatValue { + static mut instance: ::protobuf::lazy::Lazy<FloatValue> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(FloatValue::new) + } + } +} + +impl ::protobuf::Clear for FloatValue { + fn clear(&mut self) { + self.value = 0.; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for FloatValue { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for FloatValue { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Int64Value { + // message fields + pub value: i64, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Int64Value { + fn default() -> &'a Int64Value { + <Int64Value as ::protobuf::Message>::default_instance() + } +} + +impl Int64Value { + pub fn new() -> Int64Value { + ::std::default::Default::default() + } + + // int64 value = 1; + + + pub fn get_value(&self) -> i64 { + self.value + } + pub fn clear_value(&mut self) { + self.value = 0; + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: i64) { + self.value = v; + } +} + +impl ::protobuf::Message for Int64Value { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int64()?; + self.value = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.value != 0 { + my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if self.value != 0 { + os.write_int64(1, self.value)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Int64Value { + Int64Value::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>( + "value", + |m: &Int64Value| { &m.value }, + |m: &mut Int64Value| { &mut m.value }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Int64Value>( + "Int64Value", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Int64Value { + static mut instance: ::protobuf::lazy::Lazy<Int64Value> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Int64Value::new) + } + } +} + +impl ::protobuf::Clear for Int64Value { + fn clear(&mut self) { + self.value = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Int64Value { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Int64Value { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct UInt64Value { + // message fields + pub value: u64, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UInt64Value { + fn default() -> &'a UInt64Value { + <UInt64Value as ::protobuf::Message>::default_instance() + } +} + +impl UInt64Value { + pub fn new() -> UInt64Value { + ::std::default::Default::default() + } + + // uint64 value = 1; + + + pub fn get_value(&self) -> u64 { + self.value + } + pub fn clear_value(&mut self) { + self.value = 0; + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: u64) { + self.value = v; + } +} + +impl ::protobuf::Message for UInt64Value { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_uint64()?; + self.value = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.value != 0 { + my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if self.value != 0 { + os.write_uint64(1, self.value)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UInt64Value { + UInt64Value::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>( + "value", + |m: &UInt64Value| { &m.value }, + |m: &mut UInt64Value| { &mut m.value }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<UInt64Value>( + "UInt64Value", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UInt64Value { + static mut instance: ::protobuf::lazy::Lazy<UInt64Value> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(UInt64Value::new) + } + } +} + +impl ::protobuf::Clear for UInt64Value { + fn clear(&mut self) { + self.value = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UInt64Value { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UInt64Value { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct Int32Value { + // message fields + pub value: i32, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a Int32Value { + fn default() -> &'a Int32Value { + <Int32Value as ::protobuf::Message>::default_instance() + } +} + +impl Int32Value { + pub fn new() -> Int32Value { + ::std::default::Default::default() + } + + // int32 value = 1; + + + pub fn get_value(&self) -> i32 { + self.value + } + pub fn clear_value(&mut self) { + self.value = 0; + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: i32) { + self.value = v; + } +} + +impl ::protobuf::Message for Int32Value { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_int32()?; + self.value = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.value != 0 { + my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if self.value != 0 { + os.write_int32(1, self.value)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> Int32Value { + Int32Value::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( + "value", + |m: &Int32Value| { &m.value }, + |m: &mut Int32Value| { &mut m.value }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<Int32Value>( + "Int32Value", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static Int32Value { + static mut instance: ::protobuf::lazy::Lazy<Int32Value> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(Int32Value::new) + } + } +} + +impl ::protobuf::Clear for Int32Value { + fn clear(&mut self) { + self.value = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for Int32Value { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Int32Value { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct UInt32Value { + // message fields + pub value: u32, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a UInt32Value { + fn default() -> &'a UInt32Value { + <UInt32Value as ::protobuf::Message>::default_instance() + } +} + +impl UInt32Value { + pub fn new() -> UInt32Value { + ::std::default::Default::default() + } + + // uint32 value = 1; + + + pub fn get_value(&self) -> u32 { + self.value + } + pub fn clear_value(&mut self) { + self.value = 0; + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: u32) { + self.value = v; + } +} + +impl ::protobuf::Message for UInt32Value { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_uint32()?; + self.value = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.value != 0 { + my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if self.value != 0 { + os.write_uint32(1, self.value)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> UInt32Value { + UInt32Value::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>( + "value", + |m: &UInt32Value| { &m.value }, + |m: &mut UInt32Value| { &mut m.value }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<UInt32Value>( + "UInt32Value", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static UInt32Value { + static mut instance: ::protobuf::lazy::Lazy<UInt32Value> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(UInt32Value::new) + } + } +} + +impl ::protobuf::Clear for UInt32Value { + fn clear(&mut self) { + self.value = 0; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for UInt32Value { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for UInt32Value { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct BoolValue { + // message fields + pub value: bool, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a BoolValue { + fn default() -> &'a BoolValue { + <BoolValue as ::protobuf::Message>::default_instance() + } +} + +impl BoolValue { + pub fn new() -> BoolValue { + ::std::default::Default::default() + } + + // bool value = 1; + + + pub fn get_value(&self) -> bool { + self.value + } + pub fn clear_value(&mut self) { + self.value = false; + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: bool) { + self.value = v; + } +} + +impl ::protobuf::Message for BoolValue { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + if wire_type != ::protobuf::wire_format::WireTypeVarint { + return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); + } + let tmp = is.read_bool()?; + self.value = tmp; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if self.value != false { + my_size += 2; + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if self.value != false { + os.write_bool(1, self.value)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> BoolValue { + BoolValue::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>( + "value", + |m: &BoolValue| { &m.value }, + |m: &mut BoolValue| { &mut m.value }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<BoolValue>( + "BoolValue", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static BoolValue { + static mut instance: ::protobuf::lazy::Lazy<BoolValue> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(BoolValue::new) + } + } +} + +impl ::protobuf::Clear for BoolValue { + fn clear(&mut self) { + self.value = false; + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for BoolValue { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for BoolValue { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct StringValue { + // message fields + pub value: ::std::string::String, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a StringValue { + fn default() -> &'a StringValue { + <StringValue as ::protobuf::Message>::default_instance() + } +} + +impl StringValue { + pub fn new() -> StringValue { + ::std::default::Default::default() + } + + // string value = 1; + + + pub fn get_value(&self) -> &str { + &self.value + } + pub fn clear_value(&mut self) { + self.value.clear(); + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: ::std::string::String) { + self.value = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_value(&mut self) -> &mut ::std::string::String { + &mut self.value + } + + // Take field + pub fn take_value(&mut self) -> ::std::string::String { + ::std::mem::replace(&mut self.value, ::std::string::String::new()) + } +} + +impl ::protobuf::Message for StringValue { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.value)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.value.is_empty() { + my_size += ::protobuf::rt::string_size(1, &self.value); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.value.is_empty() { + os.write_string(1, &self.value)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> StringValue { + StringValue::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( + "value", + |m: &StringValue| { &m.value }, + |m: &mut StringValue| { &mut m.value }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<StringValue>( + "StringValue", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static StringValue { + static mut instance: ::protobuf::lazy::Lazy<StringValue> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(StringValue::new) + } + } +} + +impl ::protobuf::Clear for StringValue { + fn clear(&mut self) { + self.value.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for StringValue { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for StringValue { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +#[derive(PartialEq,Clone,Default)] +#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))] +pub struct BytesValue { + // message fields + pub value: ::std::vec::Vec<u8>, + // special fields + #[cfg_attr(feature = "with-serde", serde(skip))] + pub unknown_fields: ::protobuf::UnknownFields, + #[cfg_attr(feature = "with-serde", serde(skip))] + pub cached_size: ::protobuf::CachedSize, +} + +impl<'a> ::std::default::Default for &'a BytesValue { + fn default() -> &'a BytesValue { + <BytesValue as ::protobuf::Message>::default_instance() + } +} + +impl BytesValue { + pub fn new() -> BytesValue { + ::std::default::Default::default() + } + + // bytes value = 1; + + + pub fn get_value(&self) -> &[u8] { + &self.value + } + pub fn clear_value(&mut self) { + self.value.clear(); + } + + // Param is passed by value, moved + pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) { + self.value = v; + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> { + &mut self.value + } + + // Take field + pub fn take_value(&mut self) -> ::std::vec::Vec<u8> { + ::std::mem::replace(&mut self.value, ::std::vec::Vec::new()) + } +} + +impl ::protobuf::Message for BytesValue { + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { + while !is.eof()? { + let (field_number, wire_type) = is.read_tag_unpack()?; + match field_number { + 1 => { + ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?; + }, + _ => { + ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u32 { + let mut my_size = 0; + if !self.value.is_empty() { + my_size += ::protobuf::rt::bytes_size(1, &self.value); + } + my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); + self.cached_size.set(my_size); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { + if !self.value.is_empty() { + os.write_bytes(1, &self.value)?; + } + os.write_unknown_fields(self.get_unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn get_cached_size(&self) -> u32 { + self.cached_size.get() + } + + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + &self.unknown_fields + } + + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + &mut self.unknown_fields + } + + fn as_any(&self) -> &dyn (::std::any::Any) { + self as &dyn (::std::any::Any) + } + fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { + self as &mut dyn (::std::any::Any) + } + fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { + self + } + + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + + fn new() -> BytesValue { + BytesValue::new() + } + + fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { + static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT; + unsafe { + descriptor.get(|| { + let mut fields = ::std::vec::Vec::new(); + fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( + "value", + |m: &BytesValue| { &m.value }, + |m: &mut BytesValue| { &mut m.value }, + )); + ::protobuf::reflect::MessageDescriptor::new_pb_name::<BytesValue>( + "BytesValue", + fields, + file_descriptor_proto() + ) + }) + } + } + + fn default_instance() -> &'static BytesValue { + static mut instance: ::protobuf::lazy::Lazy<BytesValue> = ::protobuf::lazy::Lazy::INIT; + unsafe { + instance.get(BytesValue::new) + } + } +} + +impl ::protobuf::Clear for BytesValue { + fn clear(&mut self) { + self.value.clear(); + self.unknown_fields.clear(); + } +} + +impl ::std::fmt::Debug for BytesValue { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for BytesValue { + fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { + ::protobuf::reflect::ReflectValueRef::Message(self) + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\x1egoogle/protobuf/wrappers.proto\x12\x0fgoogle.protobuf\"#\n\x0bDoub\ + leValue\x12\x14\n\x05value\x18\x01\x20\x01(\x01R\x05value\"\"\n\nFloatVa\ + lue\x12\x14\n\x05value\x18\x01\x20\x01(\x02R\x05value\"\"\n\nInt64Value\ + \x12\x14\n\x05value\x18\x01\x20\x01(\x03R\x05value\"#\n\x0bUInt64Value\ + \x12\x14\n\x05value\x18\x01\x20\x01(\x04R\x05value\"\"\n\nInt32Value\x12\ + \x14\n\x05value\x18\x01\x20\x01(\x05R\x05value\"#\n\x0bUInt32Value\x12\ + \x14\n\x05value\x18\x01\x20\x01(\rR\x05value\"!\n\tBoolValue\x12\x14\n\ + \x05value\x18\x01\x20\x01(\x08R\x05value\"#\n\x0bStringValue\x12\x14\n\ + \x05value\x18\x01\x20\x01(\tR\x05value\"\"\n\nBytesValue\x12\x14\n\x05va\ + lue\x18\x01\x20\x01(\x0cR\x05valueB|\n\x13com.google.protobufB\rWrappers\ + ProtoP\x01Z*github.com/golang/protobuf/ptypes/wrappers\xf8\x01\x01\xa2\ + \x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesJ\xae\x1d\n\x06\x12\ + \x04#\0u\x01\n\xc3\x0e\n\x01\x0c\x12\x03#\0\x122\xc1\x0c\x20Protocol\x20\ + Buffers\x20-\x20Google's\x20data\x20interchange\x20format\n\x20Copyright\ + \x202008\x20Google\x20Inc.\x20\x20All\x20rights\x20reserved.\n\x20https:\ + //developers.google.com/protocol-buffers/\n\n\x20Redistribution\x20and\ + \x20use\x20in\x20source\x20and\x20binary\x20forms,\x20with\x20or\x20with\ + out\n\x20modification,\x20are\x20permitted\x20provided\x20that\x20the\ + \x20following\x20conditions\x20are\n\x20met:\n\n\x20\x20\x20\x20\x20*\ + \x20Redistributions\x20of\x20source\x20code\x20must\x20retain\x20the\x20\ + above\x20copyright\n\x20notice,\x20this\x20list\x20of\x20conditions\x20a\ + nd\x20the\x20following\x20disclaimer.\n\x20\x20\x20\x20\x20*\x20Redistri\ + butions\x20in\x20binary\x20form\x20must\x20reproduce\x20the\x20above\n\ + \x20copyright\x20notice,\x20this\x20list\x20of\x20conditions\x20and\x20t\ + he\x20following\x20disclaimer\n\x20in\x20the\x20documentation\x20and/or\ + \x20other\x20materials\x20provided\x20with\x20the\n\x20distribution.\n\ + \x20\x20\x20\x20\x20*\x20Neither\x20the\x20name\x20of\x20Google\x20Inc.\ + \x20nor\x20the\x20names\x20of\x20its\n\x20contributors\x20may\x20be\x20u\ + sed\x20to\x20endorse\x20or\x20promote\x20products\x20derived\x20from\n\ + \x20this\x20software\x20without\x20specific\x20prior\x20written\x20permi\ + ssion.\n\n\x20THIS\x20SOFTWARE\x20IS\x20PROVIDED\x20BY\x20THE\x20COPYRIG\ + HT\x20HOLDERS\x20AND\x20CONTRIBUTORS\n\x20\"AS\x20IS\"\x20AND\x20ANY\x20\ + EXPRESS\x20OR\x20IMPLIED\x20WARRANTIES,\x20INCLUDING,\x20BUT\x20NOT\n\ + \x20LIMITED\x20TO,\x20THE\x20IMPLIED\x20WARRANTIES\x20OF\x20MERCHANTABIL\ + ITY\x20AND\x20FITNESS\x20FOR\n\x20A\x20PARTICULAR\x20PURPOSE\x20ARE\x20D\ + ISCLAIMED.\x20IN\x20NO\x20EVENT\x20SHALL\x20THE\x20COPYRIGHT\n\x20OWNER\ + \x20OR\x20CONTRIBUTORS\x20BE\x20LIABLE\x20FOR\x20ANY\x20DIRECT,\x20INDIR\ + ECT,\x20INCIDENTAL,\n\x20SPECIAL,\x20EXEMPLARY,\x20OR\x20CONSEQUENTIAL\ + \x20DAMAGES\x20(INCLUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\x20PROCUREM\ + ENT\x20OF\x20SUBSTITUTE\x20GOODS\x20OR\x20SERVICES;\x20LOSS\x20OF\x20USE\ + ,\n\x20DATA,\x20OR\x20PROFITS;\x20OR\x20BUSINESS\x20INTERRUPTION)\x20HOW\ + EVER\x20CAUSED\x20AND\x20ON\x20ANY\n\x20THEORY\x20OF\x20LIABILITY,\x20WH\ + ETHER\x20IN\x20CONTRACT,\x20STRICT\x20LIABILITY,\x20OR\x20TORT\n\x20(INC\ + LUDING\x20NEGLIGENCE\x20OR\x20OTHERWISE)\x20ARISING\x20IN\x20ANY\x20WAY\ + \x20OUT\x20OF\x20THE\x20USE\n\x20OF\x20THIS\x20SOFTWARE,\x20EVEN\x20IF\ + \x20ADVISED\x20OF\x20THE\x20POSSIBILITY\x20OF\x20SUCH\x20DAMAGE.\n2\xf4\ + \x01\x20Wrappers\x20for\x20primitive\x20(non-message)\x20types.\x20These\ + \x20types\x20are\x20useful\n\x20for\x20embedding\x20primitives\x20in\x20\ + the\x20`google.protobuf.Any`\x20type\x20and\x20for\x20places\n\x20where\ + \x20we\x20need\x20to\x20distinguish\x20between\x20the\x20absence\x20of\ + \x20a\x20primitive\n\x20typed\x20field\x20and\x20its\x20default\x20value\ + .\n\n\x08\n\x01\x02\x12\x03%\0\x18\n\x08\n\x01\x08\x12\x03'\0;\n\t\n\x02\ + \x08%\x12\x03'\0;\n\x08\n\x01\x08\x12\x03(\0\x1f\n\t\n\x02\x08\x1f\x12\ + \x03(\0\x1f\n\x08\n\x01\x08\x12\x03)\0A\n\t\n\x02\x08\x0b\x12\x03)\0A\n\ + \x08\n\x01\x08\x12\x03*\0,\n\t\n\x02\x08\x01\x12\x03*\0,\n\x08\n\x01\x08\ + \x12\x03+\0.\n\t\n\x02\x08\x08\x12\x03+\0.\n\x08\n\x01\x08\x12\x03,\0\"\ + \n\t\n\x02\x08\n\x12\x03,\0\"\n\x08\n\x01\x08\x12\x03-\0!\n\t\n\x02\x08$\ + \x12\x03-\0!\ng\n\x02\x04\0\x12\x042\05\x01\x1a[\x20Wrapper\x20message\ + \x20for\x20`double`.\n\n\x20The\x20JSON\x20representation\x20for\x20`Dou\ + bleValue`\x20is\x20JSON\x20number.\n\n\n\n\x03\x04\0\x01\x12\x032\x08\ + \x13\n\x20\n\x04\x04\0\x02\0\x12\x034\x02\x13\x1a\x13\x20The\x20double\ + \x20value.\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x034\x02\x08\n\x0c\n\x05\ + \x04\0\x02\0\x01\x12\x034\t\x0e\n\x0c\n\x05\x04\0\x02\0\x03\x12\x034\x11\ + \x12\ne\n\x02\x04\x01\x12\x04:\0=\x01\x1aY\x20Wrapper\x20message\x20for\ + \x20`float`.\n\n\x20The\x20JSON\x20representation\x20for\x20`FloatValue`\ + \x20is\x20JSON\x20number.\n\n\n\n\x03\x04\x01\x01\x12\x03:\x08\x12\n\x1f\ + \n\x04\x04\x01\x02\0\x12\x03<\x02\x12\x1a\x12\x20The\x20float\x20value.\ + \n\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03<\x02\x07\n\x0c\n\x05\x04\x01\ + \x02\0\x01\x12\x03<\x08\r\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03<\x10\x11\ + \ne\n\x02\x04\x02\x12\x04B\0E\x01\x1aY\x20Wrapper\x20message\x20for\x20`\ + int64`.\n\n\x20The\x20JSON\x20representation\x20for\x20`Int64Value`\x20i\ + s\x20JSON\x20string.\n\n\n\n\x03\x04\x02\x01\x12\x03B\x08\x12\n\x1f\n\ + \x04\x04\x02\x02\0\x12\x03D\x02\x12\x1a\x12\x20The\x20int64\x20value.\n\ + \n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03D\x02\x07\n\x0c\n\x05\x04\x02\x02\ + \0\x01\x12\x03D\x08\r\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03D\x10\x11\ng\ + \n\x02\x04\x03\x12\x04J\0M\x01\x1a[\x20Wrapper\x20message\x20for\x20`uin\ + t64`.\n\n\x20The\x20JSON\x20representation\x20for\x20`UInt64Value`\x20is\ + \x20JSON\x20string.\n\n\n\n\x03\x04\x03\x01\x12\x03J\x08\x13\n\x20\n\x04\ + \x04\x03\x02\0\x12\x03L\x02\x13\x1a\x13\x20The\x20uint64\x20value.\n\n\ + \x0c\n\x05\x04\x03\x02\0\x05\x12\x03L\x02\x08\n\x0c\n\x05\x04\x03\x02\0\ + \x01\x12\x03L\t\x0e\n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03L\x11\x12\ne\n\ + \x02\x04\x04\x12\x04R\0U\x01\x1aY\x20Wrapper\x20message\x20for\x20`int32\ + `.\n\n\x20The\x20JSON\x20representation\x20for\x20`Int32Value`\x20is\x20\ + JSON\x20number.\n\n\n\n\x03\x04\x04\x01\x12\x03R\x08\x12\n\x1f\n\x04\x04\ + \x04\x02\0\x12\x03T\x02\x12\x1a\x12\x20The\x20int32\x20value.\n\n\x0c\n\ + \x05\x04\x04\x02\0\x05\x12\x03T\x02\x07\n\x0c\n\x05\x04\x04\x02\0\x01\ + \x12\x03T\x08\r\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03T\x10\x11\ng\n\x02\ + \x04\x05\x12\x04Z\0]\x01\x1a[\x20Wrapper\x20message\x20for\x20`uint32`.\ + \n\n\x20The\x20JSON\x20representation\x20for\x20`UInt32Value`\x20is\x20J\ + SON\x20number.\n\n\n\n\x03\x04\x05\x01\x12\x03Z\x08\x13\n\x20\n\x04\x04\ + \x05\x02\0\x12\x03\\\x02\x13\x1a\x13\x20The\x20uint32\x20value.\n\n\x0c\ + \n\x05\x04\x05\x02\0\x05\x12\x03\\\x02\x08\n\x0c\n\x05\x04\x05\x02\0\x01\ + \x12\x03\\\t\x0e\n\x0c\n\x05\x04\x05\x02\0\x03\x12\x03\\\x11\x12\no\n\ + \x02\x04\x06\x12\x04b\0e\x01\x1ac\x20Wrapper\x20message\x20for\x20`bool`\ + .\n\n\x20The\x20JSON\x20representation\x20for\x20`BoolValue`\x20is\x20JS\ + ON\x20`true`\x20and\x20`false`.\n\n\n\n\x03\x04\x06\x01\x12\x03b\x08\x11\ + \n\x1e\n\x04\x04\x06\x02\0\x12\x03d\x02\x11\x1a\x11\x20The\x20bool\x20va\ + lue.\n\n\x0c\n\x05\x04\x06\x02\0\x05\x12\x03d\x02\x06\n\x0c\n\x05\x04\ + \x06\x02\0\x01\x12\x03d\x07\x0c\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03d\ + \x0f\x10\ng\n\x02\x04\x07\x12\x04j\0m\x01\x1a[\x20Wrapper\x20message\x20\ + for\x20`string`.\n\n\x20The\x20JSON\x20representation\x20for\x20`StringV\ + alue`\x20is\x20JSON\x20string.\n\n\n\n\x03\x04\x07\x01\x12\x03j\x08\x13\ + \n\x20\n\x04\x04\x07\x02\0\x12\x03l\x02\x13\x1a\x13\x20The\x20string\x20\ + value.\n\n\x0c\n\x05\x04\x07\x02\0\x05\x12\x03l\x02\x08\n\x0c\n\x05\x04\ + \x07\x02\0\x01\x12\x03l\t\x0e\n\x0c\n\x05\x04\x07\x02\0\x03\x12\x03l\x11\ + \x12\ne\n\x02\x04\x08\x12\x04r\0u\x01\x1aY\x20Wrapper\x20message\x20for\ + \x20`bytes`.\n\n\x20The\x20JSON\x20representation\x20for\x20`BytesValue`\ + \x20is\x20JSON\x20string.\n\n\n\n\x03\x04\x08\x01\x12\x03r\x08\x12\n\x1f\ + \n\x04\x04\x08\x02\0\x12\x03t\x02\x12\x1a\x12\x20The\x20bytes\x20value.\ + \n\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03t\x02\x07\n\x0c\n\x05\x04\x08\ + \x02\0\x01\x12\x03t\x08\r\n\x0c\n\x05\x04\x08\x02\0\x03\x12\x03t\x10\x11\ + b\x06proto3\ +"; + +static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT; + +fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { + ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() +} + +pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + unsafe { + file_descriptor_proto_lazy.get(|| { + parse_descriptor_proto() + }) + } +} diff --git a/src/zigzag.rs b/src/zigzag.rs new file mode 100644 index 0000000..4c7d27d --- /dev/null +++ b/src/zigzag.rs @@ -0,0 +1,50 @@ +// ZigZag endoging used for efficient transfer of signed integers +// https://developers.google.com/protocol-buffers/docs/encoding#types + +pub fn decode_zig_zag_32(n: u32) -> i32 { + ((n >> 1) as i32) ^ (-((n & 1) as i32)) +} + +pub fn decode_zig_zag_64(n: u64) -> i64 { + ((n >> 1) as i64) ^ (-((n & 1) as i64)) +} + +pub fn encode_zig_zag_32(n: i32) -> u32 { + ((n << 1) ^ (n >> 31)) as u32 +} + +pub fn encode_zig_zag_64(n: i64) -> u64 { + ((n << 1) ^ (n >> 63)) as u64 +} + +#[cfg(test)] +mod test { + + use super::decode_zig_zag_32; + use super::decode_zig_zag_64; + use super::encode_zig_zag_32; + use super::encode_zig_zag_64; + + #[test] + fn test_zig_zag() { + fn test_zig_zag_pair_64(decoded: i64, encoded: u64) { + assert_eq!(decoded, decode_zig_zag_64(encoded)); + assert_eq!(encoded, encode_zig_zag_64(decoded)); + } + + fn test_zig_zag_pair(decoded: i32, encoded: u32) { + assert_eq!(decoded, decode_zig_zag_32(encoded)); + assert_eq!(encoded, encode_zig_zag_32(decoded)); + test_zig_zag_pair_64(decoded as i64, encoded as u64); + } + + test_zig_zag_pair(0, 0); + test_zig_zag_pair(-1, 1); + test_zig_zag_pair(1, 2); + test_zig_zag_pair(-2, 3); + test_zig_zag_pair(2147483647, 4294967294); + test_zig_zag_pair(-2147483648, 4294967295); + test_zig_zag_pair_64(9223372036854775807, 18446744073709551614); + test_zig_zag_pair_64(-9223372036854775808, 18446744073709551615); + } +} |