Introduce libprotobuf_deprecated am: 158191ed44 am: 7ed901823e am: ee940834e7 am: 1d50a14de4
Original change: https://android-review.googlesource.com/c/platform/external/rust/crates/protobuf/+/2510795
Change-Id: Icc6c8ea081660c4aadfdda472121cef445821abc
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
diff --git a/2.27.1/.cargo_vcs_info.json b/2.27.1/.cargo_vcs_info.json
new file mode 100644
index 0000000..ca74a42
--- /dev/null
+++ b/2.27.1/.cargo_vcs_info.json
@@ -0,0 +1,6 @@
+{
+ "git": {
+ "sha1": "ec31ce829473039ac598ca6fdcb245cbd6fa82ba"
+ },
+ "path_in_vcs": "protobuf"
+}
\ No newline at end of file
diff --git a/2.27.1/Android.bp b/2.27.1/Android.bp
new file mode 100644
index 0000000..6801e6f
--- /dev/null
+++ b/2.27.1/Android.bp
@@ -0,0 +1,36 @@
+// This file is generated by cargo2android.py --config cargo2android.json.
+// Do not modify this file as changes will be overridden on upgrade.
+
+genrule {
+ name: "copy_protobuf_deprecated_build_out",
+ srcs: ["out/*"],
+ cmd: "cp $(in) $(genDir)",
+ out: ["version.rs"],
+}
+
+rust_library {
+ name: "libprotobuf_deprecated",
+ // has rustc warnings
+ host_supported: true,
+ crate_name: "protobuf",
+ cargo_env_compat: true,
+ cargo_pkg_version: "2.27.1",
+ srcs: [
+ "src/lib.rs",
+ ":copy_protobuf_deprecated_build_out",
+ ],
+ edition: "2018",
+ features: ["bytes"],
+ rustlibs: [
+ "libbytes",
+ ],
+ apex_available: [
+ "//apex_available:platform",
+ "com.android.btservices",
+ "com.android.compos",
+ "com.android.virt",
+ ],
+ product_available: true,
+ vendor_available: true,
+ min_sdk_version: "29",
+}
diff --git a/2.27.1/Cargo.toml b/2.27.1/Cargo.toml
new file mode 100644
index 0000000..9e4935f
--- /dev/null
+++ b/2.27.1/Cargo.toml
@@ -0,0 +1,50 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "protobuf"
+version = "2.27.1"
+authors = ["Stepan Koltsov <stepan.koltsov@gmail.com>"]
+description = """
+Rust implementation of Google protocol buffers
+"""
+homepage = "https://github.com/stepancheg/rust-protobuf/"
+documentation = "https://github.com/stepancheg/rust-protobuf/blob/master/README.md"
+license = "MIT"
+repository = "https://github.com/stepancheg/rust-protobuf/"
+
+[package.metadata.docs.rs]
+all-features = true
+
+[lib]
+doctest = false
+bench = false
+
+[dependencies.bytes]
+version = "1.0"
+optional = true
+
+[dependencies.serde]
+version = "1.0"
+features = ["derive"]
+optional = true
+
+[dependencies.serde_derive]
+version = "1.0"
+optional = true
+
+[features]
+with-bytes = ["bytes"]
+with-serde = [
+ "serde",
+ "serde_derive",
+]
diff --git a/2.27.1/Cargo.toml.orig b/2.27.1/Cargo.toml.orig
new file mode 100644
index 0000000..c1be2f7
--- /dev/null
+++ b/2.27.1/Cargo.toml.orig
@@ -0,0 +1,29 @@
+[package]
+
+name = "protobuf"
+version = "2.27.1"
+authors = ["Stepan Koltsov <stepan.koltsov@gmail.com>"]
+edition = "2018"
+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 = "1.0", optional = true }
+serde = { version = "1.0", features = ["derive"], optional = true }
+serde_derive = { version = "1.0", optional = true }
+
+[package.metadata.docs.rs]
+all-features = true
diff --git a/2.27.1/LICENSE b/2.27.1/LICENSE
new file mode 120000
index 0000000..85de3d4
--- /dev/null
+++ b/2.27.1/LICENSE
@@ -0,0 +1 @@
+LICENSE.txt
\ No newline at end of file
diff --git a/2.27.1/LICENSE.txt b/2.27.1/LICENSE.txt
new file mode 100644
index 0000000..acce639
--- /dev/null
+++ b/2.27.1/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/2.27.1/METADATA b/2.27.1/METADATA
new file mode 100644
index 0000000..2bcb504
--- /dev/null
+++ b/2.27.1/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: ARCHIVE
+ value: "https://static.crates.io/crates/protobuf/protobuf-2.27.1.crate"
+ }
+ version: "2.27.1"
+ license_type: NOTICE
+ last_upgrade_date {
+ year: 2022
+ month: 3
+ day: 1
+ }
+}
diff --git a/2.27.1/MODULE_LICENSE_MIT b/2.27.1/MODULE_LICENSE_MIT
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/2.27.1/MODULE_LICENSE_MIT
diff --git a/2.27.1/NOTICE b/2.27.1/NOTICE
new file mode 120000
index 0000000..7a694c9
--- /dev/null
+++ b/2.27.1/NOTICE
@@ -0,0 +1 @@
+LICENSE
\ No newline at end of file
diff --git a/2.27.1/OWNERS b/2.27.1/OWNERS
new file mode 100644
index 0000000..46fc303
--- /dev/null
+++ b/2.27.1/OWNERS
@@ -0,0 +1 @@
+include platform/prebuilts/rust:/OWNERS
diff --git a/2.27.1/README.md b/2.27.1/README.md
new file mode 100644
index 0000000..af32486
--- /dev/null
+++ b/2.27.1/README.md
@@ -0,0 +1,95 @@
+<!-- cargo-sync-readme start -->
+
+# Library to read and write protocol buffers data
+
+# Version 2 is stable
+
+Currently developed branch of rust-protobuf [is 3](https://docs.rs/protobuf/%3E=3.0.0-alpha).
+It has the same spirit as version 2, but contains numerous improvements like:
+* runtime reflection for mutability, not just for access
+* protobuf text format and JSON parsing (which rely on reflection)
+* dynamic message support: work with protobuf data without generating code from schema
+
+Stable version of rust-protobuf will be supported until version 3 released.
+
+[Tracking issue for version 3](https://github.com/stepancheg/rust-protobuf/issues/518).
+
+# How to generate rust code
+
+There are several ways to generate rust code from `.proto` files
+
+## Invoke `protoc` programmatically with protoc-rust crate (recommended)
+
+Have a look at readme in [protoc-rust crate](https://docs.rs/protoc-rust/=2).
+
+## Use pure rust protobuf parser and code generator
+
+Readme should be in
+[protobuf-codegen-pure crate](https://docs.rs/protobuf-codegen-pure/=2).
+
+## Use protoc-gen-rust plugin
+
+Readme is [here](https://docs.rs/protobuf-codegen/=2).
+
+## Generated code
+
+Have a look at generated files (for current development version),
+used internally in rust-protobuf:
+
+* [descriptor.rs](https://github.com/stepancheg/rust-protobuf/blob/master/protobuf/src/descriptor.rs)
+ for [descriptor.proto](https://github.com/stepancheg/rust-protobuf/blob/master/protoc-bin-vendored/include/google/protobuf/descriptor.proto)
+ (that is part of Google protobuf)
+
+# Copy on write
+
+Rust-protobuf can be used with [bytes crate](https://github.com/tokio-rs/bytes).
+
+To enable `Bytes` you need to:
+
+1. Enable `with-bytes` feature in rust-protobuf:
+
+```rust
+[dependencies]
+protobuf = { version = "~2.0", features = ["with-bytes"] }
+```
+
+2. Enable bytes option
+
+with `Customize` when codegen is invoked programmatically:
+
+```rust
+protoc_rust::run(protoc_rust::Args {
+ ...
+ customize: Customize {
+ carllerche_bytes_for_bytes: Some(true),
+ carllerche_bytes_for_string: Some(true),
+ ..Default::default()
+ },
+});
+```
+
+or in `.proto` file:
+
+```rust
+import "rustproto.proto";
+
+option (rustproto.carllerche_bytes_for_bytes_all) = true;
+option (rustproto.carllerche_bytes_for_string_all) = true;
+```
+
+With these options enabled, fields of type `bytes` or `string` are
+generated as `Bytes` or `Chars` respectively. When `CodedInputStream` is constructed
+from `Bytes` object, fields of these types get subslices of original `Bytes` object,
+instead of being allocated on heap.
+
+# Accompanying crates
+
+* [`protoc-rust`](https://docs.rs/protoc-rust/=2)
+ and [`protobuf-codegen-pure`](https://docs.rs/protobuf-codegen-pure/=2)
+ can be used to rust code from `.proto` crates.
+* [`protobuf-codegen`](https://docs.rs/protobuf-codegen/=2) for `protoc-gen-rust` protoc plugin.
+* [`protoc`](https://docs.rs/protoc/=2) crate can be used to invoke `protoc` programmatically.
+* [`protoc-bin-vendored`](https://docs.rs/protoc-bin-vendored/=2) contains `protoc` command
+ packed into the crate.
+
+<!-- cargo-sync-readme end -->
diff --git a/2.27.1/TEST_MAPPING b/2.27.1/TEST_MAPPING
new file mode 100644
index 0000000..0225a59
--- /dev/null
+++ b/2.27.1/TEST_MAPPING
@@ -0,0 +1,14 @@
+// Generated by update_crate_tests.py for tests that depend on this crate.
+{
+ "imports": [
+ {
+ "path": "packages/modules/Virtualization/authfs"
+ },
+ {
+ "path": "packages/modules/Virtualization/microdroid_manager"
+ },
+ {
+ "path": "packages/modules/Virtualization/virtualizationmanager"
+ }
+ ]
+}
diff --git a/2.27.1/benches/coded_input_stream.rs b/2.27.1/benches/coded_input_stream.rs
new file mode 100644
index 0000000..d1795e5
--- /dev/null
+++ b/2.27.1/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::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/2.27.1/benches/coded_output_stream.rs b/2.27.1/benches/coded_output_stream.rs
new file mode 100644
index 0000000..9edf95c
--- /dev/null
+++ b/2.27.1/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::CodedOutputStream;
+
+use self::test::Bencher;
+
+#[inline]
+fn buffer_write_byte(os: &mut 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 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 = 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 = CodedOutputStream::new(&mut v);
+ buffer_write_bytes(&mut os);
+ }
+ v
+ });
+}
diff --git a/2.27.1/build.rs b/2.27.1/build.rs
new file mode 100644
index 0000000..653ba35
--- /dev/null
+++ b/2.27.1/build.rs
@@ -0,0 +1,78 @@
+use std::env;
+use std::fs::File;
+use std::io::Read;
+use std::io::Write;
+use std::path::Path;
+use std::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/2.27.1/cargo2android.json b/2.27.1/cargo2android.json
new file mode 100644
index 0000000..cafe7cd
--- /dev/null
+++ b/2.27.1/cargo2android.json
@@ -0,0 +1,24 @@
+{
+ "apex-available": [
+ "//apex_available:platform",
+ "com.android.btservices",
+ "com.android.compos",
+ "com.android.virt"
+ ],
+ "copy-out": true,
+ "dependencies": true,
+ "device": true,
+ "features": "bytes",
+ "variants": [
+ {
+ "suffix": ""
+ },
+ {
+ "suffix": "_with_serde",
+ "features": "with-serde",
+ "device": false
+ }
+ ],
+ "min-sdk-version": "29",
+ "run": true
+}
\ No newline at end of file
diff --git a/2.27.1/out/version.rs b/2.27.1/out/version.rs
new file mode 100644
index 0000000..18bbac5
--- /dev/null
+++ b/2.27.1/out/version.rs
@@ -0,0 +1,7 @@
+/// protobuf crate version
+pub const VERSION: &'static str = "2.27.1";
+/// This symbol is used by codegen
+#[doc(hidden)]
+pub const VERSION_IDENT: &'static str = "VERSION_2_27_1";
+/// This symbol can be referenced to assert that proper version of crate is used
+pub const VERSION_2_27_1: () = ();
diff --git a/2.27.1/regenerate.sh b/2.27.1/regenerate.sh
new file mode 100755
index 0000000..0173496
--- /dev/null
+++ b/2.27.1/regenerate.sh
@@ -0,0 +1,74 @@
+#!/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
+cargo build --manifest-path=../protoc-bin-vendored/Cargo.toml --bin protoc-bin-which
+
+PROTOC=$(cargo run --manifest-path=../protoc-bin-vendored/Cargo.toml --bin protoc-bin-which)
+
+where_am_i=$(
+ cd ..
+ pwd
+)
+
+rm -rf tmp-generated
+mkdir tmp-generated
+
+case $(uname) in
+Linux)
+ exe_suffix=""
+ ;;
+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 \
+ -I../protoc-bin-vendored/include \
+ ../protoc-bin-vendored/include/google/protobuf/*.proto \
+ ../protoc-bin-vendored/include/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() {
+ # shellcheck disable=SC2010
+ ls | grep -v mod.rs | sed -e 's,\.rs$,,'
+ }
+
+ echo
+ mod_list | sed -e 's,^,mod ,; s,$,;,'
+
+ echo
+ mod_list | while read -r mod; do
+ echo "pub use self::$mod::*;"
+ done
+)
+
+# vim: set ts=4 sw=4 et:
diff --git a/2.27.1/src/any.rs b/2.27.1/src/any.rs
new file mode 100644
index 0000000..31ddd82
--- /dev/null
+++ b/2.27.1/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/2.27.1/src/buf_read_iter.rs b/2.27.1/src/buf_read_iter.rs
new file mode 100644
index 0000000..ff1fce2
--- /dev/null
+++ b/2.27.1/src/buf_read_iter.rs
@@ -0,0 +1,523 @@
+use std::cmp;
+use std::io::BufRead;
+use std::io::BufReader;
+use std::io::Read;
+use std::mem;
+use std::mem::MaybeUninit;
+use std::u64;
+
+#[cfg(feature = "bytes")]
+use bytes::buf::UninitSlice;
+#[cfg(feature = "bytes")]
+use bytes::BufMut;
+#[cfg(feature = "bytes")]
+use bytes::Bytes;
+#[cfg(feature = "bytes")]
+use bytes::BytesMut;
+
+use crate::buf_read_or_reader::BufReadOrReader;
+use crate::coded_input_stream::READ_RAW_BYTES_MAX_ALLOC;
+use crate::error::WireError;
+use crate::misc::maybe_uninit_write_slice;
+use crate::misc::vec_spare_capacity_mut;
+use crate::ProtobufError;
+use crate::ProtobufResult;
+
+// 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> {
+ Read(BufReadOrReader<'a>),
+ 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(crate) 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::Read(ref mut buf_read) => buf_read.consume(self.pos_within_buf),
+ _ => {}
+ }
+ }
+}
+
+impl<'ignore> BufReadIter<'ignore> {
+ pub(crate) fn from_read<'a>(read: &'a mut dyn Read) -> BufReadIter<'a> {
+ BufReadIter {
+ input_source: InputSource::Read(BufReadOrReader::BufReader(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(crate) fn from_buf_read<'a>(buf_read: &'a mut dyn BufRead) -> BufReadIter<'a> {
+ BufReadIter {
+ input_source: InputSource::Read(BufReadOrReader::BufRead(buf_read)),
+ buf: &[],
+ pos_within_buf: 0,
+ limit_within_buf: 0,
+ pos_of_buf_start: 0,
+ limit: NO_LIMIT,
+ }
+ }
+
+ pub(crate) 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(crate) 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(crate) 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(crate) fn push_limit(&mut self, limit: u64) -> ProtobufResult<u64> {
+ let new_limit = match self.pos().checked_add(limit) {
+ Some(new_limit) => new_limit,
+ None => return Err(ProtobufError::WireError(WireError::Other)),
+ };
+
+ 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(crate) fn pop_limit(&mut self, limit: u64) {
+ assert!(limit >= self.limit);
+
+ self.limit = limit;
+
+ self.update_limit_within_buf();
+ }
+
+ #[inline]
+ pub(crate) 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(crate) fn remaining_in_buf_len(&self) -> usize {
+ self.limit_within_buf - self.pos_within_buf
+ }
+
+ #[inline(always)]
+ pub(crate) 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(crate) 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(crate) fn read_byte(&mut self) -> ProtobufResult<u8> {
+ if self.pos_within_buf == self.limit_within_buf {
+ self.do_fill_buf()?;
+ if self.remaining_in_buf_len() == 0 {
+ 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)
+ }
+
+ #[cfg(feature = "bytes")]
+ pub(crate) fn read_exact_bytes(&mut self, len: usize) -> ProtobufResult<Bytes> {
+ if let InputSource::Bytes(bytes) = self.input_source {
+ let end = match self.pos_within_buf.checked_add(len) {
+ Some(end) => end,
+ None => return Err(ProtobufError::WireError(WireError::UnexpectedEof)),
+ };
+
+ if end > self.limit_within_buf {
+ return Err(ProtobufError::WireError(WireError::UnexpectedEof));
+ }
+
+ let r = bytes.slice(self.pos_within_buf..end);
+ self.pos_within_buf += len;
+ Ok(r)
+ } else {
+ if len >= READ_RAW_BYTES_MAX_ALLOC {
+ // We cannot trust `len` because protobuf message could be malformed.
+ // Reading should not result in OOM when allocating a buffer.
+ let mut v = Vec::new();
+ self.read_exact_to_vec(len, &mut v)?;
+ Ok(Bytes::from(v))
+ } else {
+ let mut r = BytesMut::with_capacity(len);
+ unsafe {
+ let buf = Self::uninit_slice_as_mut_slice(&mut r.chunk_mut()[..len]);
+ self.read_exact(buf)?;
+ r.advance_mut(len);
+ }
+ Ok(r.freeze())
+ }
+ }
+ }
+
+ #[cfg(feature = "bytes")]
+ unsafe fn uninit_slice_as_mut_slice(slice: &mut UninitSlice) -> &mut [MaybeUninit<u8>] {
+ use std::slice;
+ slice::from_raw_parts_mut(slice.as_mut_ptr() as *mut MaybeUninit<u8>, slice.len())
+ }
+
+ /// Returns 0 when EOF or limit reached.
+ pub(crate) fn read(&mut self, buf: &mut [u8]) -> ProtobufResult<usize> {
+ self.fill_buf()?;
+
+ let rem = &self.buf[self.pos_within_buf..self.limit_within_buf];
+
+ let len = cmp::min(rem.len(), buf.len());
+ buf[..len].copy_from_slice(&rem[..len]);
+ self.pos_within_buf += len;
+ Ok(len)
+ }
+
+ fn read_exact_slow(&mut self, buf: &mut [MaybeUninit<u8>]) -> ProtobufResult<()> {
+ if self.bytes_until_limit() < buf.len() as u64 {
+ return Err(ProtobufError::WireError(WireError::UnexpectedEof));
+ }
+
+ let consume = self.pos_within_buf;
+ self.pos_of_buf_start += self.pos_within_buf as u64;
+ self.pos_within_buf = 0;
+ self.buf = &[];
+ self.limit_within_buf = 0;
+
+ match self.input_source {
+ InputSource::Read(ref mut buf_read) => {
+ buf_read.consume(consume);
+ buf_read.read_exact_uninit(buf)?;
+ }
+ _ => {
+ return Err(ProtobufError::WireError(WireError::UnexpectedEof));
+ }
+ }
+
+ self.pos_of_buf_start += buf.len() as u64;
+
+ self.assertions();
+
+ Ok(())
+ }
+
+ #[inline]
+ pub(crate) fn read_exact(&mut self, buf: &mut [MaybeUninit<u8>]) -> ProtobufResult<()> {
+ if self.remaining_in_buf_len() >= buf.len() {
+ let buf_len = buf.len();
+ maybe_uninit_write_slice(
+ buf,
+ &self.buf[self.pos_within_buf..self.pos_within_buf + buf_len],
+ );
+ self.pos_within_buf += buf_len;
+ return Ok(());
+ }
+
+ self.read_exact_slow(buf)
+ }
+
+ /// Read exact number of bytes into `Vec`.
+ ///
+ /// `Vec` is cleared in the beginning.
+ 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 vec_spare_capacity_mut(target)[..count])?;
+ target.set_len(count);
+ }
+ }
+
+ debug_assert_eq!(count, target.len());
+
+ 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()?) };
+ }
+ _ => {
+ return Ok(());
+ }
+ }
+
+ self.update_limit_within_buf();
+
+ Ok(())
+ }
+
+ #[inline(always)]
+ pub(crate) 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(crate) 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 std::io::Write;
+
+ use super::*;
+
+ 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 std::io;
+ use std::io::BufRead;
+ use std::io::Read;
+
+ use super::*;
+
+ #[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 [
+ MaybeUninit::uninit(),
+ MaybeUninit::uninit(),
+ MaybeUninit::uninit(),
+ MaybeUninit::uninit(),
+ ])
+ .expect("read_exact");
+ assert!(buf_read_iter.eof().expect("eof"));
+ }
+}
diff --git a/2.27.1/src/buf_read_or_reader.rs b/2.27.1/src/buf_read_or_reader.rs
new file mode 100644
index 0000000..6a47c76
--- /dev/null
+++ b/2.27.1/src/buf_read_or_reader.rs
@@ -0,0 +1,85 @@
+//! `BufRead` pointer or `BufReader` owned.
+
+use std::cmp;
+use std::io;
+use std::io::BufRead;
+use std::io::BufReader;
+use std::io::Read;
+use std::mem::MaybeUninit;
+
+use crate::misc::maybe_uninit_write_slice;
+
+/// Helper type to simplify `BufReadIter` implementation.
+pub(crate) enum BufReadOrReader<'a> {
+ BufReader(BufReader<&'a mut dyn Read>),
+ BufRead(&'a mut dyn BufRead),
+}
+
+impl<'a> Read for BufReadOrReader<'a> {
+ fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
+ match self {
+ BufReadOrReader::BufReader(r) => r.read(buf),
+ BufReadOrReader::BufRead(r) => r.read(buf),
+ }
+ }
+
+ fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, io::Error> {
+ match self {
+ BufReadOrReader::BufReader(r) => r.read_to_end(buf),
+ BufReadOrReader::BufRead(r) => r.read_to_end(buf),
+ }
+ }
+
+ fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), io::Error> {
+ match self {
+ BufReadOrReader::BufReader(r) => r.read_exact(buf),
+ BufReadOrReader::BufRead(r) => r.read_exact(buf),
+ }
+ }
+}
+
+impl<'a> BufReadOrReader<'a> {
+ /// Similar to `read_exact` but reads into `MaybeUninit`.
+ pub(crate) fn read_exact_uninit(
+ &mut self,
+ buf: &mut [MaybeUninit<u8>],
+ ) -> Result<(), io::Error> {
+ let mut pos = 0;
+ while pos != buf.len() {
+ let fill_buf = match self {
+ BufReadOrReader::BufReader(r) => r.fill_buf()?,
+ BufReadOrReader::BufRead(r) => r.fill_buf()?,
+ };
+ if fill_buf.is_empty() {
+ return Err(io::Error::new(
+ io::ErrorKind::UnexpectedEof,
+ "Unexpected end of file",
+ ));
+ }
+ let consume = cmp::min(fill_buf.len(), buf.len() - pos);
+ maybe_uninit_write_slice(&mut buf[pos..pos + consume], &fill_buf[..consume]);
+ match self {
+ BufReadOrReader::BufReader(r) => r.consume(consume),
+ BufReadOrReader::BufRead(r) => r.consume(consume),
+ }
+ pos += consume;
+ }
+ Ok(())
+ }
+}
+
+impl<'a> BufRead for BufReadOrReader<'a> {
+ fn fill_buf(&mut self) -> Result<&[u8], io::Error> {
+ match self {
+ BufReadOrReader::BufReader(r) => r.fill_buf(),
+ BufReadOrReader::BufRead(r) => r.fill_buf(),
+ }
+ }
+
+ fn consume(&mut self, amt: usize) {
+ match self {
+ BufReadOrReader::BufReader(r) => r.consume(amt),
+ BufReadOrReader::BufRead(r) => r.consume(amt),
+ }
+ }
+}
diff --git a/2.27.1/src/cached_size.rs b/2.27.1/src/cached_size.rs
new file mode 100644
index 0000000..350ddac
--- /dev/null
+++ b/2.27.1/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/2.27.1/src/chars.rs b/2.27.1/src/chars.rs
new file mode 100644
index 0000000..49c02d7
--- /dev/null
+++ b/2.27.1/src/chars.rs
@@ -0,0 +1,107 @@
+#![cfg(feature = "bytes")]
+
+use std::fmt;
+use std::ops::Deref;
+use std::str;
+
+use bytes::Bytes;
+
+use crate::clear::Clear;
+
+/// Thin wrapper around `Bytes` which guarantees that bytes are valid UTF-8 string.
+/// Should be API-compatible to `String`.
+#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct Chars(Bytes);
+
+impl Chars {
+ /// New empty object.
+ pub 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 Into<String> for Chars {
+ fn into(self) -> String {
+ // This is safe because `Chars` is guaranteed to store a valid UTF-8 string
+ unsafe { String::from_utf8_unchecked(self.0.as_ref().to_owned()) }
+ }
+}
+
+impl Default for Chars {
+ fn default() -> Self {
+ Chars::new()
+ }
+}
+
+impl Deref for Chars {
+ type Target = str;
+
+ fn deref(&self) -> &str {
+ // This is safe because `Chars` is guaranteed to store a valid UTF-8 string
+ unsafe { str::from_utf8_unchecked(&self.0) }
+ }
+}
+
+impl 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/2.27.1/src/clear.rs b/2.27.1/src/clear.rs
new file mode 100644
index 0000000..712c492
--- /dev/null
+++ b/2.27.1/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/2.27.1/src/coded_input_stream.rs b/2.27.1/src/coded_input_stream.rs
new file mode 100644
index 0000000..a49563c
--- /dev/null
+++ b/2.27.1/src/coded_input_stream.rs
@@ -0,0 +1,976 @@
+#![doc(hidden)]
+
+//! `CodedInputStream` and `CodedOutputStream` implementations
+
+use std::io;
+use std::io::BufRead;
+use std::io::Read;
+use std::mem;
+use std::mem::MaybeUninit;
+use std::slice;
+
+#[cfg(feature = "bytes")]
+use bytes::Bytes;
+
+use crate::buf_read_iter::BufReadIter;
+#[cfg(feature = "bytes")]
+use crate::chars::Chars;
+use crate::enums::ProtobufEnum;
+use crate::error::ProtobufError;
+use crate::error::ProtobufResult;
+use crate::error::WireError;
+use crate::message::Message;
+use crate::misc::maybe_ununit_array_assume_init;
+use crate::unknown::UnknownValue;
+use crate::wire_format;
+use crate::zigzag::decode_zig_zag_32;
+use crate::zigzag::decode_zig_zag_64;
+
+/// Default recursion level limit. 100 is the default value of C++'s implementation.
+const DEFAULT_RECURSION_LIMIT: u32 = 100;
+
+/// Max allocated vec when reading length-delimited from unknown input stream
+pub(crate) const READ_RAW_BYTES_MAX_ALLOC: usize = 10_000_000;
+
+/// Buffered read with handy utilities.
+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 dyn 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 dyn BufRead) -> CodedInputStream<'a> {
+ CodedInputStream::from_buf_read_iter(BufReadIter::from_buf_read(buf_read))
+ }
+
+ /// Read from byte slice
+ pub fn from_bytes(bytes: &'a [u8]) -> CodedInputStream<'a> {
+ CodedInputStream::from_buf_read_iter(BufReadIter::from_byte_slice(bytes))
+ }
+
+ /// Read from `Bytes`.
+ ///
+ /// `CodedInputStream` operations like
+ /// [`read_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`.
+ #[inline]
+ fn read_exact_uninit(&mut self, buf: &mut [MaybeUninit<u8>]) -> ProtobufResult<()> {
+ self.source.read_exact(buf)
+ }
+
+ /// Read bytes into given `buf`.
+ ///
+ /// Return `0` on EOF.
+ // TODO: overload with `Read::read`
+ pub fn read(&mut self, buf: &mut [u8]) -> ProtobufResult<()> {
+ // SAFETY: same layout
+ let buf = unsafe {
+ slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut MaybeUninit<u8>, buf.len())
+ };
+ self.read_exact_uninit(buf)
+ }
+
+ /// Read exact number of bytes as `Bytes` object.
+ ///
+ /// 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 bytes = [MaybeUninit::uninit(); 4];
+ self.read_exact_uninit(&mut bytes)?;
+ // SAFETY: `read_exact` guarantees that the buffer is filled.
+ let bytes = unsafe { maybe_ununit_array_assume_init(bytes) };
+ Ok(u32::from_le_bytes(bytes))
+ }
+
+ /// Read little-endian 64-bit integer
+ pub fn read_raw_little_endian64(&mut self) -> ProtobufResult<u64> {
+ let mut bytes = [MaybeUninit::uninit(); 8];
+ self.read_exact_uninit(&mut bytes)?;
+ // SAFETY: `read_exact` guarantees that the buffer is filled.
+ let bytes = unsafe { maybe_ununit_array_assume_init(bytes) };
+ Ok(u64::from_le_bytes(bytes))
+ }
+
+ /// Read tag
+ #[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<()> {
+ self.source.read_exact_to_vec(count as usize, target)
+ }
+
+ /// 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)),
+ };
+ *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)
+ }
+}
+
+/// 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 (dyn 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 (dyn 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)
+ }
+}
+
+#[cfg(test)]
+mod test {
+
+ use std::fmt::Debug;
+ use std::io;
+ use std::io::BufRead;
+ use std::io::Read;
+
+ use super::CodedInputStream;
+ use super::READ_RAW_BYTES_MAX_ALLOC;
+ use crate::error::ProtobufError;
+ use crate::error::ProtobufResult;
+ use crate::hex::decode_hex;
+
+ 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"));
+ }
+}
diff --git a/2.27.1/src/coded_output_stream.rs b/2.27.1/src/coded_output_stream.rs
new file mode 100644
index 0000000..2bbe0a3
--- /dev/null
+++ b/2.27.1/src/coded_output_stream.rs
@@ -0,0 +1,756 @@
+use std::io;
+use std::io::Write;
+use std::mem;
+use std::mem::MaybeUninit;
+use std::ptr;
+use std::slice;
+
+use crate::misc::maybe_uninit_write;
+use crate::misc::maybe_uninit_write_slice;
+use crate::misc::vec_spare_capacity_mut;
+use crate::varint;
+use crate::wire_format;
+use crate::zigzag::encode_zig_zag_32;
+use crate::zigzag::encode_zig_zag_64;
+use crate::Message;
+use crate::ProtobufEnum;
+use crate::ProtobufError;
+use crate::ProtobufResult;
+use crate::UnknownFields;
+use crate::UnknownValueRef;
+
+/// 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;
+
+#[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 (dyn 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)
+}
+
+/// Output buffer/writer for `CodedOutputStream`.
+enum OutputTarget<'a> {
+ Write(&'a mut dyn Write, Vec<u8>),
+ Vec(&'a mut Vec<u8>),
+ /// The buffer is passed as `&[u8]` to `CodedOutputStream` constructor
+ /// and immediately converted to `buffer` field of `CodedOutputStream`,
+ /// it is not needed to be stored here.
+ /// Lifetime parameter of `CodedOutputStream` guarantees the buffer is valid
+ /// during the lifetime of `CodedOutputStream`.
+ Bytes,
+}
+
+/// Buffered write with handy utilities
+pub struct CodedOutputStream<'a> {
+ target: OutputTarget<'a>,
+ // Actual buffer is owned by `OutputTarget`,
+ // and here we alias the buffer so access to the buffer is branchless:
+ // access does not require switch by actual target type: `&[], `Vec`, `Write` etc.
+ // We don't access the actual buffer in `OutputTarget` except when
+ // we initialize `buffer` field here.
+ buffer: *mut [MaybeUninit<u8>],
+ // within buffer
+ position: usize,
+}
+
+impl<'a> CodedOutputStream<'a> {
+ /// Construct from given `Write`.
+ ///
+ /// `CodedOutputStream` is buffered even if `Write` is not
+ pub fn new(writer: &'a mut dyn Write) -> CodedOutputStream<'a> {
+ let buffer_len = OUTPUT_STREAM_BUFFER_SIZE;
+
+ let mut buffer_storage = Vec::with_capacity(buffer_len);
+
+ // SAFETY: we are not using the `buffer_storage`
+ // except for initializing the `buffer` field.
+ // See `buffer` field documentation.
+ let buffer = vec_spare_capacity_mut(&mut buffer_storage);
+ let buffer: *mut [MaybeUninit<u8>] = buffer;
+
+ CodedOutputStream {
+ target: OutputTarget::Write(writer, buffer_storage),
+ 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> {
+ // SAFETY: it is safe to cast from &mut [u8] to &mut [MaybeUninit<u8>].
+ let buffer =
+ ptr::slice_from_raw_parts_mut(bytes.as_mut_ptr() as *mut MaybeUninit<u8>, bytes.len());
+ CodedOutputStream {
+ target: OutputTarget::Bytes,
+ buffer,
+ 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> {
+ let buffer: *mut [MaybeUninit<u8>] = &mut [];
+ CodedOutputStream {
+ target: OutputTarget::Vec(vec),
+ buffer,
+ 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");
+ }
+ }
+ }
+
+ #[inline(always)]
+ fn buffer(&self) -> &[MaybeUninit<u8>] {
+ // SAFETY: see the `buffer` field documentation about invariants.
+ unsafe { &*(self.buffer as *mut [MaybeUninit<u8>]) }
+ }
+
+ #[inline(always)]
+ fn filled_buffer_impl<'s>(buffer: *mut [MaybeUninit<u8>], position: usize) -> &'s [u8] {
+ // SAFETY: this function is safe assuming `buffer` and `position`
+ // are `self.buffer` and `safe.position`:
+ // * `CodedOutputStream` has invariant that `position <= buffer.len()`.
+ // * `buffer` is filled up to `position`.
+ unsafe { slice::from_raw_parts_mut(buffer as *mut u8, position) }
+ }
+
+ fn refresh_buffer(&mut self) -> ProtobufResult<()> {
+ match self.target {
+ OutputTarget::Write(ref mut write, _) => {
+ write.write_all(Self::filled_buffer_impl(self.buffer, self.position))?;
+ 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 = vec_spare_capacity_mut(vec);
+ self.position = 0;
+ },
+ OutputTarget::Bytes => {
+ return Err(ProtobufError::IoError(io::Error::new(
+ io::ErrorKind::Other,
+ "given slice is too small to serialize the message",
+ )));
+ }
+ }
+ 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()?;
+ }
+ unsafe { maybe_uninit_write(&mut (&mut *self.buffer)[self.position as usize], byte) };
+ self.position += 1;
+ Ok(())
+ }
+
+ /// Write bytes
+ pub fn write_raw_bytes(&mut self, bytes: &[u8]) -> ProtobufResult<()> {
+ if bytes.len() <= self.buffer().len() - self.position {
+ let bottom = self.position as usize;
+ let top = bottom + (bytes.len() as usize);
+ // SAFETY: see the `buffer` field documentation about invariants.
+ let buffer = unsafe { &mut (&mut *self.buffer)[bottom..top] };
+ maybe_uninit_write_slice(buffer, bytes);
+ self.position += bytes.len();
+ return Ok(());
+ }
+
+ self.refresh_buffer()?;
+
+ assert!(self.position == 0);
+
+ if self.position + bytes.len() < self.buffer().len() {
+ // SAFETY: see the `buffer` field documentation about invariants.
+ let buffer =
+ unsafe { &mut (&mut *self.buffer)[self.position..self.position + bytes.len()] };
+ maybe_uninit_write_slice(buffer, bytes);
+ self.position += bytes.len();
+ return Ok(());
+ }
+
+ match self.target {
+ OutputTarget::Bytes => {
+ unreachable!();
+ }
+ OutputTarget::Write(ref mut write, _) => {
+ write.write_all(bytes)?;
+ }
+ OutputTarget::Vec(ref mut vec) => {
+ vec.extend(bytes);
+ self.buffer = vec_spare_capacity_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 = unsafe {
+ varint::encode_varint32(value, &mut (&mut *self.buffer)[self.position..])
+ };
+ self.position += len;
+ Ok(())
+ } else {
+ // slow path
+ let buf = &mut [0u8; 5];
+ let len = varint::encode_varint32(value, unsafe {
+ slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut MaybeUninit<u8>, buf.len())
+ });
+ self.write_raw_bytes(&buf[..len])
+ }
+ }
+
+ /// Write varint
+ pub fn write_raw_varint64(&mut self, value: u64) -> ProtobufResult<()> {
+ if self.buffer().len() - self.position >= 10 {
+ // fast path
+ let len = unsafe {
+ varint::encode_varint64(value, &mut (&mut *self.buffer)[self.position..])
+ };
+ self.position += len;
+ Ok(())
+ } else {
+ // slow path
+ let buf = &mut [0u8; 10];
+ let len = varint::encode_varint64(value, unsafe {
+ slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut MaybeUninit<u8>, buf.len())
+ });
+ 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::io::Write;
+ use std::iter;
+
+ use crate::coded_output_stream::CodedOutputStream;
+ use crate::hex::decode_hex;
+ use crate::hex::encode_hex;
+ use crate::wire_format;
+ use crate::ProtobufResult;
+
+ 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 = iter::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/2.27.1/src/compiler_plugin.rs b/2.27.1/src/compiler_plugin.rs
new file mode 100644
index 0000000..122eeb3
--- /dev/null
+++ b/2.27.1/src/compiler_plugin.rs
@@ -0,0 +1,53 @@
+// TODO: move into separate crate
+#![doc(hidden)]
+
+use std::io::stdin;
+use std::io::stdout;
+use std::str;
+
+use crate::descriptor::FileDescriptorProto;
+use crate::plugin::*;
+use crate::Message;
+
+pub struct GenRequest<'a> {
+ pub file_descriptors: &'a [FileDescriptorProto],
+ pub files_to_generate: &'a [String],
+ 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 = CodeGeneratorRequest::parse_from_reader(&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/2.27.1/src/descriptor.rs b/2.27.1/src/descriptor.rs
new file mode 100644
index 0000000..7ca155d
--- /dev/null
+++ b/2.27.1/src/descriptor.rs
@@ -0,0 +1,10858 @@
+// This file is generated by rust-protobuf 2.26.0. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(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(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `google/protobuf/descriptor.proto`
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct FileDescriptorSet {
+ // message fields
+ pub file: crate::RepeatedField<FileDescriptorProto>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a FileDescriptorSet {
+ fn default() -> &'a FileDescriptorSet {
+ <FileDescriptorSet as crate::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: crate::RepeatedField<FileDescriptorProto>) {
+ self.file = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_file(&mut self) -> &mut crate::RepeatedField<FileDescriptorProto> {
+ &mut self.file
+ }
+
+ // Take field
+ pub fn take_file(&mut self) -> crate::RepeatedField<FileDescriptorProto> {
+ ::std::mem::replace(&mut self.file, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.file)?;
+ },
+ _ => {
+ crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ for v in &self.file {
+ os.write_tag(1, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> FileDescriptorSet {
+ FileDescriptorSet::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<FileDescriptorProto>>(
+ "file",
+ |m: &FileDescriptorSet| { &m.file },
+ |m: &mut FileDescriptorSet| { &mut m.file },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<FileDescriptorSet>(
+ "FileDescriptorSet",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static FileDescriptorSet {
+ static instance: crate::rt::LazyV2<FileDescriptorSet> = crate::rt::LazyV2::INIT;
+ instance.get(FileDescriptorSet::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for FileDescriptorSet {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct FileDescriptorProto {
+ // message fields
+ name: crate::SingularField<::std::string::String>,
+ package: crate::SingularField<::std::string::String>,
+ pub dependency: crate::RepeatedField<::std::string::String>,
+ pub public_dependency: ::std::vec::Vec<i32>,
+ pub weak_dependency: ::std::vec::Vec<i32>,
+ pub message_type: crate::RepeatedField<DescriptorProto>,
+ pub enum_type: crate::RepeatedField<EnumDescriptorProto>,
+ pub service: crate::RepeatedField<ServiceDescriptorProto>,
+ pub extension: crate::RepeatedField<FieldDescriptorProto>,
+ pub options: crate::SingularPtrField<FileOptions>,
+ pub source_code_info: crate::SingularPtrField<SourceCodeInfo>,
+ syntax: crate::SingularField<::std::string::String>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a FileDescriptorProto {
+ fn default() -> &'a FileDescriptorProto {
+ <FileDescriptorProto as crate::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 = crate::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 = crate::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: crate::RepeatedField<::std::string::String>) {
+ self.dependency = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_dependency(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
+ &mut self.dependency
+ }
+
+ // Take field
+ pub fn take_dependency(&mut self) -> crate::RepeatedField<::std::string::String> {
+ ::std::mem::replace(&mut self.dependency, crate::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: crate::RepeatedField<DescriptorProto>) {
+ self.message_type = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_message_type(&mut self) -> &mut crate::RepeatedField<DescriptorProto> {
+ &mut self.message_type
+ }
+
+ // Take field
+ pub fn take_message_type(&mut self) -> crate::RepeatedField<DescriptorProto> {
+ ::std::mem::replace(&mut self.message_type, crate::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: crate::RepeatedField<EnumDescriptorProto>) {
+ self.enum_type = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_enum_type(&mut self) -> &mut crate::RepeatedField<EnumDescriptorProto> {
+ &mut self.enum_type
+ }
+
+ // Take field
+ pub fn take_enum_type(&mut self) -> crate::RepeatedField<EnumDescriptorProto> {
+ ::std::mem::replace(&mut self.enum_type, crate::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: crate::RepeatedField<ServiceDescriptorProto>) {
+ self.service = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_service(&mut self) -> &mut crate::RepeatedField<ServiceDescriptorProto> {
+ &mut self.service
+ }
+
+ // Take field
+ pub fn take_service(&mut self) -> crate::RepeatedField<ServiceDescriptorProto> {
+ ::std::mem::replace(&mut self.service, crate::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: crate::RepeatedField<FieldDescriptorProto>) {
+ self.extension = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_extension(&mut self) -> &mut crate::RepeatedField<FieldDescriptorProto> {
+ &mut self.extension
+ }
+
+ // Take field
+ pub fn take_extension(&mut self) -> crate::RepeatedField<FieldDescriptorProto> {
+ ::std::mem::replace(&mut self.extension, crate::RepeatedField::new())
+ }
+
+ // optional .google.protobuf.FileOptions options = 8;
+
+
+ pub fn get_options(&self) -> &FileOptions {
+ self.options.as_ref().unwrap_or_else(|| <FileOptions as crate::Message>::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 = crate::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 as crate::Message>::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 = crate::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 = crate::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 crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.package)?;
+ },
+ 3 => {
+ crate::rt::read_repeated_string_into(wire_type, is, &mut self.dependency)?;
+ },
+ 10 => {
+ crate::rt::read_repeated_int32_into(wire_type, is, &mut self.public_dependency)?;
+ },
+ 11 => {
+ crate::rt::read_repeated_int32_into(wire_type, is, &mut self.weak_dependency)?;
+ },
+ 4 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.message_type)?;
+ },
+ 5 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.enum_type)?;
+ },
+ 6 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.service)?;
+ },
+ 7 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.extension)?;
+ },
+ 8 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+ },
+ 9 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.source_code_info)?;
+ },
+ 12 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.syntax)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &v);
+ }
+ if let Some(ref v) = self.package.as_ref() {
+ my_size += crate::rt::string_size(2, &v);
+ }
+ for value in &self.dependency {
+ my_size += crate::rt::string_size(3, &value);
+ };
+ for value in &self.public_dependency {
+ my_size += crate::rt::value_size(10, *value, crate::wire_format::WireTypeVarint);
+ };
+ for value in &self.weak_dependency {
+ my_size += crate::rt::value_size(11, *value, crate::wire_format::WireTypeVarint);
+ };
+ for value in &self.message_type {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ for value in &self.enum_type {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ for value in &self.service {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ for value in &self.extension {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ if let Some(ref v) = self.options.as_ref() {
+ let len = v.compute_size();
+ my_size += 1 + crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ if let Some(ref v) = self.syntax.as_ref() {
+ my_size += crate::rt::string_size(12, &v);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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, crate::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, crate::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, crate::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, crate::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, crate::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, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> FileDescriptorProto {
+ FileDescriptorProto::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &FileDescriptorProto| { &m.name },
+ |m: &mut FileDescriptorProto| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "package",
+ |m: &FileDescriptorProto| { &m.package },
+ |m: &mut FileDescriptorProto| { &mut m.package },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "dependency",
+ |m: &FileDescriptorProto| { &m.dependency },
+ |m: &mut FileDescriptorProto| { &mut m.dependency },
+ ));
+ fields.push(crate::reflect::accessor::make_vec_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "public_dependency",
+ |m: &FileDescriptorProto| { &m.public_dependency },
+ |m: &mut FileDescriptorProto| { &mut m.public_dependency },
+ ));
+ fields.push(crate::reflect::accessor::make_vec_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "weak_dependency",
+ |m: &FileDescriptorProto| { &m.weak_dependency },
+ |m: &mut FileDescriptorProto| { &mut m.weak_dependency },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<DescriptorProto>>(
+ "message_type",
+ |m: &FileDescriptorProto| { &m.message_type },
+ |m: &mut FileDescriptorProto| { &mut m.message_type },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<EnumDescriptorProto>>(
+ "enum_type",
+ |m: &FileDescriptorProto| { &m.enum_type },
+ |m: &mut FileDescriptorProto| { &mut m.enum_type },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<ServiceDescriptorProto>>(
+ "service",
+ |m: &FileDescriptorProto| { &m.service },
+ |m: &mut FileDescriptorProto| { &mut m.service },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<FieldDescriptorProto>>(
+ "extension",
+ |m: &FileDescriptorProto| { &m.extension },
+ |m: &mut FileDescriptorProto| { &mut m.extension },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<FileOptions>>(
+ "options",
+ |m: &FileDescriptorProto| { &m.options },
+ |m: &mut FileDescriptorProto| { &mut m.options },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<SourceCodeInfo>>(
+ "source_code_info",
+ |m: &FileDescriptorProto| { &m.source_code_info },
+ |m: &mut FileDescriptorProto| { &mut m.source_code_info },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "syntax",
+ |m: &FileDescriptorProto| { &m.syntax },
+ |m: &mut FileDescriptorProto| { &mut m.syntax },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<FileDescriptorProto>(
+ "FileDescriptorProto",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static FileDescriptorProto {
+ static instance: crate::rt::LazyV2<FileDescriptorProto> = crate::rt::LazyV2::INIT;
+ instance.get(FileDescriptorProto::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for FileDescriptorProto {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct DescriptorProto {
+ // message fields
+ name: crate::SingularField<::std::string::String>,
+ pub field: crate::RepeatedField<FieldDescriptorProto>,
+ pub extension: crate::RepeatedField<FieldDescriptorProto>,
+ pub nested_type: crate::RepeatedField<DescriptorProto>,
+ pub enum_type: crate::RepeatedField<EnumDescriptorProto>,
+ pub extension_range: crate::RepeatedField<DescriptorProto_ExtensionRange>,
+ pub oneof_decl: crate::RepeatedField<OneofDescriptorProto>,
+ pub options: crate::SingularPtrField<MessageOptions>,
+ pub reserved_range: crate::RepeatedField<DescriptorProto_ReservedRange>,
+ pub reserved_name: crate::RepeatedField<::std::string::String>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a DescriptorProto {
+ fn default() -> &'a DescriptorProto {
+ <DescriptorProto as crate::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 = crate::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: crate::RepeatedField<FieldDescriptorProto>) {
+ self.field = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_field(&mut self) -> &mut crate::RepeatedField<FieldDescriptorProto> {
+ &mut self.field
+ }
+
+ // Take field
+ pub fn take_field(&mut self) -> crate::RepeatedField<FieldDescriptorProto> {
+ ::std::mem::replace(&mut self.field, crate::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: crate::RepeatedField<FieldDescriptorProto>) {
+ self.extension = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_extension(&mut self) -> &mut crate::RepeatedField<FieldDescriptorProto> {
+ &mut self.extension
+ }
+
+ // Take field
+ pub fn take_extension(&mut self) -> crate::RepeatedField<FieldDescriptorProto> {
+ ::std::mem::replace(&mut self.extension, crate::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: crate::RepeatedField<DescriptorProto>) {
+ self.nested_type = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_nested_type(&mut self) -> &mut crate::RepeatedField<DescriptorProto> {
+ &mut self.nested_type
+ }
+
+ // Take field
+ pub fn take_nested_type(&mut self) -> crate::RepeatedField<DescriptorProto> {
+ ::std::mem::replace(&mut self.nested_type, crate::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: crate::RepeatedField<EnumDescriptorProto>) {
+ self.enum_type = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_enum_type(&mut self) -> &mut crate::RepeatedField<EnumDescriptorProto> {
+ &mut self.enum_type
+ }
+
+ // Take field
+ pub fn take_enum_type(&mut self) -> crate::RepeatedField<EnumDescriptorProto> {
+ ::std::mem::replace(&mut self.enum_type, crate::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: crate::RepeatedField<DescriptorProto_ExtensionRange>) {
+ self.extension_range = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_extension_range(&mut self) -> &mut crate::RepeatedField<DescriptorProto_ExtensionRange> {
+ &mut self.extension_range
+ }
+
+ // Take field
+ pub fn take_extension_range(&mut self) -> crate::RepeatedField<DescriptorProto_ExtensionRange> {
+ ::std::mem::replace(&mut self.extension_range, crate::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: crate::RepeatedField<OneofDescriptorProto>) {
+ self.oneof_decl = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_oneof_decl(&mut self) -> &mut crate::RepeatedField<OneofDescriptorProto> {
+ &mut self.oneof_decl
+ }
+
+ // Take field
+ pub fn take_oneof_decl(&mut self) -> crate::RepeatedField<OneofDescriptorProto> {
+ ::std::mem::replace(&mut self.oneof_decl, crate::RepeatedField::new())
+ }
+
+ // optional .google.protobuf.MessageOptions options = 7;
+
+
+ pub fn get_options(&self) -> &MessageOptions {
+ self.options.as_ref().unwrap_or_else(|| <MessageOptions as crate::Message>::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 = crate::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: crate::RepeatedField<DescriptorProto_ReservedRange>) {
+ self.reserved_range = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_reserved_range(&mut self) -> &mut crate::RepeatedField<DescriptorProto_ReservedRange> {
+ &mut self.reserved_range
+ }
+
+ // Take field
+ pub fn take_reserved_range(&mut self) -> crate::RepeatedField<DescriptorProto_ReservedRange> {
+ ::std::mem::replace(&mut self.reserved_range, crate::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: crate::RepeatedField<::std::string::String>) {
+ self.reserved_name = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_reserved_name(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
+ &mut self.reserved_name
+ }
+
+ // Take field
+ pub fn take_reserved_name(&mut self) -> crate::RepeatedField<::std::string::String> {
+ ::std::mem::replace(&mut self.reserved_name, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.field)?;
+ },
+ 6 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.extension)?;
+ },
+ 3 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.nested_type)?;
+ },
+ 4 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.enum_type)?;
+ },
+ 5 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.extension_range)?;
+ },
+ 8 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.oneof_decl)?;
+ },
+ 7 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+ },
+ 9 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.reserved_range)?;
+ },
+ 10 => {
+ crate::rt::read_repeated_string_into(wire_type, is, &mut self.reserved_name)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &v);
+ }
+ for value in &self.field {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ for value in &self.extension {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ for value in &self.nested_type {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ for value in &self.enum_type {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ for value in &self.extension_range {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ for value in &self.oneof_decl {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ if let Some(ref v) = self.options.as_ref() {
+ let len = v.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ for value in &self.reserved_range {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ for value in &self.reserved_name {
+ my_size += crate::rt::string_size(10, &value);
+ };
+ my_size += crate::rt::unknown_fields_size(self.get_unknown_fields());
+ self.cached_size.set(my_size);
+ my_size
+ }
+
+ fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if let Some(ref v) = self.name.as_ref() {
+ os.write_string(1, &v)?;
+ }
+ for v in &self.field {
+ os.write_tag(2, crate::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, crate::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, crate::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, crate::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, crate::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, crate::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, crate::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, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> DescriptorProto {
+ DescriptorProto::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &DescriptorProto| { &m.name },
+ |m: &mut DescriptorProto| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<FieldDescriptorProto>>(
+ "field",
+ |m: &DescriptorProto| { &m.field },
+ |m: &mut DescriptorProto| { &mut m.field },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<FieldDescriptorProto>>(
+ "extension",
+ |m: &DescriptorProto| { &m.extension },
+ |m: &mut DescriptorProto| { &mut m.extension },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<DescriptorProto>>(
+ "nested_type",
+ |m: &DescriptorProto| { &m.nested_type },
+ |m: &mut DescriptorProto| { &mut m.nested_type },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<EnumDescriptorProto>>(
+ "enum_type",
+ |m: &DescriptorProto| { &m.enum_type },
+ |m: &mut DescriptorProto| { &mut m.enum_type },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<DescriptorProto_ExtensionRange>>(
+ "extension_range",
+ |m: &DescriptorProto| { &m.extension_range },
+ |m: &mut DescriptorProto| { &mut m.extension_range },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<OneofDescriptorProto>>(
+ "oneof_decl",
+ |m: &DescriptorProto| { &m.oneof_decl },
+ |m: &mut DescriptorProto| { &mut m.oneof_decl },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<MessageOptions>>(
+ "options",
+ |m: &DescriptorProto| { &m.options },
+ |m: &mut DescriptorProto| { &mut m.options },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<DescriptorProto_ReservedRange>>(
+ "reserved_range",
+ |m: &DescriptorProto| { &m.reserved_range },
+ |m: &mut DescriptorProto| { &mut m.reserved_range },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "reserved_name",
+ |m: &DescriptorProto| { &m.reserved_name },
+ |m: &mut DescriptorProto| { &mut m.reserved_name },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<DescriptorProto>(
+ "DescriptorProto",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static DescriptorProto {
+ static instance: crate::rt::LazyV2<DescriptorProto> = crate::rt::LazyV2::INIT;
+ instance.get(DescriptorProto::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for DescriptorProto {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct DescriptorProto_ExtensionRange {
+ // message fields
+ start: ::std::option::Option<i32>,
+ end: ::std::option::Option<i32>,
+ pub options: crate::SingularPtrField<ExtensionRangeOptions>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a DescriptorProto_ExtensionRange {
+ fn default() -> &'a DescriptorProto_ExtensionRange {
+ <DescriptorProto_ExtensionRange as crate::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);
+ }
+
+ // optional .google.protobuf.ExtensionRangeOptions options = 3;
+
+
+ pub fn get_options(&self) -> &ExtensionRangeOptions {
+ self.options.as_ref().unwrap_or_else(|| <ExtensionRangeOptions as crate::Message>::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: ExtensionRangeOptions) {
+ self.options = crate::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 ExtensionRangeOptions {
+ if self.options.is_none() {
+ self.options.set_default();
+ }
+ self.options.as_mut().unwrap()
+ }
+
+ // Take field
+ pub fn take_options(&mut self) -> ExtensionRangeOptions {
+ self.options.take().unwrap_or_else(|| ExtensionRangeOptions::new())
+ }
+}
+
+impl crate::Message for DescriptorProto_ExtensionRange {
+ fn is_initialized(&self) -> bool {
+ for v in &self.options {
+ if !v.is_initialized() {
+ return false;
+ }
+ };
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.start = ::std::option::Option::Some(tmp);
+ },
+ 2 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.end = ::std::option::Option::Some(tmp);
+ },
+ 3 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+ },
+ _ => {
+ crate::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 += crate::rt::value_size(1, v, crate::wire_format::WireTypeVarint);
+ }
+ if let Some(v) = self.end {
+ my_size += crate::rt::value_size(2, v, crate::wire_format::WireTypeVarint);
+ }
+ if let Some(ref v) = self.options.as_ref() {
+ let len = v.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if let Some(v) = self.start {
+ os.write_int32(1, v)?;
+ }
+ if let Some(v) = self.end {
+ os.write_int32(2, v)?;
+ }
+ if let Some(ref v) = self.options.as_ref() {
+ os.write_tag(3, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> DescriptorProto_ExtensionRange {
+ DescriptorProto_ExtensionRange::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "start",
+ |m: &DescriptorProto_ExtensionRange| { &m.start },
+ |m: &mut DescriptorProto_ExtensionRange| { &mut m.start },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "end",
+ |m: &DescriptorProto_ExtensionRange| { &m.end },
+ |m: &mut DescriptorProto_ExtensionRange| { &mut m.end },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<ExtensionRangeOptions>>(
+ "options",
+ |m: &DescriptorProto_ExtensionRange| { &m.options },
+ |m: &mut DescriptorProto_ExtensionRange| { &mut m.options },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<DescriptorProto_ExtensionRange>(
+ "DescriptorProto.ExtensionRange",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static DescriptorProto_ExtensionRange {
+ static instance: crate::rt::LazyV2<DescriptorProto_ExtensionRange> = crate::rt::LazyV2::INIT;
+ instance.get(DescriptorProto_ExtensionRange::new)
+ }
+}
+
+impl crate::Clear for DescriptorProto_ExtensionRange {
+ fn clear(&mut self) {
+ self.start = ::std::option::Option::None;
+ self.end = ::std::option::Option::None;
+ self.options.clear();
+ self.unknown_fields.clear();
+ }
+}
+
+impl ::std::fmt::Debug for DescriptorProto_ExtensionRange {
+ fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for DescriptorProto_ExtensionRange {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::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: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a DescriptorProto_ReservedRange {
+ fn default() -> &'a DescriptorProto_ReservedRange {
+ <DescriptorProto_ReservedRange as crate::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 crate::Message for DescriptorProto_ReservedRange {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.start = ::std::option::Option::Some(tmp);
+ },
+ 2 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.end = ::std::option::Option::Some(tmp);
+ },
+ _ => {
+ crate::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 += crate::rt::value_size(1, v, crate::wire_format::WireTypeVarint);
+ }
+ if let Some(v) = self.end {
+ my_size += crate::rt::value_size(2, v, crate::wire_format::WireTypeVarint);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> DescriptorProto_ReservedRange {
+ DescriptorProto_ReservedRange::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "start",
+ |m: &DescriptorProto_ReservedRange| { &m.start },
+ |m: &mut DescriptorProto_ReservedRange| { &mut m.start },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "end",
+ |m: &DescriptorProto_ReservedRange| { &m.end },
+ |m: &mut DescriptorProto_ReservedRange| { &mut m.end },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<DescriptorProto_ReservedRange>(
+ "DescriptorProto.ReservedRange",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static DescriptorProto_ReservedRange {
+ static instance: crate::rt::LazyV2<DescriptorProto_ReservedRange> = crate::rt::LazyV2::INIT;
+ instance.get(DescriptorProto_ReservedRange::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for DescriptorProto_ReservedRange {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct ExtensionRangeOptions {
+ // message fields
+ pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a ExtensionRangeOptions {
+ fn default() -> &'a ExtensionRangeOptions {
+ <ExtensionRangeOptions as crate::Message>::default_instance()
+ }
+}
+
+impl ExtensionRangeOptions {
+ pub fn new() -> ExtensionRangeOptions {
+ ::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: crate::RepeatedField<UninterpretedOption>) {
+ self.uninterpreted_option = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
+ &mut self.uninterpreted_option
+ }
+
+ // Take field
+ pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+ ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
+ }
+}
+
+impl crate::Message for ExtensionRangeOptions {
+ fn is_initialized(&self) -> bool {
+ for v in &self.uninterpreted_option {
+ if !v.is_initialized() {
+ return false;
+ }
+ };
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 999 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+ },
+ _ => {
+ crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ for v in &self.uninterpreted_option {
+ os.write_tag(999, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> ExtensionRangeOptions {
+ ExtensionRangeOptions::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
+ "uninterpreted_option",
+ |m: &ExtensionRangeOptions| { &m.uninterpreted_option },
+ |m: &mut ExtensionRangeOptions| { &mut m.uninterpreted_option },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<ExtensionRangeOptions>(
+ "ExtensionRangeOptions",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static ExtensionRangeOptions {
+ static instance: crate::rt::LazyV2<ExtensionRangeOptions> = crate::rt::LazyV2::INIT;
+ instance.get(ExtensionRangeOptions::new)
+ }
+}
+
+impl crate::Clear for ExtensionRangeOptions {
+ fn clear(&mut self) {
+ self.uninterpreted_option.clear();
+ self.unknown_fields.clear();
+ }
+}
+
+impl ::std::fmt::Debug for ExtensionRangeOptions {
+ fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for ExtensionRangeOptions {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct FieldDescriptorProto {
+ // message fields
+ name: crate::SingularField<::std::string::String>,
+ number: ::std::option::Option<i32>,
+ label: ::std::option::Option<FieldDescriptorProto_Label>,
+ field_type: ::std::option::Option<FieldDescriptorProto_Type>,
+ type_name: crate::SingularField<::std::string::String>,
+ extendee: crate::SingularField<::std::string::String>,
+ default_value: crate::SingularField<::std::string::String>,
+ oneof_index: ::std::option::Option<i32>,
+ json_name: crate::SingularField<::std::string::String>,
+ pub options: crate::SingularPtrField<FieldOptions>,
+ proto3_optional: ::std::option::Option<bool>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a FieldDescriptorProto {
+ fn default() -> &'a FieldDescriptorProto {
+ <FieldDescriptorProto as crate::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 = crate::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 = crate::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 = crate::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 = crate::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 = crate::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 as crate::Message>::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 = crate::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())
+ }
+
+ // optional bool proto3_optional = 17;
+
+
+ pub fn get_proto3_optional(&self) -> bool {
+ self.proto3_optional.unwrap_or(false)
+ }
+ pub fn clear_proto3_optional(&mut self) {
+ self.proto3_optional = ::std::option::Option::None;
+ }
+
+ pub fn has_proto3_optional(&self) -> bool {
+ self.proto3_optional.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_proto3_optional(&mut self, v: bool) {
+ self.proto3_optional = ::std::option::Option::Some(v);
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+ },
+ 3 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.number = ::std::option::Option::Some(tmp);
+ },
+ 4 => {
+ crate::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.label, 4, &mut self.unknown_fields)?
+ },
+ 5 => {
+ crate::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 5, &mut self.unknown_fields)?
+ },
+ 6 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.type_name)?;
+ },
+ 2 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.extendee)?;
+ },
+ 7 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.default_value)?;
+ },
+ 9 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.oneof_index = ::std::option::Option::Some(tmp);
+ },
+ 10 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.json_name)?;
+ },
+ 8 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+ },
+ 17 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.proto3_optional = ::std::option::Option::Some(tmp);
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &v);
+ }
+ if let Some(v) = self.number {
+ my_size += crate::rt::value_size(3, v, crate::wire_format::WireTypeVarint);
+ }
+ if let Some(v) = self.label {
+ my_size += crate::rt::enum_size(4, v);
+ }
+ if let Some(v) = self.field_type {
+ my_size += crate::rt::enum_size(5, v);
+ }
+ if let Some(ref v) = self.type_name.as_ref() {
+ my_size += crate::rt::string_size(6, &v);
+ }
+ if let Some(ref v) = self.extendee.as_ref() {
+ my_size += crate::rt::string_size(2, &v);
+ }
+ if let Some(ref v) = self.default_value.as_ref() {
+ my_size += crate::rt::string_size(7, &v);
+ }
+ if let Some(v) = self.oneof_index {
+ my_size += crate::rt::value_size(9, v, crate::wire_format::WireTypeVarint);
+ }
+ if let Some(ref v) = self.json_name.as_ref() {
+ my_size += crate::rt::string_size(10, &v);
+ }
+ if let Some(ref v) = self.options.as_ref() {
+ let len = v.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ if let Some(v) = self.proto3_optional {
+ my_size += 3;
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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, crate::ProtobufEnum::value(&v))?;
+ }
+ if let Some(v) = self.field_type {
+ os.write_enum(5, crate::ProtobufEnum::value(&v))?;
+ }
+ 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, crate::wire_format::WireTypeLengthDelimited)?;
+ os.write_raw_varint32(v.get_cached_size())?;
+ v.write_to_with_cached_sizes(os)?;
+ }
+ if let Some(v) = self.proto3_optional {
+ os.write_bool(17, 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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> FieldDescriptorProto {
+ FieldDescriptorProto::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &FieldDescriptorProto| { &m.name },
+ |m: &mut FieldDescriptorProto| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "number",
+ |m: &FieldDescriptorProto| { &m.number },
+ |m: &mut FieldDescriptorProto| { &mut m.number },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeEnum<FieldDescriptorProto_Label>>(
+ "label",
+ |m: &FieldDescriptorProto| { &m.label },
+ |m: &mut FieldDescriptorProto| { &mut m.label },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeEnum<FieldDescriptorProto_Type>>(
+ "type",
+ |m: &FieldDescriptorProto| { &m.field_type },
+ |m: &mut FieldDescriptorProto| { &mut m.field_type },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "type_name",
+ |m: &FieldDescriptorProto| { &m.type_name },
+ |m: &mut FieldDescriptorProto| { &mut m.type_name },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "extendee",
+ |m: &FieldDescriptorProto| { &m.extendee },
+ |m: &mut FieldDescriptorProto| { &mut m.extendee },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "default_value",
+ |m: &FieldDescriptorProto| { &m.default_value },
+ |m: &mut FieldDescriptorProto| { &mut m.default_value },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "oneof_index",
+ |m: &FieldDescriptorProto| { &m.oneof_index },
+ |m: &mut FieldDescriptorProto| { &mut m.oneof_index },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "json_name",
+ |m: &FieldDescriptorProto| { &m.json_name },
+ |m: &mut FieldDescriptorProto| { &mut m.json_name },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<FieldOptions>>(
+ "options",
+ |m: &FieldDescriptorProto| { &m.options },
+ |m: &mut FieldDescriptorProto| { &mut m.options },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "proto3_optional",
+ |m: &FieldDescriptorProto| { &m.proto3_optional },
+ |m: &mut FieldDescriptorProto| { &mut m.proto3_optional },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<FieldDescriptorProto>(
+ "FieldDescriptorProto",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static FieldDescriptorProto {
+ static instance: crate::rt::LazyV2<FieldDescriptorProto> = crate::rt::LazyV2::INIT;
+ instance.get(FieldDescriptorProto::new)
+ }
+}
+
+impl crate::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.proto3_optional = ::std::option::Option::None;
+ self.unknown_fields.clear();
+ }
+}
+
+impl ::std::fmt::Debug for FieldDescriptorProto {
+ fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for FieldDescriptorProto {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::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 crate::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 crate::reflect::EnumDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ crate::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 crate::reflect::ProtobufValue for FieldDescriptorProto_Type {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
+ }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub enum FieldDescriptorProto_Label {
+ LABEL_OPTIONAL = 1,
+ LABEL_REQUIRED = 2,
+ LABEL_REPEATED = 3,
+}
+
+impl crate::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 crate::reflect::EnumDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ crate::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 crate::reflect::ProtobufValue for FieldDescriptorProto_Label {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct OneofDescriptorProto {
+ // message fields
+ name: crate::SingularField<::std::string::String>,
+ pub options: crate::SingularPtrField<OneofOptions>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a OneofDescriptorProto {
+ fn default() -> &'a OneofDescriptorProto {
+ <OneofDescriptorProto as crate::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 = crate::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 as crate::Message>::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 = crate::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 crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &v);
+ }
+ if let Some(ref v) = self.options.as_ref() {
+ let len = v.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> OneofDescriptorProto {
+ OneofDescriptorProto::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &OneofDescriptorProto| { &m.name },
+ |m: &mut OneofDescriptorProto| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<OneofOptions>>(
+ "options",
+ |m: &OneofDescriptorProto| { &m.options },
+ |m: &mut OneofDescriptorProto| { &mut m.options },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<OneofDescriptorProto>(
+ "OneofDescriptorProto",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static OneofDescriptorProto {
+ static instance: crate::rt::LazyV2<OneofDescriptorProto> = crate::rt::LazyV2::INIT;
+ instance.get(OneofDescriptorProto::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for OneofDescriptorProto {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct EnumDescriptorProto {
+ // message fields
+ name: crate::SingularField<::std::string::String>,
+ pub value: crate::RepeatedField<EnumValueDescriptorProto>,
+ pub options: crate::SingularPtrField<EnumOptions>,
+ pub reserved_range: crate::RepeatedField<EnumDescriptorProto_EnumReservedRange>,
+ pub reserved_name: crate::RepeatedField<::std::string::String>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a EnumDescriptorProto {
+ fn default() -> &'a EnumDescriptorProto {
+ <EnumDescriptorProto as crate::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 = crate::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: crate::RepeatedField<EnumValueDescriptorProto>) {
+ self.value = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_value(&mut self) -> &mut crate::RepeatedField<EnumValueDescriptorProto> {
+ &mut self.value
+ }
+
+ // Take field
+ pub fn take_value(&mut self) -> crate::RepeatedField<EnumValueDescriptorProto> {
+ ::std::mem::replace(&mut self.value, crate::RepeatedField::new())
+ }
+
+ // optional .google.protobuf.EnumOptions options = 3;
+
+
+ pub fn get_options(&self) -> &EnumOptions {
+ self.options.as_ref().unwrap_or_else(|| <EnumOptions as crate::Message>::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 = crate::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())
+ }
+
+ // repeated .google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4;
+
+
+ pub fn get_reserved_range(&self) -> &[EnumDescriptorProto_EnumReservedRange] {
+ &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: crate::RepeatedField<EnumDescriptorProto_EnumReservedRange>) {
+ self.reserved_range = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_reserved_range(&mut self) -> &mut crate::RepeatedField<EnumDescriptorProto_EnumReservedRange> {
+ &mut self.reserved_range
+ }
+
+ // Take field
+ pub fn take_reserved_range(&mut self) -> crate::RepeatedField<EnumDescriptorProto_EnumReservedRange> {
+ ::std::mem::replace(&mut self.reserved_range, crate::RepeatedField::new())
+ }
+
+ // repeated string reserved_name = 5;
+
+
+ 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: crate::RepeatedField<::std::string::String>) {
+ self.reserved_name = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_reserved_name(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
+ &mut self.reserved_name
+ }
+
+ // Take field
+ pub fn take_reserved_name(&mut self) -> crate::RepeatedField<::std::string::String> {
+ ::std::mem::replace(&mut self.reserved_name, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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;
+ }
+ };
+ for v in &self.reserved_range {
+ if !v.is_initialized() {
+ return false;
+ }
+ };
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.value)?;
+ },
+ 3 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+ },
+ 4 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.reserved_range)?;
+ },
+ 5 => {
+ crate::rt::read_repeated_string_into(wire_type, is, &mut self.reserved_name)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &v);
+ }
+ for value in &self.value {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ if let Some(ref v) = self.options.as_ref() {
+ let len = v.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ for value in &self.reserved_range {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ for value in &self.reserved_name {
+ my_size += crate::rt::string_size(5, &value);
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if let Some(ref v) = self.name.as_ref() {
+ os.write_string(1, &v)?;
+ }
+ for v in &self.value {
+ os.write_tag(2, crate::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, crate::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(4, crate::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(5, &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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> EnumDescriptorProto {
+ EnumDescriptorProto::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &EnumDescriptorProto| { &m.name },
+ |m: &mut EnumDescriptorProto| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<EnumValueDescriptorProto>>(
+ "value",
+ |m: &EnumDescriptorProto| { &m.value },
+ |m: &mut EnumDescriptorProto| { &mut m.value },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<EnumOptions>>(
+ "options",
+ |m: &EnumDescriptorProto| { &m.options },
+ |m: &mut EnumDescriptorProto| { &mut m.options },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<EnumDescriptorProto_EnumReservedRange>>(
+ "reserved_range",
+ |m: &EnumDescriptorProto| { &m.reserved_range },
+ |m: &mut EnumDescriptorProto| { &mut m.reserved_range },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "reserved_name",
+ |m: &EnumDescriptorProto| { &m.reserved_name },
+ |m: &mut EnumDescriptorProto| { &mut m.reserved_name },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<EnumDescriptorProto>(
+ "EnumDescriptorProto",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static EnumDescriptorProto {
+ static instance: crate::rt::LazyV2<EnumDescriptorProto> = crate::rt::LazyV2::INIT;
+ instance.get(EnumDescriptorProto::new)
+ }
+}
+
+impl crate::Clear for EnumDescriptorProto {
+ fn clear(&mut self) {
+ self.name.clear();
+ self.value.clear();
+ self.options.clear();
+ self.reserved_range.clear();
+ self.reserved_name.clear();
+ self.unknown_fields.clear();
+ }
+}
+
+impl ::std::fmt::Debug for EnumDescriptorProto {
+ fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for EnumDescriptorProto {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct EnumDescriptorProto_EnumReservedRange {
+ // message fields
+ start: ::std::option::Option<i32>,
+ end: ::std::option::Option<i32>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a EnumDescriptorProto_EnumReservedRange {
+ fn default() -> &'a EnumDescriptorProto_EnumReservedRange {
+ <EnumDescriptorProto_EnumReservedRange as crate::Message>::default_instance()
+ }
+}
+
+impl EnumDescriptorProto_EnumReservedRange {
+ pub fn new() -> EnumDescriptorProto_EnumReservedRange {
+ ::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 crate::Message for EnumDescriptorProto_EnumReservedRange {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.start = ::std::option::Option::Some(tmp);
+ },
+ 2 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.end = ::std::option::Option::Some(tmp);
+ },
+ _ => {
+ crate::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 += crate::rt::value_size(1, v, crate::wire_format::WireTypeVarint);
+ }
+ if let Some(v) = self.end {
+ my_size += crate::rt::value_size(2, v, crate::wire_format::WireTypeVarint);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> EnumDescriptorProto_EnumReservedRange {
+ EnumDescriptorProto_EnumReservedRange::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "start",
+ |m: &EnumDescriptorProto_EnumReservedRange| { &m.start },
+ |m: &mut EnumDescriptorProto_EnumReservedRange| { &mut m.start },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "end",
+ |m: &EnumDescriptorProto_EnumReservedRange| { &m.end },
+ |m: &mut EnumDescriptorProto_EnumReservedRange| { &mut m.end },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<EnumDescriptorProto_EnumReservedRange>(
+ "EnumDescriptorProto.EnumReservedRange",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static EnumDescriptorProto_EnumReservedRange {
+ static instance: crate::rt::LazyV2<EnumDescriptorProto_EnumReservedRange> = crate::rt::LazyV2::INIT;
+ instance.get(EnumDescriptorProto_EnumReservedRange::new)
+ }
+}
+
+impl crate::Clear for EnumDescriptorProto_EnumReservedRange {
+ 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 EnumDescriptorProto_EnumReservedRange {
+ fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for EnumDescriptorProto_EnumReservedRange {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct EnumValueDescriptorProto {
+ // message fields
+ name: crate::SingularField<::std::string::String>,
+ number: ::std::option::Option<i32>,
+ pub options: crate::SingularPtrField<EnumValueOptions>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a EnumValueDescriptorProto {
+ fn default() -> &'a EnumValueDescriptorProto {
+ <EnumValueDescriptorProto as crate::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 = crate::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 as crate::Message>::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 = crate::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 crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.number = ::std::option::Option::Some(tmp);
+ },
+ 3 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &v);
+ }
+ if let Some(v) = self.number {
+ my_size += crate::rt::value_size(2, v, crate::wire_format::WireTypeVarint);
+ }
+ if let Some(ref v) = self.options.as_ref() {
+ let len = v.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> EnumValueDescriptorProto {
+ EnumValueDescriptorProto::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &EnumValueDescriptorProto| { &m.name },
+ |m: &mut EnumValueDescriptorProto| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "number",
+ |m: &EnumValueDescriptorProto| { &m.number },
+ |m: &mut EnumValueDescriptorProto| { &mut m.number },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<EnumValueOptions>>(
+ "options",
+ |m: &EnumValueDescriptorProto| { &m.options },
+ |m: &mut EnumValueDescriptorProto| { &mut m.options },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<EnumValueDescriptorProto>(
+ "EnumValueDescriptorProto",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static EnumValueDescriptorProto {
+ static instance: crate::rt::LazyV2<EnumValueDescriptorProto> = crate::rt::LazyV2::INIT;
+ instance.get(EnumValueDescriptorProto::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for EnumValueDescriptorProto {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct ServiceDescriptorProto {
+ // message fields
+ name: crate::SingularField<::std::string::String>,
+ pub method: crate::RepeatedField<MethodDescriptorProto>,
+ pub options: crate::SingularPtrField<ServiceOptions>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a ServiceDescriptorProto {
+ fn default() -> &'a ServiceDescriptorProto {
+ <ServiceDescriptorProto as crate::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 = crate::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: crate::RepeatedField<MethodDescriptorProto>) {
+ self.method = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_method(&mut self) -> &mut crate::RepeatedField<MethodDescriptorProto> {
+ &mut self.method
+ }
+
+ // Take field
+ pub fn take_method(&mut self) -> crate::RepeatedField<MethodDescriptorProto> {
+ ::std::mem::replace(&mut self.method, crate::RepeatedField::new())
+ }
+
+ // optional .google.protobuf.ServiceOptions options = 3;
+
+
+ pub fn get_options(&self) -> &ServiceOptions {
+ self.options.as_ref().unwrap_or_else(|| <ServiceOptions as crate::Message>::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 = crate::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 crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.method)?;
+ },
+ 3 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &v);
+ }
+ for value in &self.method {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ if let Some(ref v) = self.options.as_ref() {
+ let len = v.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if let Some(ref v) = self.name.as_ref() {
+ os.write_string(1, &v)?;
+ }
+ for v in &self.method {
+ os.write_tag(2, crate::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, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> ServiceDescriptorProto {
+ ServiceDescriptorProto::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &ServiceDescriptorProto| { &m.name },
+ |m: &mut ServiceDescriptorProto| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<MethodDescriptorProto>>(
+ "method",
+ |m: &ServiceDescriptorProto| { &m.method },
+ |m: &mut ServiceDescriptorProto| { &mut m.method },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<ServiceOptions>>(
+ "options",
+ |m: &ServiceDescriptorProto| { &m.options },
+ |m: &mut ServiceDescriptorProto| { &mut m.options },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<ServiceDescriptorProto>(
+ "ServiceDescriptorProto",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static ServiceDescriptorProto {
+ static instance: crate::rt::LazyV2<ServiceDescriptorProto> = crate::rt::LazyV2::INIT;
+ instance.get(ServiceDescriptorProto::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for ServiceDescriptorProto {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct MethodDescriptorProto {
+ // message fields
+ name: crate::SingularField<::std::string::String>,
+ input_type: crate::SingularField<::std::string::String>,
+ output_type: crate::SingularField<::std::string::String>,
+ pub options: crate::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: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a MethodDescriptorProto {
+ fn default() -> &'a MethodDescriptorProto {
+ <MethodDescriptorProto as crate::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 = crate::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 = crate::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 = crate::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 as crate::Message>::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 = crate::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 crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.input_type)?;
+ },
+ 3 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.output_type)?;
+ },
+ 4 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+ },
+ 5 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.client_streaming = ::std::option::Option::Some(tmp);
+ },
+ 6 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.server_streaming = ::std::option::Option::Some(tmp);
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &v);
+ }
+ if let Some(ref v) = self.input_type.as_ref() {
+ my_size += crate::rt::string_size(2, &v);
+ }
+ if let Some(ref v) = self.output_type.as_ref() {
+ my_size += crate::rt::string_size(3, &v);
+ }
+ if let Some(ref v) = self.options.as_ref() {
+ let len = v.compute_size();
+ my_size += 1 + crate::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 += crate::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 crate::CodedOutputStream<'_>) -> crate::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, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> MethodDescriptorProto {
+ MethodDescriptorProto::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &MethodDescriptorProto| { &m.name },
+ |m: &mut MethodDescriptorProto| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "input_type",
+ |m: &MethodDescriptorProto| { &m.input_type },
+ |m: &mut MethodDescriptorProto| { &mut m.input_type },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "output_type",
+ |m: &MethodDescriptorProto| { &m.output_type },
+ |m: &mut MethodDescriptorProto| { &mut m.output_type },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<MethodOptions>>(
+ "options",
+ |m: &MethodDescriptorProto| { &m.options },
+ |m: &mut MethodDescriptorProto| { &mut m.options },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "client_streaming",
+ |m: &MethodDescriptorProto| { &m.client_streaming },
+ |m: &mut MethodDescriptorProto| { &mut m.client_streaming },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "server_streaming",
+ |m: &MethodDescriptorProto| { &m.server_streaming },
+ |m: &mut MethodDescriptorProto| { &mut m.server_streaming },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<MethodDescriptorProto>(
+ "MethodDescriptorProto",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static MethodDescriptorProto {
+ static instance: crate::rt::LazyV2<MethodDescriptorProto> = crate::rt::LazyV2::INIT;
+ instance.get(MethodDescriptorProto::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for MethodDescriptorProto {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct FileOptions {
+ // message fields
+ java_package: crate::SingularField<::std::string::String>,
+ java_outer_classname: crate::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: crate::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>,
+ php_generic_services: ::std::option::Option<bool>,
+ deprecated: ::std::option::Option<bool>,
+ cc_enable_arenas: ::std::option::Option<bool>,
+ objc_class_prefix: crate::SingularField<::std::string::String>,
+ csharp_namespace: crate::SingularField<::std::string::String>,
+ swift_prefix: crate::SingularField<::std::string::String>,
+ php_class_prefix: crate::SingularField<::std::string::String>,
+ php_namespace: crate::SingularField<::std::string::String>,
+ php_metadata_namespace: crate::SingularField<::std::string::String>,
+ ruby_package: crate::SingularField<::std::string::String>,
+ pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a FileOptions {
+ fn default() -> &'a FileOptions {
+ <FileOptions as crate::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 = crate::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 = crate::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 = crate::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 php_generic_services = 42;
+
+
+ pub fn get_php_generic_services(&self) -> bool {
+ self.php_generic_services.unwrap_or(false)
+ }
+ pub fn clear_php_generic_services(&mut self) {
+ self.php_generic_services = ::std::option::Option::None;
+ }
+
+ pub fn has_php_generic_services(&self) -> bool {
+ self.php_generic_services.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_php_generic_services(&mut self, v: bool) {
+ self.php_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(true)
+ }
+ 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 = crate::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 = crate::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())
+ }
+
+ // optional string swift_prefix = 39;
+
+
+ pub fn get_swift_prefix(&self) -> &str {
+ match self.swift_prefix.as_ref() {
+ Some(v) => &v,
+ None => "",
+ }
+ }
+ pub fn clear_swift_prefix(&mut self) {
+ self.swift_prefix.clear();
+ }
+
+ pub fn has_swift_prefix(&self) -> bool {
+ self.swift_prefix.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_swift_prefix(&mut self, v: ::std::string::String) {
+ self.swift_prefix = crate::SingularField::some(v);
+ }
+
+ // Mutable pointer to the field.
+ // If field is not initialized, it is initialized with default value first.
+ pub fn mut_swift_prefix(&mut self) -> &mut ::std::string::String {
+ if self.swift_prefix.is_none() {
+ self.swift_prefix.set_default();
+ }
+ self.swift_prefix.as_mut().unwrap()
+ }
+
+ // Take field
+ pub fn take_swift_prefix(&mut self) -> ::std::string::String {
+ self.swift_prefix.take().unwrap_or_else(|| ::std::string::String::new())
+ }
+
+ // optional string php_class_prefix = 40;
+
+
+ pub fn get_php_class_prefix(&self) -> &str {
+ match self.php_class_prefix.as_ref() {
+ Some(v) => &v,
+ None => "",
+ }
+ }
+ pub fn clear_php_class_prefix(&mut self) {
+ self.php_class_prefix.clear();
+ }
+
+ pub fn has_php_class_prefix(&self) -> bool {
+ self.php_class_prefix.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_php_class_prefix(&mut self, v: ::std::string::String) {
+ self.php_class_prefix = crate::SingularField::some(v);
+ }
+
+ // Mutable pointer to the field.
+ // If field is not initialized, it is initialized with default value first.
+ pub fn mut_php_class_prefix(&mut self) -> &mut ::std::string::String {
+ if self.php_class_prefix.is_none() {
+ self.php_class_prefix.set_default();
+ }
+ self.php_class_prefix.as_mut().unwrap()
+ }
+
+ // Take field
+ pub fn take_php_class_prefix(&mut self) -> ::std::string::String {
+ self.php_class_prefix.take().unwrap_or_else(|| ::std::string::String::new())
+ }
+
+ // optional string php_namespace = 41;
+
+
+ pub fn get_php_namespace(&self) -> &str {
+ match self.php_namespace.as_ref() {
+ Some(v) => &v,
+ None => "",
+ }
+ }
+ pub fn clear_php_namespace(&mut self) {
+ self.php_namespace.clear();
+ }
+
+ pub fn has_php_namespace(&self) -> bool {
+ self.php_namespace.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_php_namespace(&mut self, v: ::std::string::String) {
+ self.php_namespace = crate::SingularField::some(v);
+ }
+
+ // Mutable pointer to the field.
+ // If field is not initialized, it is initialized with default value first.
+ pub fn mut_php_namespace(&mut self) -> &mut ::std::string::String {
+ if self.php_namespace.is_none() {
+ self.php_namespace.set_default();
+ }
+ self.php_namespace.as_mut().unwrap()
+ }
+
+ // Take field
+ pub fn take_php_namespace(&mut self) -> ::std::string::String {
+ self.php_namespace.take().unwrap_or_else(|| ::std::string::String::new())
+ }
+
+ // optional string php_metadata_namespace = 44;
+
+
+ pub fn get_php_metadata_namespace(&self) -> &str {
+ match self.php_metadata_namespace.as_ref() {
+ Some(v) => &v,
+ None => "",
+ }
+ }
+ pub fn clear_php_metadata_namespace(&mut self) {
+ self.php_metadata_namespace.clear();
+ }
+
+ pub fn has_php_metadata_namespace(&self) -> bool {
+ self.php_metadata_namespace.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_php_metadata_namespace(&mut self, v: ::std::string::String) {
+ self.php_metadata_namespace = crate::SingularField::some(v);
+ }
+
+ // Mutable pointer to the field.
+ // If field is not initialized, it is initialized with default value first.
+ pub fn mut_php_metadata_namespace(&mut self) -> &mut ::std::string::String {
+ if self.php_metadata_namespace.is_none() {
+ self.php_metadata_namespace.set_default();
+ }
+ self.php_metadata_namespace.as_mut().unwrap()
+ }
+
+ // Take field
+ pub fn take_php_metadata_namespace(&mut self) -> ::std::string::String {
+ self.php_metadata_namespace.take().unwrap_or_else(|| ::std::string::String::new())
+ }
+
+ // optional string ruby_package = 45;
+
+
+ pub fn get_ruby_package(&self) -> &str {
+ match self.ruby_package.as_ref() {
+ Some(v) => &v,
+ None => "",
+ }
+ }
+ pub fn clear_ruby_package(&mut self) {
+ self.ruby_package.clear();
+ }
+
+ pub fn has_ruby_package(&self) -> bool {
+ self.ruby_package.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_ruby_package(&mut self, v: ::std::string::String) {
+ self.ruby_package = crate::SingularField::some(v);
+ }
+
+ // Mutable pointer to the field.
+ // If field is not initialized, it is initialized with default value first.
+ pub fn mut_ruby_package(&mut self) -> &mut ::std::string::String {
+ if self.ruby_package.is_none() {
+ self.ruby_package.set_default();
+ }
+ self.ruby_package.as_mut().unwrap()
+ }
+
+ // Take field
+ pub fn take_ruby_package(&mut self) -> ::std::string::String {
+ self.ruby_package.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: crate::RepeatedField<UninterpretedOption>) {
+ self.uninterpreted_option = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
+ &mut self.uninterpreted_option
+ }
+
+ // Take field
+ pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+ ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.java_package)?;
+ },
+ 8 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.java_outer_classname)?;
+ },
+ 10 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.java_multiple_files = ::std::option::Option::Some(tmp);
+ },
+ 20 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::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 != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.java_string_check_utf8 = ::std::option::Option::Some(tmp);
+ },
+ 9 => {
+ crate::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.optimize_for, 9, &mut self.unknown_fields)?
+ },
+ 11 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.go_package)?;
+ },
+ 16 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.cc_generic_services = ::std::option::Option::Some(tmp);
+ },
+ 17 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.java_generic_services = ::std::option::Option::Some(tmp);
+ },
+ 18 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.py_generic_services = ::std::option::Option::Some(tmp);
+ },
+ 42 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.php_generic_services = ::std::option::Option::Some(tmp);
+ },
+ 23 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.deprecated = ::std::option::Option::Some(tmp);
+ },
+ 31 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.cc_enable_arenas = ::std::option::Option::Some(tmp);
+ },
+ 36 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.objc_class_prefix)?;
+ },
+ 37 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.csharp_namespace)?;
+ },
+ 39 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.swift_prefix)?;
+ },
+ 40 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.php_class_prefix)?;
+ },
+ 41 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.php_namespace)?;
+ },
+ 44 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.php_metadata_namespace)?;
+ },
+ 45 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.ruby_package)?;
+ },
+ 999 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &v);
+ }
+ if let Some(ref v) = self.java_outer_classname.as_ref() {
+ my_size += crate::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 += crate::rt::enum_size(9, v);
+ }
+ if let Some(ref v) = self.go_package.as_ref() {
+ my_size += crate::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.php_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 += crate::rt::string_size(36, &v);
+ }
+ if let Some(ref v) = self.csharp_namespace.as_ref() {
+ my_size += crate::rt::string_size(37, &v);
+ }
+ if let Some(ref v) = self.swift_prefix.as_ref() {
+ my_size += crate::rt::string_size(39, &v);
+ }
+ if let Some(ref v) = self.php_class_prefix.as_ref() {
+ my_size += crate::rt::string_size(40, &v);
+ }
+ if let Some(ref v) = self.php_namespace.as_ref() {
+ my_size += crate::rt::string_size(41, &v);
+ }
+ if let Some(ref v) = self.php_metadata_namespace.as_ref() {
+ my_size += crate::rt::string_size(44, &v);
+ }
+ if let Some(ref v) = self.ruby_package.as_ref() {
+ my_size += crate::rt::string_size(45, &v);
+ }
+ for value in &self.uninterpreted_option {
+ let len = value.compute_size();
+ my_size += 2 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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, crate::ProtobufEnum::value(&v))?;
+ }
+ 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.php_generic_services {
+ os.write_bool(42, 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)?;
+ }
+ if let Some(ref v) = self.swift_prefix.as_ref() {
+ os.write_string(39, &v)?;
+ }
+ if let Some(ref v) = self.php_class_prefix.as_ref() {
+ os.write_string(40, &v)?;
+ }
+ if let Some(ref v) = self.php_namespace.as_ref() {
+ os.write_string(41, &v)?;
+ }
+ if let Some(ref v) = self.php_metadata_namespace.as_ref() {
+ os.write_string(44, &v)?;
+ }
+ if let Some(ref v) = self.ruby_package.as_ref() {
+ os.write_string(45, &v)?;
+ }
+ for v in &self.uninterpreted_option {
+ os.write_tag(999, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> FileOptions {
+ FileOptions::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "java_package",
+ |m: &FileOptions| { &m.java_package },
+ |m: &mut FileOptions| { &mut m.java_package },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "java_outer_classname",
+ |m: &FileOptions| { &m.java_outer_classname },
+ |m: &mut FileOptions| { &mut m.java_outer_classname },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "java_multiple_files",
+ |m: &FileOptions| { &m.java_multiple_files },
+ |m: &mut FileOptions| { &mut m.java_multiple_files },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::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(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "java_string_check_utf8",
+ |m: &FileOptions| { &m.java_string_check_utf8 },
+ |m: &mut FileOptions| { &mut m.java_string_check_utf8 },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeEnum<FileOptions_OptimizeMode>>(
+ "optimize_for",
+ |m: &FileOptions| { &m.optimize_for },
+ |m: &mut FileOptions| { &mut m.optimize_for },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "go_package",
+ |m: &FileOptions| { &m.go_package },
+ |m: &mut FileOptions| { &mut m.go_package },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "cc_generic_services",
+ |m: &FileOptions| { &m.cc_generic_services },
+ |m: &mut FileOptions| { &mut m.cc_generic_services },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "java_generic_services",
+ |m: &FileOptions| { &m.java_generic_services },
+ |m: &mut FileOptions| { &mut m.java_generic_services },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "py_generic_services",
+ |m: &FileOptions| { &m.py_generic_services },
+ |m: &mut FileOptions| { &mut m.py_generic_services },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "php_generic_services",
+ |m: &FileOptions| { &m.php_generic_services },
+ |m: &mut FileOptions| { &mut m.php_generic_services },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "deprecated",
+ |m: &FileOptions| { &m.deprecated },
+ |m: &mut FileOptions| { &mut m.deprecated },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "cc_enable_arenas",
+ |m: &FileOptions| { &m.cc_enable_arenas },
+ |m: &mut FileOptions| { &mut m.cc_enable_arenas },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "objc_class_prefix",
+ |m: &FileOptions| { &m.objc_class_prefix },
+ |m: &mut FileOptions| { &mut m.objc_class_prefix },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "csharp_namespace",
+ |m: &FileOptions| { &m.csharp_namespace },
+ |m: &mut FileOptions| { &mut m.csharp_namespace },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "swift_prefix",
+ |m: &FileOptions| { &m.swift_prefix },
+ |m: &mut FileOptions| { &mut m.swift_prefix },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "php_class_prefix",
+ |m: &FileOptions| { &m.php_class_prefix },
+ |m: &mut FileOptions| { &mut m.php_class_prefix },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "php_namespace",
+ |m: &FileOptions| { &m.php_namespace },
+ |m: &mut FileOptions| { &mut m.php_namespace },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "php_metadata_namespace",
+ |m: &FileOptions| { &m.php_metadata_namespace },
+ |m: &mut FileOptions| { &mut m.php_metadata_namespace },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "ruby_package",
+ |m: &FileOptions| { &m.ruby_package },
+ |m: &mut FileOptions| { &mut m.ruby_package },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
+ "uninterpreted_option",
+ |m: &FileOptions| { &m.uninterpreted_option },
+ |m: &mut FileOptions| { &mut m.uninterpreted_option },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<FileOptions>(
+ "FileOptions",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static FileOptions {
+ static instance: crate::rt::LazyV2<FileOptions> = crate::rt::LazyV2::INIT;
+ instance.get(FileOptions::new)
+ }
+}
+
+impl crate::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.php_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.swift_prefix.clear();
+ self.php_class_prefix.clear();
+ self.php_namespace.clear();
+ self.php_metadata_namespace.clear();
+ self.ruby_package.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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for FileOptions {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub enum FileOptions_OptimizeMode {
+ SPEED = 1,
+ CODE_SIZE = 2,
+ LITE_RUNTIME = 3,
+}
+
+impl crate::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 crate::reflect::EnumDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ crate::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 crate::reflect::ProtobufValue for FileOptions_OptimizeMode {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::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>,
+ pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a MessageOptions {
+ fn default() -> &'a MessageOptions {
+ <MessageOptions as crate::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: crate::RepeatedField<UninterpretedOption>) {
+ self.uninterpreted_option = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
+ &mut self.uninterpreted_option
+ }
+
+ // Take field
+ pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+ ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::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 != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::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 != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.deprecated = ::std::option::Option::Some(tmp);
+ },
+ 7 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.map_entry = ::std::option::Option::Some(tmp);
+ },
+ 999 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+ },
+ _ => {
+ crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> MessageOptions {
+ MessageOptions::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "message_set_wire_format",
+ |m: &MessageOptions| { &m.message_set_wire_format },
+ |m: &mut MessageOptions| { &mut m.message_set_wire_format },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "no_standard_descriptor_accessor",
+ |m: &MessageOptions| { &m.no_standard_descriptor_accessor },
+ |m: &mut MessageOptions| { &mut m.no_standard_descriptor_accessor },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "deprecated",
+ |m: &MessageOptions| { &m.deprecated },
+ |m: &mut MessageOptions| { &mut m.deprecated },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "map_entry",
+ |m: &MessageOptions| { &m.map_entry },
+ |m: &mut MessageOptions| { &mut m.map_entry },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
+ "uninterpreted_option",
+ |m: &MessageOptions| { &m.uninterpreted_option },
+ |m: &mut MessageOptions| { &mut m.uninterpreted_option },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<MessageOptions>(
+ "MessageOptions",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static MessageOptions {
+ static instance: crate::rt::LazyV2<MessageOptions> = crate::rt::LazyV2::INIT;
+ instance.get(MessageOptions::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for MessageOptions {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::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>,
+ pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a FieldOptions {
+ fn default() -> &'a FieldOptions {
+ <FieldOptions as crate::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: crate::RepeatedField<UninterpretedOption>) {
+ self.uninterpreted_option = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
+ &mut self.uninterpreted_option
+ }
+
+ // Take field
+ pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+ ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.ctype, 1, &mut self.unknown_fields)?
+ },
+ 2 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.packed = ::std::option::Option::Some(tmp);
+ },
+ 6 => {
+ crate::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.jstype, 6, &mut self.unknown_fields)?
+ },
+ 5 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.lazy = ::std::option::Option::Some(tmp);
+ },
+ 3 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.deprecated = ::std::option::Option::Some(tmp);
+ },
+ 10 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.weak = ::std::option::Option::Some(tmp);
+ },
+ 999 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+ },
+ _ => {
+ crate::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 += crate::rt::enum_size(1, v);
+ }
+ if let Some(v) = self.packed {
+ my_size += 2;
+ }
+ if let Some(v) = self.jstype {
+ my_size += crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if let Some(v) = self.ctype {
+ os.write_enum(1, crate::ProtobufEnum::value(&v))?;
+ }
+ if let Some(v) = self.packed {
+ os.write_bool(2, v)?;
+ }
+ if let Some(v) = self.jstype {
+ os.write_enum(6, crate::ProtobufEnum::value(&v))?;
+ }
+ 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, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> FieldOptions {
+ FieldOptions::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeEnum<FieldOptions_CType>>(
+ "ctype",
+ |m: &FieldOptions| { &m.ctype },
+ |m: &mut FieldOptions| { &mut m.ctype },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "packed",
+ |m: &FieldOptions| { &m.packed },
+ |m: &mut FieldOptions| { &mut m.packed },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeEnum<FieldOptions_JSType>>(
+ "jstype",
+ |m: &FieldOptions| { &m.jstype },
+ |m: &mut FieldOptions| { &mut m.jstype },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "lazy",
+ |m: &FieldOptions| { &m.lazy },
+ |m: &mut FieldOptions| { &mut m.lazy },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "deprecated",
+ |m: &FieldOptions| { &m.deprecated },
+ |m: &mut FieldOptions| { &mut m.deprecated },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "weak",
+ |m: &FieldOptions| { &m.weak },
+ |m: &mut FieldOptions| { &mut m.weak },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
+ "uninterpreted_option",
+ |m: &FieldOptions| { &m.uninterpreted_option },
+ |m: &mut FieldOptions| { &mut m.uninterpreted_option },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<FieldOptions>(
+ "FieldOptions",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static FieldOptions {
+ static instance: crate::rt::LazyV2<FieldOptions> = crate::rt::LazyV2::INIT;
+ instance.get(FieldOptions::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for FieldOptions {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub enum FieldOptions_CType {
+ STRING = 0,
+ CORD = 1,
+ STRING_PIECE = 2,
+}
+
+impl crate::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 crate::reflect::EnumDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ crate::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 crate::reflect::ProtobufValue for FieldOptions_CType {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
+ }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub enum FieldOptions_JSType {
+ JS_NORMAL = 0,
+ JS_STRING = 1,
+ JS_NUMBER = 2,
+}
+
+impl crate::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 crate::reflect::EnumDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ crate::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 crate::reflect::ProtobufValue for FieldOptions_JSType {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct OneofOptions {
+ // message fields
+ pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a OneofOptions {
+ fn default() -> &'a OneofOptions {
+ <OneofOptions as crate::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: crate::RepeatedField<UninterpretedOption>) {
+ self.uninterpreted_option = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
+ &mut self.uninterpreted_option
+ }
+
+ // Take field
+ pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+ ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 999 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+ },
+ _ => {
+ crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ for v in &self.uninterpreted_option {
+ os.write_tag(999, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> OneofOptions {
+ OneofOptions::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
+ "uninterpreted_option",
+ |m: &OneofOptions| { &m.uninterpreted_option },
+ |m: &mut OneofOptions| { &mut m.uninterpreted_option },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<OneofOptions>(
+ "OneofOptions",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static OneofOptions {
+ static instance: crate::rt::LazyV2<OneofOptions> = crate::rt::LazyV2::INIT;
+ instance.get(OneofOptions::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for OneofOptions {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct EnumOptions {
+ // message fields
+ allow_alias: ::std::option::Option<bool>,
+ deprecated: ::std::option::Option<bool>,
+ pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a EnumOptions {
+ fn default() -> &'a EnumOptions {
+ <EnumOptions as crate::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: crate::RepeatedField<UninterpretedOption>) {
+ self.uninterpreted_option = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
+ &mut self.uninterpreted_option
+ }
+
+ // Take field
+ pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+ ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 2 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.allow_alias = ::std::option::Option::Some(tmp);
+ },
+ 3 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.deprecated = ::std::option::Option::Some(tmp);
+ },
+ 999 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+ },
+ _ => {
+ crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> EnumOptions {
+ EnumOptions::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "allow_alias",
+ |m: &EnumOptions| { &m.allow_alias },
+ |m: &mut EnumOptions| { &mut m.allow_alias },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "deprecated",
+ |m: &EnumOptions| { &m.deprecated },
+ |m: &mut EnumOptions| { &mut m.deprecated },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
+ "uninterpreted_option",
+ |m: &EnumOptions| { &m.uninterpreted_option },
+ |m: &mut EnumOptions| { &mut m.uninterpreted_option },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<EnumOptions>(
+ "EnumOptions",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static EnumOptions {
+ static instance: crate::rt::LazyV2<EnumOptions> = crate::rt::LazyV2::INIT;
+ instance.get(EnumOptions::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for EnumOptions {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct EnumValueOptions {
+ // message fields
+ deprecated: ::std::option::Option<bool>,
+ pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a EnumValueOptions {
+ fn default() -> &'a EnumValueOptions {
+ <EnumValueOptions as crate::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: crate::RepeatedField<UninterpretedOption>) {
+ self.uninterpreted_option = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
+ &mut self.uninterpreted_option
+ }
+
+ // Take field
+ pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+ ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.deprecated = ::std::option::Option::Some(tmp);
+ },
+ 999 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+ },
+ _ => {
+ crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if let Some(v) = self.deprecated {
+ os.write_bool(1, v)?;
+ }
+ for v in &self.uninterpreted_option {
+ os.write_tag(999, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> EnumValueOptions {
+ EnumValueOptions::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "deprecated",
+ |m: &EnumValueOptions| { &m.deprecated },
+ |m: &mut EnumValueOptions| { &mut m.deprecated },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
+ "uninterpreted_option",
+ |m: &EnumValueOptions| { &m.uninterpreted_option },
+ |m: &mut EnumValueOptions| { &mut m.uninterpreted_option },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<EnumValueOptions>(
+ "EnumValueOptions",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static EnumValueOptions {
+ static instance: crate::rt::LazyV2<EnumValueOptions> = crate::rt::LazyV2::INIT;
+ instance.get(EnumValueOptions::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for EnumValueOptions {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct ServiceOptions {
+ // message fields
+ deprecated: ::std::option::Option<bool>,
+ pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a ServiceOptions {
+ fn default() -> &'a ServiceOptions {
+ <ServiceOptions as crate::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: crate::RepeatedField<UninterpretedOption>) {
+ self.uninterpreted_option = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
+ &mut self.uninterpreted_option
+ }
+
+ // Take field
+ pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+ ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 33 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.deprecated = ::std::option::Option::Some(tmp);
+ },
+ 999 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+ },
+ _ => {
+ crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if let Some(v) = self.deprecated {
+ os.write_bool(33, v)?;
+ }
+ for v in &self.uninterpreted_option {
+ os.write_tag(999, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> ServiceOptions {
+ ServiceOptions::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "deprecated",
+ |m: &ServiceOptions| { &m.deprecated },
+ |m: &mut ServiceOptions| { &mut m.deprecated },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
+ "uninterpreted_option",
+ |m: &ServiceOptions| { &m.uninterpreted_option },
+ |m: &mut ServiceOptions| { &mut m.uninterpreted_option },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<ServiceOptions>(
+ "ServiceOptions",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static ServiceOptions {
+ static instance: crate::rt::LazyV2<ServiceOptions> = crate::rt::LazyV2::INIT;
+ instance.get(ServiceOptions::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for ServiceOptions {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct MethodOptions {
+ // message fields
+ deprecated: ::std::option::Option<bool>,
+ idempotency_level: ::std::option::Option<MethodOptions_IdempotencyLevel>,
+ pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a MethodOptions {
+ fn default() -> &'a MethodOptions {
+ <MethodOptions as crate::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);
+ }
+
+ // optional .google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34;
+
+
+ pub fn get_idempotency_level(&self) -> MethodOptions_IdempotencyLevel {
+ self.idempotency_level.unwrap_or(MethodOptions_IdempotencyLevel::IDEMPOTENCY_UNKNOWN)
+ }
+ pub fn clear_idempotency_level(&mut self) {
+ self.idempotency_level = ::std::option::Option::None;
+ }
+
+ pub fn has_idempotency_level(&self) -> bool {
+ self.idempotency_level.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_idempotency_level(&mut self, v: MethodOptions_IdempotencyLevel) {
+ self.idempotency_level = ::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: crate::RepeatedField<UninterpretedOption>) {
+ self.uninterpreted_option = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
+ &mut self.uninterpreted_option
+ }
+
+ // Take field
+ pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+ ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 33 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.deprecated = ::std::option::Option::Some(tmp);
+ },
+ 34 => {
+ crate::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.idempotency_level, 34, &mut self.unknown_fields)?
+ },
+ 999 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+ },
+ _ => {
+ crate::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;
+ }
+ if let Some(v) = self.idempotency_level {
+ my_size += crate::rt::enum_size(34, v);
+ }
+ for value in &self.uninterpreted_option {
+ let len = value.compute_size();
+ my_size += 2 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if let Some(v) = self.deprecated {
+ os.write_bool(33, v)?;
+ }
+ if let Some(v) = self.idempotency_level {
+ os.write_enum(34, crate::ProtobufEnum::value(&v))?;
+ }
+ for v in &self.uninterpreted_option {
+ os.write_tag(999, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> MethodOptions {
+ MethodOptions::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "deprecated",
+ |m: &MethodOptions| { &m.deprecated },
+ |m: &mut MethodOptions| { &mut m.deprecated },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeEnum<MethodOptions_IdempotencyLevel>>(
+ "idempotency_level",
+ |m: &MethodOptions| { &m.idempotency_level },
+ |m: &mut MethodOptions| { &mut m.idempotency_level },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
+ "uninterpreted_option",
+ |m: &MethodOptions| { &m.uninterpreted_option },
+ |m: &mut MethodOptions| { &mut m.uninterpreted_option },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<MethodOptions>(
+ "MethodOptions",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static MethodOptions {
+ static instance: crate::rt::LazyV2<MethodOptions> = crate::rt::LazyV2::INIT;
+ instance.get(MethodOptions::new)
+ }
+}
+
+impl crate::Clear for MethodOptions {
+ fn clear(&mut self) {
+ self.deprecated = ::std::option::Option::None;
+ self.idempotency_level = ::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for MethodOptions {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub enum MethodOptions_IdempotencyLevel {
+ IDEMPOTENCY_UNKNOWN = 0,
+ NO_SIDE_EFFECTS = 1,
+ IDEMPOTENT = 2,
+}
+
+impl crate::ProtobufEnum for MethodOptions_IdempotencyLevel {
+ fn value(&self) -> i32 {
+ *self as i32
+ }
+
+ fn from_i32(value: i32) -> ::std::option::Option<MethodOptions_IdempotencyLevel> {
+ match value {
+ 0 => ::std::option::Option::Some(MethodOptions_IdempotencyLevel::IDEMPOTENCY_UNKNOWN),
+ 1 => ::std::option::Option::Some(MethodOptions_IdempotencyLevel::NO_SIDE_EFFECTS),
+ 2 => ::std::option::Option::Some(MethodOptions_IdempotencyLevel::IDEMPOTENT),
+ _ => ::std::option::Option::None
+ }
+ }
+
+ fn values() -> &'static [Self] {
+ static values: &'static [MethodOptions_IdempotencyLevel] = &[
+ MethodOptions_IdempotencyLevel::IDEMPOTENCY_UNKNOWN,
+ MethodOptions_IdempotencyLevel::NO_SIDE_EFFECTS,
+ MethodOptions_IdempotencyLevel::IDEMPOTENT,
+ ];
+ values
+ }
+
+ fn enum_descriptor_static() -> &'static crate::reflect::EnumDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ crate::reflect::EnumDescriptor::new_pb_name::<MethodOptions_IdempotencyLevel>("MethodOptions.IdempotencyLevel", file_descriptor_proto())
+ })
+ }
+}
+
+impl ::std::marker::Copy for MethodOptions_IdempotencyLevel {
+}
+
+impl ::std::default::Default for MethodOptions_IdempotencyLevel {
+ fn default() -> Self {
+ MethodOptions_IdempotencyLevel::IDEMPOTENCY_UNKNOWN
+ }
+}
+
+impl crate::reflect::ProtobufValue for MethodOptions_IdempotencyLevel {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct UninterpretedOption {
+ // message fields
+ pub name: crate::RepeatedField<UninterpretedOption_NamePart>,
+ identifier_value: crate::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: crate::SingularField<::std::vec::Vec<u8>>,
+ aggregate_value: crate::SingularField<::std::string::String>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a UninterpretedOption {
+ fn default() -> &'a UninterpretedOption {
+ <UninterpretedOption as crate::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: crate::RepeatedField<UninterpretedOption_NamePart>) {
+ self.name = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_name(&mut self) -> &mut crate::RepeatedField<UninterpretedOption_NamePart> {
+ &mut self.name
+ }
+
+ // Take field
+ pub fn take_name(&mut self) -> crate::RepeatedField<UninterpretedOption_NamePart> {
+ ::std::mem::replace(&mut self.name, crate::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 = crate::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 = crate::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 = crate::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 crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 2 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.name)?;
+ },
+ 3 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.identifier_value)?;
+ },
+ 4 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_uint64()?;
+ self.positive_int_value = ::std::option::Option::Some(tmp);
+ },
+ 5 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int64()?;
+ self.negative_int_value = ::std::option::Option::Some(tmp);
+ },
+ 6 => {
+ if wire_type != crate::wire_format::WireTypeFixed64 {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_double()?;
+ self.double_value = ::std::option::Option::Some(tmp);
+ },
+ 7 => {
+ crate::rt::read_singular_bytes_into(wire_type, is, &mut self.string_value)?;
+ },
+ 8 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.aggregate_value)?;
+ },
+ _ => {
+ crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ if let Some(ref v) = self.identifier_value.as_ref() {
+ my_size += crate::rt::string_size(3, &v);
+ }
+ if let Some(v) = self.positive_int_value {
+ my_size += crate::rt::value_size(4, v, crate::wire_format::WireTypeVarint);
+ }
+ if let Some(v) = self.negative_int_value {
+ my_size += crate::rt::value_size(5, v, crate::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 += crate::rt::bytes_size(7, &v);
+ }
+ if let Some(ref v) = self.aggregate_value.as_ref() {
+ my_size += crate::rt::string_size(8, &v);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ for v in &self.name {
+ os.write_tag(2, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> UninterpretedOption {
+ UninterpretedOption::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption_NamePart>>(
+ "name",
+ |m: &UninterpretedOption| { &m.name },
+ |m: &mut UninterpretedOption| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "identifier_value",
+ |m: &UninterpretedOption| { &m.identifier_value },
+ |m: &mut UninterpretedOption| { &mut m.identifier_value },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeUint64>(
+ "positive_int_value",
+ |m: &UninterpretedOption| { &m.positive_int_value },
+ |m: &mut UninterpretedOption| { &mut m.positive_int_value },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt64>(
+ "negative_int_value",
+ |m: &UninterpretedOption| { &m.negative_int_value },
+ |m: &mut UninterpretedOption| { &mut m.negative_int_value },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeDouble>(
+ "double_value",
+ |m: &UninterpretedOption| { &m.double_value },
+ |m: &mut UninterpretedOption| { &mut m.double_value },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeBytes>(
+ "string_value",
+ |m: &UninterpretedOption| { &m.string_value },
+ |m: &mut UninterpretedOption| { &mut m.string_value },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "aggregate_value",
+ |m: &UninterpretedOption| { &m.aggregate_value },
+ |m: &mut UninterpretedOption| { &mut m.aggregate_value },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<UninterpretedOption>(
+ "UninterpretedOption",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static UninterpretedOption {
+ static instance: crate::rt::LazyV2<UninterpretedOption> = crate::rt::LazyV2::INIT;
+ instance.get(UninterpretedOption::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for UninterpretedOption {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct UninterpretedOption_NamePart {
+ // message fields
+ name_part: crate::SingularField<::std::string::String>,
+ is_extension: ::std::option::Option<bool>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a UninterpretedOption_NamePart {
+ fn default() -> &'a UninterpretedOption_NamePart {
+ <UninterpretedOption_NamePart as crate::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 = crate::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 crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.name_part)?;
+ },
+ 2 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.is_extension = ::std::option::Option::Some(tmp);
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &v);
+ }
+ if let Some(v) = self.is_extension {
+ my_size += 2;
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> UninterpretedOption_NamePart {
+ UninterpretedOption_NamePart::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name_part",
+ |m: &UninterpretedOption_NamePart| { &m.name_part },
+ |m: &mut UninterpretedOption_NamePart| { &mut m.name_part },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
+ "is_extension",
+ |m: &UninterpretedOption_NamePart| { &m.is_extension },
+ |m: &mut UninterpretedOption_NamePart| { &mut m.is_extension },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<UninterpretedOption_NamePart>(
+ "UninterpretedOption.NamePart",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static UninterpretedOption_NamePart {
+ static instance: crate::rt::LazyV2<UninterpretedOption_NamePart> = crate::rt::LazyV2::INIT;
+ instance.get(UninterpretedOption_NamePart::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for UninterpretedOption_NamePart {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct SourceCodeInfo {
+ // message fields
+ pub location: crate::RepeatedField<SourceCodeInfo_Location>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a SourceCodeInfo {
+ fn default() -> &'a SourceCodeInfo {
+ <SourceCodeInfo as crate::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: crate::RepeatedField<SourceCodeInfo_Location>) {
+ self.location = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_location(&mut self) -> &mut crate::RepeatedField<SourceCodeInfo_Location> {
+ &mut self.location
+ }
+
+ // Take field
+ pub fn take_location(&mut self) -> crate::RepeatedField<SourceCodeInfo_Location> {
+ ::std::mem::replace(&mut self.location, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.location)?;
+ },
+ _ => {
+ crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ for v in &self.location {
+ os.write_tag(1, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> SourceCodeInfo {
+ SourceCodeInfo::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<SourceCodeInfo_Location>>(
+ "location",
+ |m: &SourceCodeInfo| { &m.location },
+ |m: &mut SourceCodeInfo| { &mut m.location },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<SourceCodeInfo>(
+ "SourceCodeInfo",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static SourceCodeInfo {
+ static instance: crate::rt::LazyV2<SourceCodeInfo> = crate::rt::LazyV2::INIT;
+ instance.get(SourceCodeInfo::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for SourceCodeInfo {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct SourceCodeInfo_Location {
+ // message fields
+ pub path: ::std::vec::Vec<i32>,
+ pub span: ::std::vec::Vec<i32>,
+ leading_comments: crate::SingularField<::std::string::String>,
+ trailing_comments: crate::SingularField<::std::string::String>,
+ pub leading_detached_comments: crate::RepeatedField<::std::string::String>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a SourceCodeInfo_Location {
+ fn default() -> &'a SourceCodeInfo_Location {
+ <SourceCodeInfo_Location as crate::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 = crate::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 = crate::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: crate::RepeatedField<::std::string::String>) {
+ self.leading_detached_comments = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_leading_detached_comments(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
+ &mut self.leading_detached_comments
+ }
+
+ // Take field
+ pub fn take_leading_detached_comments(&mut self) -> crate::RepeatedField<::std::string::String> {
+ ::std::mem::replace(&mut self.leading_detached_comments, crate::RepeatedField::new())
+ }
+}
+
+impl crate::Message for SourceCodeInfo_Location {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_repeated_int32_into(wire_type, is, &mut self.path)?;
+ },
+ 2 => {
+ crate::rt::read_repeated_int32_into(wire_type, is, &mut self.span)?;
+ },
+ 3 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.leading_comments)?;
+ },
+ 4 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.trailing_comments)?;
+ },
+ 6 => {
+ crate::rt::read_repeated_string_into(wire_type, is, &mut self.leading_detached_comments)?;
+ },
+ _ => {
+ crate::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 += crate::rt::vec_packed_varint_size(1, &self.path);
+ }
+ if !self.span.is_empty() {
+ my_size += crate::rt::vec_packed_varint_size(2, &self.span);
+ }
+ if let Some(ref v) = self.leading_comments.as_ref() {
+ my_size += crate::rt::string_size(3, &v);
+ }
+ if let Some(ref v) = self.trailing_comments.as_ref() {
+ my_size += crate::rt::string_size(4, &v);
+ }
+ for value in &self.leading_detached_comments {
+ my_size += crate::rt::string_size(6, &value);
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if !self.path.is_empty() {
+ os.write_tag(1, crate::wire_format::WireTypeLengthDelimited)?;
+ // TODO: Data size is computed again, it should be cached
+ os.write_raw_varint32(crate::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, crate::wire_format::WireTypeLengthDelimited)?;
+ // TODO: Data size is computed again, it should be cached
+ os.write_raw_varint32(crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> SourceCodeInfo_Location {
+ SourceCodeInfo_Location::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_vec_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "path",
+ |m: &SourceCodeInfo_Location| { &m.path },
+ |m: &mut SourceCodeInfo_Location| { &mut m.path },
+ ));
+ fields.push(crate::reflect::accessor::make_vec_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "span",
+ |m: &SourceCodeInfo_Location| { &m.span },
+ |m: &mut SourceCodeInfo_Location| { &mut m.span },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "leading_comments",
+ |m: &SourceCodeInfo_Location| { &m.leading_comments },
+ |m: &mut SourceCodeInfo_Location| { &mut m.leading_comments },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "trailing_comments",
+ |m: &SourceCodeInfo_Location| { &m.trailing_comments },
+ |m: &mut SourceCodeInfo_Location| { &mut m.trailing_comments },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "leading_detached_comments",
+ |m: &SourceCodeInfo_Location| { &m.leading_detached_comments },
+ |m: &mut SourceCodeInfo_Location| { &mut m.leading_detached_comments },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<SourceCodeInfo_Location>(
+ "SourceCodeInfo.Location",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static SourceCodeInfo_Location {
+ static instance: crate::rt::LazyV2<SourceCodeInfo_Location> = crate::rt::LazyV2::INIT;
+ instance.get(SourceCodeInfo_Location::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for SourceCodeInfo_Location {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct GeneratedCodeInfo {
+ // message fields
+ pub annotation: crate::RepeatedField<GeneratedCodeInfo_Annotation>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a GeneratedCodeInfo {
+ fn default() -> &'a GeneratedCodeInfo {
+ <GeneratedCodeInfo as crate::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: crate::RepeatedField<GeneratedCodeInfo_Annotation>) {
+ self.annotation = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_annotation(&mut self) -> &mut crate::RepeatedField<GeneratedCodeInfo_Annotation> {
+ &mut self.annotation
+ }
+
+ // Take field
+ pub fn take_annotation(&mut self) -> crate::RepeatedField<GeneratedCodeInfo_Annotation> {
+ ::std::mem::replace(&mut self.annotation, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.annotation)?;
+ },
+ _ => {
+ crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ for v in &self.annotation {
+ os.write_tag(1, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> GeneratedCodeInfo {
+ GeneratedCodeInfo::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<GeneratedCodeInfo_Annotation>>(
+ "annotation",
+ |m: &GeneratedCodeInfo| { &m.annotation },
+ |m: &mut GeneratedCodeInfo| { &mut m.annotation },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<GeneratedCodeInfo>(
+ "GeneratedCodeInfo",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static GeneratedCodeInfo {
+ static instance: crate::rt::LazyV2<GeneratedCodeInfo> = crate::rt::LazyV2::INIT;
+ instance.get(GeneratedCodeInfo::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for GeneratedCodeInfo {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct GeneratedCodeInfo_Annotation {
+ // message fields
+ pub path: ::std::vec::Vec<i32>,
+ source_file: crate::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: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a GeneratedCodeInfo_Annotation {
+ fn default() -> &'a GeneratedCodeInfo_Annotation {
+ <GeneratedCodeInfo_Annotation as crate::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 = crate::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 crate::Message for GeneratedCodeInfo_Annotation {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_repeated_int32_into(wire_type, is, &mut self.path)?;
+ },
+ 2 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.source_file)?;
+ },
+ 3 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.begin = ::std::option::Option::Some(tmp);
+ },
+ 4 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.end = ::std::option::Option::Some(tmp);
+ },
+ _ => {
+ crate::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 += crate::rt::vec_packed_varint_size(1, &self.path);
+ }
+ if let Some(ref v) = self.source_file.as_ref() {
+ my_size += crate::rt::string_size(2, &v);
+ }
+ if let Some(v) = self.begin {
+ my_size += crate::rt::value_size(3, v, crate::wire_format::WireTypeVarint);
+ }
+ if let Some(v) = self.end {
+ my_size += crate::rt::value_size(4, v, crate::wire_format::WireTypeVarint);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if !self.path.is_empty() {
+ os.write_tag(1, crate::wire_format::WireTypeLengthDelimited)?;
+ // TODO: Data size is computed again, it should be cached
+ os.write_raw_varint32(crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> GeneratedCodeInfo_Annotation {
+ GeneratedCodeInfo_Annotation::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_vec_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "path",
+ |m: &GeneratedCodeInfo_Annotation| { &m.path },
+ |m: &mut GeneratedCodeInfo_Annotation| { &mut m.path },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "source_file",
+ |m: &GeneratedCodeInfo_Annotation| { &m.source_file },
+ |m: &mut GeneratedCodeInfo_Annotation| { &mut m.source_file },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "begin",
+ |m: &GeneratedCodeInfo_Annotation| { &m.begin },
+ |m: &mut GeneratedCodeInfo_Annotation| { &mut m.begin },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "end",
+ |m: &GeneratedCodeInfo_Annotation| { &m.end },
+ |m: &mut GeneratedCodeInfo_Annotation| { &mut m.end },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<GeneratedCodeInfo_Annotation>(
+ "GeneratedCodeInfo.Annotation",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static GeneratedCodeInfo_Annotation {
+ static instance: crate::rt::LazyV2<GeneratedCodeInfo_Annotation> = crate::rt::LazyV2::INIT;
+ instance.get(GeneratedCodeInfo_Annotation::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for GeneratedCodeInfo_Annotation {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::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\"\xb9\x06\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\x1az\n\x0e\
+ ExtensionRange\x12\x14\n\x05start\x18\x01\x20\x01(\x05R\x05start\x12\x10\
+ \n\x03end\x18\x02\x20\x01(\x05R\x03end\x12@\n\x07options\x18\x03\x20\x01\
+ (\x0b2&.google.protobuf.ExtensionRangeOptionsR\x07options\x1a7\n\rReserv\
+ edRange\x12\x14\n\x05start\x18\x01\x20\x01(\x05R\x05start\x12\x10\n\x03e\
+ nd\x18\x02\x20\x01(\x05R\x03end\"|\n\x15ExtensionRangeOptions\x12X\n\x14\
+ uninterpreted_option\x18\xe7\x07\x20\x03(\x0b2$.google.protobuf.Uninterp\
+ retedOptionR\x13uninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\
+ \x02\"\xc1\x06\n\x14FieldDescriptorProto\x12\x12\n\x04name\x18\x01\x20\
+ \x01(\tR\x04name\x12\x16\n\x06number\x18\x03\x20\x01(\x05R\x06number\x12\
+ A\n\x05label\x18\x04\x20\x01(\x0e2+.google.protobuf.FieldDescriptorProto\
+ .LabelR\x05label\x12>\n\x04type\x18\x05\x20\x01(\x0e2*.google.protobuf.F\
+ ieldDescriptorProto.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\x0b\
+ oneof_index\x18\t\x20\x01(\x05R\noneofIndex\x12\x1b\n\tjson_name\x18\n\
+ \x20\x01(\tR\x08jsonName\x127\n\x07options\x18\x08\x20\x01(\x0b2\x1d.goo\
+ gle.protobuf.FieldOptionsR\x07options\x12'\n\x0fproto3_optional\x18\x11\
+ \x20\x01(\x08R\x0eproto3Optional\"\xb6\x02\n\x04Type\x12\x0f\n\x0bTYPE_D\
+ OUBLE\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_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_BYTES\x10\x0c\
+ \x12\x0f\n\x0bTYPE_UINT32\x10\r\x12\r\n\tTYPE_ENUM\x10\x0e\x12\x11\n\rTY\
+ PE_SFIXED32\x10\x0f\x12\x11\n\rTYPE_SFIXED64\x10\x10\x12\x0f\n\x0bTYPE_S\
+ INT32\x10\x11\x12\x0f\n\x0bTYPE_SINT64\x10\x12\"C\n\x05Label\x12\x12\n\
+ \x0eLABEL_OPTIONAL\x10\x01\x12\x12\n\x0eLABEL_REQUIRED\x10\x02\x12\x12\n\
+ \x0eLABEL_REPEATED\x10\x03\"c\n\x14OneofDescriptorProto\x12\x12\n\x04nam\
+ e\x18\x01\x20\x01(\tR\x04name\x127\n\x07options\x18\x02\x20\x01(\x0b2\
+ \x1d.google.protobuf.OneofOptionsR\x07options\"\xe3\x02\n\x13EnumDescrip\
+ torProto\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12?\n\x05value\
+ \x18\x02\x20\x03(\x0b2).google.protobuf.EnumValueDescriptorProtoR\x05val\
+ ue\x126\n\x07options\x18\x03\x20\x01(\x0b2\x1c.google.protobuf.EnumOptio\
+ nsR\x07options\x12]\n\x0ereserved_range\x18\x04\x20\x03(\x0b26.google.pr\
+ otobuf.EnumDescriptorProto.EnumReservedRangeR\rreservedRange\x12#\n\rres\
+ erved_name\x18\x05\x20\x03(\tR\x0creservedName\x1a;\n\x11EnumReservedRan\
+ ge\x12\x14\n\x05start\x18\x01\x20\x01(\x05R\x05start\x12\x10\n\x03end\
+ \x18\x02\x20\x01(\x05R\x03end\"\x83\x01\n\x18EnumValueDescriptorProto\
+ \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\"\x91\t\n\x0bFileOptions\x12!\n\x0cjava_packag\
+ e\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_generate_\
+ equals_and_hash\x18\x14\x20\x01(\x08R\x19javaGenerateEqualsAndHashB\x02\
+ \x18\x01\x12:\n\x16java_string_check_utf8\x18\x1b\x20\x01(\x08:\x05false\
+ R\x13javaStringCheckUtf8\x12S\n\x0coptimize_for\x18\t\x20\x01(\x0e2).goo\
+ gle.protobuf.FileOptions.OptimizeMode:\x05SPEEDR\x0boptimizeFor\x12\x1d\
+ \n\ngo_package\x18\x0b\x20\x01(\tR\tgoPackage\x125\n\x13cc_generic_servi\
+ ces\x18\x10\x20\x01(\x08:\x05falseR\x11ccGenericServices\x129\n\x15java_\
+ generic_services\x18\x11\x20\x01(\x08:\x05falseR\x13javaGenericServices\
+ \x125\n\x13py_generic_services\x18\x12\x20\x01(\x08:\x05falseR\x11pyGene\
+ ricServices\x127\n\x14php_generic_services\x18*\x20\x01(\x08:\x05falseR\
+ \x12phpGenericServices\x12%\n\ndeprecated\x18\x17\x20\x01(\x08:\x05false\
+ R\ndeprecated\x12.\n\x10cc_enable_arenas\x18\x1f\x20\x01(\x08:\x04trueR\
+ \x0eccEnableArenas\x12*\n\x11objc_class_prefix\x18$\x20\x01(\tR\x0fobjcC\
+ lassPrefix\x12)\n\x10csharp_namespace\x18%\x20\x01(\tR\x0fcsharpNamespac\
+ e\x12!\n\x0cswift_prefix\x18'\x20\x01(\tR\x0bswiftPrefix\x12(\n\x10php_c\
+ lass_prefix\x18(\x20\x01(\tR\x0ephpClassPrefix\x12#\n\rphp_namespace\x18\
+ )\x20\x01(\tR\x0cphpNamespace\x124\n\x16php_metadata_namespace\x18,\x20\
+ \x01(\tR\x14phpMetadataNamespace\x12!\n\x0cruby_package\x18-\x20\x01(\tR\
+ \x0brubyPackage\x12X\n\x14uninterpreted_option\x18\xe7\x07\x20\x03(\x0b2\
+ $.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\":\n\x0cOp\
+ timizeMode\x12\t\n\x05SPEED\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\x02J\x04\x08\
+ &\x10'\"\xd1\x02\n\x0eMessageOptions\x12<\n\x17message_set_wire_format\
+ \x18\x01\x20\x01(\x08:\x05falseR\x14messageSetWireFormat\x12L\n\x1fno_st\
+ andard_descriptor_accessor\x18\x02\x20\x01(\x08:\x05falseR\x1cnoStandard\
+ DescriptorAccessor\x12%\n\ndeprecated\x18\x03\x20\x01(\x08:\x05falseR\nd\
+ eprecated\x12\x1b\n\tmap_entry\x18\x07\x20\x01(\x08R\x08mapEntry\x12X\n\
+ \x14uninterpreted_option\x18\xe7\x07\x20\x03(\x0b2$.google.protobuf.Unin\
+ terpretedOptionR\x13uninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\
+ \x80\x02J\x04\x08\x08\x10\tJ\x04\x08\t\x10\n\"\xe2\x03\n\x0cFieldOptions\
+ \x12A\n\x05ctype\x18\x01\x20\x01(\x0e2#.google.protobuf.FieldOptions.CTy\
+ pe:\x06STRINGR\x05ctype\x12\x16\n\x06packed\x18\x02\x20\x01(\x08R\x06pac\
+ ked\x12G\n\x06jstype\x18\x06\x20\x01(\x0e2$.google.protobuf.FieldOptions\
+ .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\x02J\x04\x08\x04\
+ \x10\x05\"s\n\x0cOneofOptions\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\"\xc0\x01\n\x0bEnumOptions\
+ \x12\x1f\n\x0ballow_alias\x18\x02\x20\x01(\x08R\nallowAlias\x12%\n\ndepr\
+ ecated\x18\x03\x20\x01(\x08:\x05falseR\ndeprecated\x12X\n\x14uninterpret\
+ ed_option\x18\xe7\x07\x20\x03(\x0b2$.google.protobuf.UninterpretedOption\
+ R\x13uninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\
+ \x05\x10\x06\"\x9e\x01\n\x10EnumValueOptions\x12%\n\ndeprecated\x18\x01\
+ \x20\x01(\x08:\x05falseR\ndeprecated\x12X\n\x14uninterpreted_option\x18\
+ \xe7\x07\x20\x03(\x0b2$.google.protobuf.UninterpretedOptionR\x13uninterp\
+ retedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\x9c\x01\n\x0eServic\
+ eOptions\x12%\n\ndeprecated\x18!\x20\x01(\x08:\x05falseR\ndeprecated\x12\
+ X\n\x14uninterpreted_option\x18\xe7\x07\x20\x03(\x0b2$.google.protobuf.U\
+ ninterpretedOptionR\x13uninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\
+ \x80\x80\x02\"\xe0\x02\n\rMethodOptions\x12%\n\ndeprecated\x18!\x20\x01(\
+ \x08:\x05falseR\ndeprecated\x12q\n\x11idempotency_level\x18\"\x20\x01(\
+ \x0e2/.google.protobuf.MethodOptions.IdempotencyLevel:\x13IDEMPOTENCY_UN\
+ KNOWNR\x10idempotencyLevel\x12X\n\x14uninterpreted_option\x18\xe7\x07\
+ \x20\x03(\x0b2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOpt\
+ ion\"P\n\x10IdempotencyLevel\x12\x17\n\x13IDEMPOTENCY_UNKNOWN\x10\0\x12\
+ \x13\n\x0fNO_SIDE_EFFECTS\x10\x01\x12\x0e\n\nIDEMPOTENT\x10\x02*\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.Na\
+ mePartR\x04name\x12)\n\x10identifier_value\x18\x03\x20\x01(\tR\x0fidenti\
+ fierValue\x12,\n\x12positive_int_value\x18\x04\x20\x01(\x04R\x10positive\
+ IntValue\x12,\n\x12negative_int_value\x18\x05\x20\x01(\x03R\x10negativeI\
+ ntValue\x12!\n\x0cdouble_value\x18\x06\x20\x01(\x01R\x0bdoubleValue\x12!\
+ \n\x0cstring_value\x18\x07\x20\x01(\x0cR\x0bstringValue\x12'\n\x0faggreg\
+ ate_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.Loc\
+ ationR\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(\t\
+ R\x0fleadingComments\x12+\n\x11trailing_comments\x18\x04\x20\x01(\tR\x10\
+ trailingComments\x12:\n\x19leading_detached_comments\x18\x06\x20\x03(\tR\
+ \x17leadingDetachedComments\"\xd1\x01\n\x11GeneratedCodeInfo\x12M\n\nann\
+ otation\x18\x01\x20\x03(\x0b2-.google.protobuf.GeneratedCodeInfo.Annotat\
+ ionR\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\x03endB~\n\x13com.google.protobufB\x10Desc\
+ riptorProtosH\x01Z-google.golang.org/protobuf/types/descriptorpb\xf8\x01\
+ \x01\xa2\x02\x03GPB\xaa\x02\x1aGoogle.Protobuf.ReflectionJ\xbc\xc8\x02\n\
+ \x07\x12\x05'\0\x8c\x07\x01\n\xaa\x0f\n\x01\x0c\x12\x03'\0\x122\xc1\x0c\
+ \x20Protocol\x20Buffers\x20-\x20Google's\x20data\x20interchange\x20forma\
+ t\n\x20Copyright\x202008\x20Google\x20Inc.\x20\x20All\x20rights\x20reser\
+ ved.\n\x20https://developers.google.com/protocol-buffers/\n\n\x20Redistr\
+ ibution\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.\n2\xdb\x02\x20Author:\x20kenton@google.com\x20(Kenton\x20Varda)\n\
+ \x20\x20Based\x20on\x20original\x20Protocol\x20Buffers\x20design\x20by\n\
+ \x20\x20Sanjay\x20Ghemawat,\x20Jeff\x20Dean,\x20and\x20others.\n\n\x20Th\
+ e\x20messages\x20in\x20this\x20file\x20describe\x20the\x20definitions\
+ \x20found\x20in\x20.proto\x20files.\n\x20A\x20valid\x20.proto\x20file\
+ \x20can\x20be\x20translated\x20directly\x20to\x20a\x20FileDescriptorProt\
+ o\n\x20without\x20any\x20other\x20information\x20(e.g.\x20without\x20rea\
+ ding\x20its\x20imports).\n\n\x08\n\x01\x02\x12\x03)\0\x18\n\x08\n\x01\
+ \x08\x12\x03+\0D\n\t\n\x02\x08\x0b\x12\x03+\0D\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\x030\0\x1f\n\t\n\x02\x08\x1f\x12\x030\0\x1f\n\x08\n\x01\x08\x12\
+ \x034\0\x1c\n\x7f\n\x02\x08\t\x12\x034\0\x1c\x1at\x20descriptor.proto\
+ \x20must\x20be\x20optimized\x20for\x20speed\x20because\x20reflection-bas\
+ ed\n\x20algorithms\x20don't\x20work\x20during\x20bootstrapping.\n\nj\n\
+ \x02\x04\0\x12\x048\0:\x01\x1a^\x20The\x20protocol\x20compiler\x20can\
+ \x20output\x20a\x20FileDescriptorSet\x20containing\x20the\x20.proto\n\
+ \x20files\x20it\x20parses.\n\n\n\n\x03\x04\0\x01\x12\x038\x08\x19\n\x0b\
+ \n\x04\x04\0\x02\0\x12\x039\x02(\n\x0c\n\x05\x04\0\x02\0\x04\x12\x039\
+ \x02\n\n\x0c\n\x05\x04\0\x02\0\x06\x12\x039\x0b\x1e\n\x0c\n\x05\x04\0\
+ \x02\0\x01\x12\x039\x1f#\n\x0c\n\x05\x04\0\x02\0\x03\x12\x039&'\n/\n\x02\
+ \x04\x01\x12\x04=\0Z\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\x03B\x02!\x1a'\x20Names\x20of\x20files\x20im\
+ ported\x20by\x20this\x20file.\n\n\x0c\n\x05\x04\x01\x02\x02\x04\x12\x03B\
+ \x02\n\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03B\x0b\x11\n\x0c\n\x05\x04\
+ \x01\x02\x02\x01\x12\x03B\x12\x1c\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\
+ \x03B\x1f\x20\nQ\n\x04\x04\x01\x02\x03\x12\x03D\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\x03D\x02\n\n\x0c\n\
+ \x05\x04\x01\x02\x03\x05\x12\x03D\x0b\x10\n\x0c\n\x05\x04\x01\x02\x03\
+ \x01\x12\x03D\x11\"\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03D%'\nz\n\x04\
+ \x04\x01\x02\x04\x12\x03G\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\x03G\x02\n\n\x0c\n\x05\x04\x01\x02\x04\x05\x12\x03G\
+ \x0b\x10\n\x0c\n\x05\x04\x01\x02\x04\x01\x12\x03G\x11\x20\n\x0c\n\x05\
+ \x04\x01\x02\x04\x03\x12\x03G#%\n6\n\x04\x04\x01\x02\x05\x12\x03J\x02,\
+ \x1a)\x20All\x20top-level\x20definitions\x20in\x20this\x20file.\n\n\x0c\
+ \n\x05\x04\x01\x02\x05\x04\x12\x03J\x02\n\n\x0c\n\x05\x04\x01\x02\x05\
+ \x06\x12\x03J\x0b\x1a\n\x0c\n\x05\x04\x01\x02\x05\x01\x12\x03J\x1b'\n\
+ \x0c\n\x05\x04\x01\x02\x05\x03\x12\x03J*+\n\x0b\n\x04\x04\x01\x02\x06\
+ \x12\x03K\x02-\n\x0c\n\x05\x04\x01\x02\x06\x04\x12\x03K\x02\n\n\x0c\n\
+ \x05\x04\x01\x02\x06\x06\x12\x03K\x0b\x1e\n\x0c\n\x05\x04\x01\x02\x06\
+ \x01\x12\x03K\x1f(\n\x0c\n\x05\x04\x01\x02\x06\x03\x12\x03K+,\n\x0b\n\
+ \x04\x04\x01\x02\x07\x12\x03L\x02.\n\x0c\n\x05\x04\x01\x02\x07\x04\x12\
+ \x03L\x02\n\n\x0c\n\x05\x04\x01\x02\x07\x06\x12\x03L\x0b!\n\x0c\n\x05\
+ \x04\x01\x02\x07\x01\x12\x03L\")\n\x0c\n\x05\x04\x01\x02\x07\x03\x12\x03\
+ L,-\n\x0b\n\x04\x04\x01\x02\x08\x12\x03M\x02.\n\x0c\n\x05\x04\x01\x02\
+ \x08\x04\x12\x03M\x02\n\n\x0c\n\x05\x04\x01\x02\x08\x06\x12\x03M\x0b\x1f\
+ \n\x0c\n\x05\x04\x01\x02\x08\x01\x12\x03M\x20)\n\x0c\n\x05\x04\x01\x02\
+ \x08\x03\x12\x03M,-\n\x0b\n\x04\x04\x01\x02\t\x12\x03O\x02#\n\x0c\n\x05\
+ \x04\x01\x02\t\x04\x12\x03O\x02\n\n\x0c\n\x05\x04\x01\x02\t\x06\x12\x03O\
+ \x0b\x16\n\x0c\n\x05\x04\x01\x02\t\x01\x12\x03O\x17\x1e\n\x0c\n\x05\x04\
+ \x01\x02\t\x03\x12\x03O!\"\n\xf4\x01\n\x04\x04\x01\x02\n\x12\x03U\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\x03U\x02\n\n\x0c\n\x05\x04\x01\x02\n\x06\x12\x03U\
+ \x0b\x19\n\x0c\n\x05\x04\x01\x02\n\x01\x12\x03U\x1a*\n\x0c\n\x05\x04\x01\
+ \x02\n\x03\x12\x03U-.\n]\n\x04\x04\x01\x02\x0b\x12\x03Y\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\x03Y\x02\n\n\x0c\n\x05\x04\x01\x02\x0b\x05\x12\x03Y\x0b\
+ \x11\n\x0c\n\x05\x04\x01\x02\x0b\x01\x12\x03Y\x12\x18\n\x0c\n\x05\x04\
+ \x01\x02\x0b\x03\x12\x03Y\x1b\x1d\n'\n\x02\x04\x02\x12\x04]\0}\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\x03a\x02.\n\x0c\n\x05\x04\x02\x02\x02\x04\x12\x03a\x02\n\n\x0c\n\
+ \x05\x04\x02\x02\x02\x06\x12\x03a\x0b\x1f\n\x0c\n\x05\x04\x02\x02\x02\
+ \x01\x12\x03a\x20)\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\x03a,-\n\x0b\n\
+ \x04\x04\x02\x02\x03\x12\x03c\x02+\n\x0c\n\x05\x04\x02\x02\x03\x04\x12\
+ \x03c\x02\n\n\x0c\n\x05\x04\x02\x02\x03\x06\x12\x03c\x0b\x1a\n\x0c\n\x05\
+ \x04\x02\x02\x03\x01\x12\x03c\x1b&\n\x0c\n\x05\x04\x02\x02\x03\x03\x12\
+ \x03c)*\n\x0b\n\x04\x04\x02\x02\x04\x12\x03d\x02-\n\x0c\n\x05\x04\x02\
+ \x02\x04\x04\x12\x03d\x02\n\n\x0c\n\x05\x04\x02\x02\x04\x06\x12\x03d\x0b\
+ \x1e\n\x0c\n\x05\x04\x02\x02\x04\x01\x12\x03d\x1f(\n\x0c\n\x05\x04\x02\
+ \x02\x04\x03\x12\x03d+,\n\x0c\n\x04\x04\x02\x03\0\x12\x04f\x02k\x03\n\
+ \x0c\n\x05\x04\x02\x03\0\x01\x12\x03f\n\x18\n\x1b\n\x06\x04\x02\x03\0\
+ \x02\0\x12\x03g\x04\x1d\"\x0c\x20Inclusive.\n\n\x0e\n\x07\x04\x02\x03\0\
+ \x02\0\x04\x12\x03g\x04\x0c\n\x0e\n\x07\x04\x02\x03\0\x02\0\x05\x12\x03g\
+ \r\x12\n\x0e\n\x07\x04\x02\x03\0\x02\0\x01\x12\x03g\x13\x18\n\x0e\n\x07\
+ \x04\x02\x03\0\x02\0\x03\x12\x03g\x1b\x1c\n\x1b\n\x06\x04\x02\x03\0\x02\
+ \x01\x12\x03h\x04\x1b\"\x0c\x20Exclusive.\n\n\x0e\n\x07\x04\x02\x03\0\
+ \x02\x01\x04\x12\x03h\x04\x0c\n\x0e\n\x07\x04\x02\x03\0\x02\x01\x05\x12\
+ \x03h\r\x12\n\x0e\n\x07\x04\x02\x03\0\x02\x01\x01\x12\x03h\x13\x16\n\x0e\
+ \n\x07\x04\x02\x03\0\x02\x01\x03\x12\x03h\x19\x1a\n\r\n\x06\x04\x02\x03\
+ \0\x02\x02\x12\x03j\x04/\n\x0e\n\x07\x04\x02\x03\0\x02\x02\x04\x12\x03j\
+ \x04\x0c\n\x0e\n\x07\x04\x02\x03\0\x02\x02\x06\x12\x03j\r\"\n\x0e\n\x07\
+ \x04\x02\x03\0\x02\x02\x01\x12\x03j#*\n\x0e\n\x07\x04\x02\x03\0\x02\x02\
+ \x03\x12\x03j-.\n\x0b\n\x04\x04\x02\x02\x05\x12\x03l\x02.\n\x0c\n\x05\
+ \x04\x02\x02\x05\x04\x12\x03l\x02\n\n\x0c\n\x05\x04\x02\x02\x05\x06\x12\
+ \x03l\x0b\x19\n\x0c\n\x05\x04\x02\x02\x05\x01\x12\x03l\x1a)\n\x0c\n\x05\
+ \x04\x02\x02\x05\x03\x12\x03l,-\n\x0b\n\x04\x04\x02\x02\x06\x12\x03n\x02\
+ /\n\x0c\n\x05\x04\x02\x02\x06\x04\x12\x03n\x02\n\n\x0c\n\x05\x04\x02\x02\
+ \x06\x06\x12\x03n\x0b\x1f\n\x0c\n\x05\x04\x02\x02\x06\x01\x12\x03n\x20*\
+ \n\x0c\n\x05\x04\x02\x02\x06\x03\x12\x03n-.\n\x0b\n\x04\x04\x02\x02\x07\
+ \x12\x03p\x02&\n\x0c\n\x05\x04\x02\x02\x07\x04\x12\x03p\x02\n\n\x0c\n\
+ \x05\x04\x02\x02\x07\x06\x12\x03p\x0b\x19\n\x0c\n\x05\x04\x02\x02\x07\
+ \x01\x12\x03p\x1a!\n\x0c\n\x05\x04\x02\x02\x07\x03\x12\x03p$%\n\xaa\x01\
+ \n\x04\x04\x02\x03\x01\x12\x04u\x02x\x03\x1a\x9b\x01\x20Range\x20of\x20r\
+ eserved\x20tag\x20numbers.\x20Reserved\x20tag\x20numbers\x20may\x20not\
+ \x20be\x20used\x20by\n\x20fields\x20or\x20extension\x20ranges\x20in\x20t\
+ he\x20same\x20message.\x20Reserved\x20ranges\x20may\n\x20not\x20overlap.\
+ \n\n\x0c\n\x05\x04\x02\x03\x01\x01\x12\x03u\n\x17\n\x1b\n\x06\x04\x02\
+ \x03\x01\x02\0\x12\x03v\x04\x1d\"\x0c\x20Inclusive.\n\n\x0e\n\x07\x04\
+ \x02\x03\x01\x02\0\x04\x12\x03v\x04\x0c\n\x0e\n\x07\x04\x02\x03\x01\x02\
+ \0\x05\x12\x03v\r\x12\n\x0e\n\x07\x04\x02\x03\x01\x02\0\x01\x12\x03v\x13\
+ \x18\n\x0e\n\x07\x04\x02\x03\x01\x02\0\x03\x12\x03v\x1b\x1c\n\x1b\n\x06\
+ \x04\x02\x03\x01\x02\x01\x12\x03w\x04\x1b\"\x0c\x20Exclusive.\n\n\x0e\n\
+ \x07\x04\x02\x03\x01\x02\x01\x04\x12\x03w\x04\x0c\n\x0e\n\x07\x04\x02\
+ \x03\x01\x02\x01\x05\x12\x03w\r\x12\n\x0e\n\x07\x04\x02\x03\x01\x02\x01\
+ \x01\x12\x03w\x13\x16\n\x0e\n\x07\x04\x02\x03\x01\x02\x01\x03\x12\x03w\
+ \x19\x1a\n\x0b\n\x04\x04\x02\x02\x08\x12\x03y\x02,\n\x0c\n\x05\x04\x02\
+ \x02\x08\x04\x12\x03y\x02\n\n\x0c\n\x05\x04\x02\x02\x08\x06\x12\x03y\x0b\
+ \x18\n\x0c\n\x05\x04\x02\x02\x08\x01\x12\x03y\x19'\n\x0c\n\x05\x04\x02\
+ \x02\x08\x03\x12\x03y*+\n\x82\x01\n\x04\x04\x02\x02\t\x12\x03|\x02%\x1au\
+ \x20Reserved\x20field\x20names,\x20which\x20may\x20not\x20be\x20used\x20\
+ by\x20fields\x20in\x20the\x20same\x20message.\n\x20A\x20given\x20name\
+ \x20may\x20only\x20be\x20reserved\x20once.\n\n\x0c\n\x05\x04\x02\x02\t\
+ \x04\x12\x03|\x02\n\n\x0c\n\x05\x04\x02\x02\t\x05\x12\x03|\x0b\x11\n\x0c\
+ \n\x05\x04\x02\x02\t\x01\x12\x03|\x12\x1f\n\x0c\n\x05\x04\x02\x02\t\x03\
+ \x12\x03|\"$\n\x0b\n\x02\x04\x03\x12\x05\x7f\0\x86\x01\x01\n\n\n\x03\x04\
+ \x03\x01\x12\x03\x7f\x08\x1d\nO\n\x04\x04\x03\x02\0\x12\x04\x81\x01\x02:\
+ \x1aA\x20The\x20parser\x20stores\x20options\x20it\x20doesn't\x20recogniz\
+ e\x20here.\x20See\x20above.\n\n\r\n\x05\x04\x03\x02\0\x04\x12\x04\x81\
+ \x01\x02\n\n\r\n\x05\x04\x03\x02\0\x06\x12\x04\x81\x01\x0b\x1e\n\r\n\x05\
+ \x04\x03\x02\0\x01\x12\x04\x81\x01\x1f3\n\r\n\x05\x04\x03\x02\0\x03\x12\
+ \x04\x81\x0169\nZ\n\x03\x04\x03\x05\x12\x04\x85\x01\x02\x19\x1aM\x20Clie\
+ nts\x20can\x20define\x20custom\x20options\x20in\x20extensions\x20of\x20t\
+ his\x20message.\x20See\x20above.\n\n\x0c\n\x04\x04\x03\x05\0\x12\x04\x85\
+ \x01\r\x18\n\r\n\x05\x04\x03\x05\0\x01\x12\x04\x85\x01\r\x11\n\r\n\x05\
+ \x04\x03\x05\0\x02\x12\x04\x85\x01\x15\x18\n3\n\x02\x04\x04\x12\x06\x89\
+ \x01\0\xee\x01\x01\x1a%\x20Describes\x20a\x20field\x20within\x20a\x20mes\
+ sage.\n\n\x0b\n\x03\x04\x04\x01\x12\x04\x89\x01\x08\x1c\n\x0e\n\x04\x04\
+ \x04\x04\0\x12\x06\x8a\x01\x02\xa9\x01\x03\n\r\n\x05\x04\x04\x04\0\x01\
+ \x12\x04\x8a\x01\x07\x0b\nS\n\x06\x04\x04\x04\0\x02\0\x12\x04\x8d\x01\
+ \x04\x14\x1aC\x200\x20is\x20reserved\x20for\x20errors.\n\x20Order\x20is\
+ \x20weird\x20for\x20historical\x20reasons.\n\n\x0f\n\x07\x04\x04\x04\0\
+ \x02\0\x01\x12\x04\x8d\x01\x04\x0f\n\x0f\n\x07\x04\x04\x04\0\x02\0\x02\
+ \x12\x04\x8d\x01\x12\x13\n\x0e\n\x06\x04\x04\x04\0\x02\x01\x12\x04\x8e\
+ \x01\x04\x13\n\x0f\n\x07\x04\x04\x04\0\x02\x01\x01\x12\x04\x8e\x01\x04\
+ \x0e\n\x0f\n\x07\x04\x04\x04\0\x02\x01\x02\x12\x04\x8e\x01\x11\x12\nw\n\
+ \x06\x04\x04\x04\0\x02\x02\x12\x04\x91\x01\x04\x13\x1ag\x20Not\x20ZigZag\
+ \x20encoded.\x20\x20Negative\x20numbers\x20take\x2010\x20bytes.\x20\x20U\
+ se\x20TYPE_SINT64\x20if\n\x20negative\x20values\x20are\x20likely.\n\n\
+ \x0f\n\x07\x04\x04\x04\0\x02\x02\x01\x12\x04\x91\x01\x04\x0e\n\x0f\n\x07\
+ \x04\x04\x04\0\x02\x02\x02\x12\x04\x91\x01\x11\x12\n\x0e\n\x06\x04\x04\
+ \x04\0\x02\x03\x12\x04\x92\x01\x04\x14\n\x0f\n\x07\x04\x04\x04\0\x02\x03\
+ \x01\x12\x04\x92\x01\x04\x0f\n\x0f\n\x07\x04\x04\x04\0\x02\x03\x02\x12\
+ \x04\x92\x01\x12\x13\nw\n\x06\x04\x04\x04\0\x02\x04\x12\x04\x95\x01\x04\
+ \x13\x1ag\x20Not\x20ZigZag\x20encoded.\x20\x20Negative\x20numbers\x20tak\
+ e\x2010\x20bytes.\x20\x20Use\x20TYPE_SINT32\x20if\n\x20negative\x20value\
+ s\x20are\x20likely.\n\n\x0f\n\x07\x04\x04\x04\0\x02\x04\x01\x12\x04\x95\
+ \x01\x04\x0e\n\x0f\n\x07\x04\x04\x04\0\x02\x04\x02\x12\x04\x95\x01\x11\
+ \x12\n\x0e\n\x06\x04\x04\x04\0\x02\x05\x12\x04\x96\x01\x04\x15\n\x0f\n\
+ \x07\x04\x04\x04\0\x02\x05\x01\x12\x04\x96\x01\x04\x10\n\x0f\n\x07\x04\
+ \x04\x04\0\x02\x05\x02\x12\x04\x96\x01\x13\x14\n\x0e\n\x06\x04\x04\x04\0\
+ \x02\x06\x12\x04\x97\x01\x04\x15\n\x0f\n\x07\x04\x04\x04\0\x02\x06\x01\
+ \x12\x04\x97\x01\x04\x10\n\x0f\n\x07\x04\x04\x04\0\x02\x06\x02\x12\x04\
+ \x97\x01\x13\x14\n\x0e\n\x06\x04\x04\x04\0\x02\x07\x12\x04\x98\x01\x04\
+ \x12\n\x0f\n\x07\x04\x04\x04\0\x02\x07\x01\x12\x04\x98\x01\x04\r\n\x0f\n\
+ \x07\x04\x04\x04\0\x02\x07\x02\x12\x04\x98\x01\x10\x11\n\x0e\n\x06\x04\
+ \x04\x04\0\x02\x08\x12\x04\x99\x01\x04\x14\n\x0f\n\x07\x04\x04\x04\0\x02\
+ \x08\x01\x12\x04\x99\x01\x04\x0f\n\x0f\n\x07\x04\x04\x04\0\x02\x08\x02\
+ \x12\x04\x99\x01\x12\x13\n\xe2\x01\n\x06\x04\x04\x04\0\x02\t\x12\x04\x9e\
+ \x01\x04\x14\x1a\xd1\x01\x20Tag-delimited\x20aggregate.\n\x20Group\x20ty\
+ pe\x20is\x20deprecated\x20and\x20not\x20supported\x20in\x20proto3.\x20Ho\
+ wever,\x20Proto3\n\x20implementations\x20should\x20still\x20be\x20able\
+ \x20to\x20parse\x20the\x20group\x20wire\x20format\x20and\n\x20treat\x20g\
+ roup\x20fields\x20as\x20unknown\x20fields.\n\n\x0f\n\x07\x04\x04\x04\0\
+ \x02\t\x01\x12\x04\x9e\x01\x04\x0e\n\x0f\n\x07\x04\x04\x04\0\x02\t\x02\
+ \x12\x04\x9e\x01\x11\x13\n-\n\x06\x04\x04\x04\0\x02\n\x12\x04\x9f\x01\
+ \x04\x16\"\x1d\x20Length-delimited\x20aggregate.\n\n\x0f\n\x07\x04\x04\
+ \x04\0\x02\n\x01\x12\x04\x9f\x01\x04\x10\n\x0f\n\x07\x04\x04\x04\0\x02\n\
+ \x02\x12\x04\x9f\x01\x13\x15\n#\n\x06\x04\x04\x04\0\x02\x0b\x12\x04\xa2\
+ \x01\x04\x14\x1a\x13\x20New\x20in\x20version\x202.\n\n\x0f\n\x07\x04\x04\
+ \x04\0\x02\x0b\x01\x12\x04\xa2\x01\x04\x0e\n\x0f\n\x07\x04\x04\x04\0\x02\
+ \x0b\x02\x12\x04\xa2\x01\x11\x13\n\x0e\n\x06\x04\x04\x04\0\x02\x0c\x12\
+ \x04\xa3\x01\x04\x15\n\x0f\n\x07\x04\x04\x04\0\x02\x0c\x01\x12\x04\xa3\
+ \x01\x04\x0f\n\x0f\n\x07\x04\x04\x04\0\x02\x0c\x02\x12\x04\xa3\x01\x12\
+ \x14\n\x0e\n\x06\x04\x04\x04\0\x02\r\x12\x04\xa4\x01\x04\x13\n\x0f\n\x07\
+ \x04\x04\x04\0\x02\r\x01\x12\x04\xa4\x01\x04\r\n\x0f\n\x07\x04\x04\x04\0\
+ \x02\r\x02\x12\x04\xa4\x01\x10\x12\n\x0e\n\x06\x04\x04\x04\0\x02\x0e\x12\
+ \x04\xa5\x01\x04\x17\n\x0f\n\x07\x04\x04\x04\0\x02\x0e\x01\x12\x04\xa5\
+ \x01\x04\x11\n\x0f\n\x07\x04\x04\x04\0\x02\x0e\x02\x12\x04\xa5\x01\x14\
+ \x16\n\x0e\n\x06\x04\x04\x04\0\x02\x0f\x12\x04\xa6\x01\x04\x17\n\x0f\n\
+ \x07\x04\x04\x04\0\x02\x0f\x01\x12\x04\xa6\x01\x04\x11\n\x0f\n\x07\x04\
+ \x04\x04\0\x02\x0f\x02\x12\x04\xa6\x01\x14\x16\n'\n\x06\x04\x04\x04\0\
+ \x02\x10\x12\x04\xa7\x01\x04\x15\"\x17\x20Uses\x20ZigZag\x20encoding.\n\
+ \n\x0f\n\x07\x04\x04\x04\0\x02\x10\x01\x12\x04\xa7\x01\x04\x0f\n\x0f\n\
+ \x07\x04\x04\x04\0\x02\x10\x02\x12\x04\xa7\x01\x12\x14\n'\n\x06\x04\x04\
+ \x04\0\x02\x11\x12\x04\xa8\x01\x04\x15\"\x17\x20Uses\x20ZigZag\x20encodi\
+ ng.\n\n\x0f\n\x07\x04\x04\x04\0\x02\x11\x01\x12\x04\xa8\x01\x04\x0f\n\
+ \x0f\n\x07\x04\x04\x04\0\x02\x11\x02\x12\x04\xa8\x01\x12\x14\n\x0e\n\x04\
+ \x04\x04\x04\x01\x12\x06\xab\x01\x02\xb0\x01\x03\n\r\n\x05\x04\x04\x04\
+ \x01\x01\x12\x04\xab\x01\x07\x0c\n*\n\x06\x04\x04\x04\x01\x02\0\x12\x04\
+ \xad\x01\x04\x17\x1a\x1a\x200\x20is\x20reserved\x20for\x20errors\n\n\x0f\
+ \n\x07\x04\x04\x04\x01\x02\0\x01\x12\x04\xad\x01\x04\x12\n\x0f\n\x07\x04\
+ \x04\x04\x01\x02\0\x02\x12\x04\xad\x01\x15\x16\n\x0e\n\x06\x04\x04\x04\
+ \x01\x02\x01\x12\x04\xae\x01\x04\x17\n\x0f\n\x07\x04\x04\x04\x01\x02\x01\
+ \x01\x12\x04\xae\x01\x04\x12\n\x0f\n\x07\x04\x04\x04\x01\x02\x01\x02\x12\
+ \x04\xae\x01\x15\x16\n\x0e\n\x06\x04\x04\x04\x01\x02\x02\x12\x04\xaf\x01\
+ \x04\x17\n\x0f\n\x07\x04\x04\x04\x01\x02\x02\x01\x12\x04\xaf\x01\x04\x12\
+ \n\x0f\n\x07\x04\x04\x04\x01\x02\x02\x02\x12\x04\xaf\x01\x15\x16\n\x0c\n\
+ \x04\x04\x04\x02\0\x12\x04\xb2\x01\x02\x1b\n\r\n\x05\x04\x04\x02\0\x04\
+ \x12\x04\xb2\x01\x02\n\n\r\n\x05\x04\x04\x02\0\x05\x12\x04\xb2\x01\x0b\
+ \x11\n\r\n\x05\x04\x04\x02\0\x01\x12\x04\xb2\x01\x12\x16\n\r\n\x05\x04\
+ \x04\x02\0\x03\x12\x04\xb2\x01\x19\x1a\n\x0c\n\x04\x04\x04\x02\x01\x12\
+ \x04\xb3\x01\x02\x1c\n\r\n\x05\x04\x04\x02\x01\x04\x12\x04\xb3\x01\x02\n\
+ \n\r\n\x05\x04\x04\x02\x01\x05\x12\x04\xb3\x01\x0b\x10\n\r\n\x05\x04\x04\
+ \x02\x01\x01\x12\x04\xb3\x01\x11\x17\n\r\n\x05\x04\x04\x02\x01\x03\x12\
+ \x04\xb3\x01\x1a\x1b\n\x0c\n\x04\x04\x04\x02\x02\x12\x04\xb4\x01\x02\x1b\
+ \n\r\n\x05\x04\x04\x02\x02\x04\x12\x04\xb4\x01\x02\n\n\r\n\x05\x04\x04\
+ \x02\x02\x06\x12\x04\xb4\x01\x0b\x10\n\r\n\x05\x04\x04\x02\x02\x01\x12\
+ \x04\xb4\x01\x11\x16\n\r\n\x05\x04\x04\x02\x02\x03\x12\x04\xb4\x01\x19\
+ \x1a\n\x9c\x01\n\x04\x04\x04\x02\x03\x12\x04\xb8\x01\x02\x19\x1a\x8d\x01\
+ \x20If\x20type_name\x20is\x20set,\x20this\x20need\x20not\x20be\x20set.\
+ \x20\x20If\x20both\x20this\x20and\x20type_name\n\x20are\x20set,\x20this\
+ \x20must\x20be\x20one\x20of\x20TYPE_ENUM,\x20TYPE_MESSAGE\x20or\x20TYPE_\
+ GROUP.\n\n\r\n\x05\x04\x04\x02\x03\x04\x12\x04\xb8\x01\x02\n\n\r\n\x05\
+ \x04\x04\x02\x03\x06\x12\x04\xb8\x01\x0b\x0f\n\r\n\x05\x04\x04\x02\x03\
+ \x01\x12\x04\xb8\x01\x10\x14\n\r\n\x05\x04\x04\x02\x03\x03\x12\x04\xb8\
+ \x01\x17\x18\n\xb7\x02\n\x04\x04\x04\x02\x04\x12\x04\xbf\x01\x02\x20\x1a\
+ \xa8\x02\x20For\x20message\x20and\x20enum\x20types,\x20this\x20is\x20the\
+ \x20name\x20of\x20the\x20type.\x20\x20If\x20the\x20name\n\x20starts\x20w\
+ ith\x20a\x20'.',\x20it\x20is\x20fully-qualified.\x20\x20Otherwise,\x20C+\
+ +-like\x20scoping\n\x20rules\x20are\x20used\x20to\x20find\x20the\x20type\
+ \x20(i.e.\x20first\x20the\x20nested\x20types\x20within\x20this\n\x20mess\
+ age\x20are\x20searched,\x20then\x20within\x20the\x20parent,\x20on\x20up\
+ \x20to\x20the\x20root\n\x20namespace).\n\n\r\n\x05\x04\x04\x02\x04\x04\
+ \x12\x04\xbf\x01\x02\n\n\r\n\x05\x04\x04\x02\x04\x05\x12\x04\xbf\x01\x0b\
+ \x11\n\r\n\x05\x04\x04\x02\x04\x01\x12\x04\xbf\x01\x12\x1b\n\r\n\x05\x04\
+ \x04\x02\x04\x03\x12\x04\xbf\x01\x1e\x1f\n~\n\x04\x04\x04\x02\x05\x12\
+ \x04\xc3\x01\x02\x1f\x1ap\x20For\x20extensions,\x20this\x20is\x20the\x20\
+ name\x20of\x20the\x20type\x20being\x20extended.\x20\x20It\x20is\n\x20res\
+ olved\x20in\x20the\x20same\x20manner\x20as\x20type_name.\n\n\r\n\x05\x04\
+ \x04\x02\x05\x04\x12\x04\xc3\x01\x02\n\n\r\n\x05\x04\x04\x02\x05\x05\x12\
+ \x04\xc3\x01\x0b\x11\n\r\n\x05\x04\x04\x02\x05\x01\x12\x04\xc3\x01\x12\
+ \x1a\n\r\n\x05\x04\x04\x02\x05\x03\x12\x04\xc3\x01\x1d\x1e\n\xb1\x02\n\
+ \x04\x04\x04\x02\x06\x12\x04\xca\x01\x02$\x1a\xa2\x02\x20For\x20numeric\
+ \x20types,\x20contains\x20the\x20original\x20text\x20representation\x20o\
+ f\x20the\x20value.\n\x20For\x20booleans,\x20\"true\"\x20or\x20\"false\".\
+ \n\x20For\x20strings,\x20contains\x20the\x20default\x20text\x20contents\
+ \x20(not\x20escaped\x20in\x20any\x20way).\n\x20For\x20bytes,\x20contains\
+ \x20the\x20C\x20escaped\x20value.\x20\x20All\x20bytes\x20>=\x20128\x20ar\
+ e\x20escaped.\n\x20TODO(kenton):\x20\x20Base-64\x20encode?\n\n\r\n\x05\
+ \x04\x04\x02\x06\x04\x12\x04\xca\x01\x02\n\n\r\n\x05\x04\x04\x02\x06\x05\
+ \x12\x04\xca\x01\x0b\x11\n\r\n\x05\x04\x04\x02\x06\x01\x12\x04\xca\x01\
+ \x12\x1f\n\r\n\x05\x04\x04\x02\x06\x03\x12\x04\xca\x01\"#\n\x84\x01\n\
+ \x04\x04\x04\x02\x07\x12\x04\xce\x01\x02!\x1av\x20If\x20set,\x20gives\
+ \x20the\x20index\x20of\x20a\x20oneof\x20in\x20the\x20containing\x20type'\
+ s\x20oneof_decl\n\x20list.\x20\x20This\x20field\x20is\x20a\x20member\x20\
+ of\x20that\x20oneof.\n\n\r\n\x05\x04\x04\x02\x07\x04\x12\x04\xce\x01\x02\
+ \n\n\r\n\x05\x04\x04\x02\x07\x05\x12\x04\xce\x01\x0b\x10\n\r\n\x05\x04\
+ \x04\x02\x07\x01\x12\x04\xce\x01\x11\x1c\n\r\n\x05\x04\x04\x02\x07\x03\
+ \x12\x04\xce\x01\x1f\x20\n\xfa\x01\n\x04\x04\x04\x02\x08\x12\x04\xd4\x01\
+ \x02!\x1a\xeb\x01\x20JSON\x20name\x20of\x20this\x20field.\x20The\x20valu\
+ e\x20is\x20set\x20by\x20protocol\x20compiler.\x20If\x20the\n\x20user\x20\
+ has\x20set\x20a\x20\"json_name\"\x20option\x20on\x20this\x20field,\x20th\
+ at\x20option's\x20value\n\x20will\x20be\x20used.\x20Otherwise,\x20it's\
+ \x20deduced\x20from\x20the\x20field's\x20name\x20by\x20converting\n\x20i\
+ t\x20to\x20camelCase.\n\n\r\n\x05\x04\x04\x02\x08\x04\x12\x04\xd4\x01\
+ \x02\n\n\r\n\x05\x04\x04\x02\x08\x05\x12\x04\xd4\x01\x0b\x11\n\r\n\x05\
+ \x04\x04\x02\x08\x01\x12\x04\xd4\x01\x12\x1b\n\r\n\x05\x04\x04\x02\x08\
+ \x03\x12\x04\xd4\x01\x1e\x20\n\x0c\n\x04\x04\x04\x02\t\x12\x04\xd6\x01\
+ \x02$\n\r\n\x05\x04\x04\x02\t\x04\x12\x04\xd6\x01\x02\n\n\r\n\x05\x04\
+ \x04\x02\t\x06\x12\x04\xd6\x01\x0b\x17\n\r\n\x05\x04\x04\x02\t\x01\x12\
+ \x04\xd6\x01\x18\x1f\n\r\n\x05\x04\x04\x02\t\x03\x12\x04\xd6\x01\"#\n\
+ \xb3\t\n\x04\x04\x04\x02\n\x12\x04\xed\x01\x02%\x1a\xa4\t\x20If\x20true,\
+ \x20this\x20is\x20a\x20proto3\x20\"optional\".\x20When\x20a\x20proto3\
+ \x20field\x20is\x20optional,\x20it\n\x20tracks\x20presence\x20regardless\
+ \x20of\x20field\x20type.\n\n\x20When\x20proto3_optional\x20is\x20true,\
+ \x20this\x20field\x20must\x20be\x20belong\x20to\x20a\x20oneof\x20to\n\
+ \x20signal\x20to\x20old\x20proto3\x20clients\x20that\x20presence\x20is\
+ \x20tracked\x20for\x20this\x20field.\x20This\n\x20oneof\x20is\x20known\
+ \x20as\x20a\x20\"synthetic\"\x20oneof,\x20and\x20this\x20field\x20must\
+ \x20be\x20its\x20sole\n\x20member\x20(each\x20proto3\x20optional\x20fiel\
+ d\x20gets\x20its\x20own\x20synthetic\x20oneof).\x20Synthetic\n\x20oneofs\
+ \x20exist\x20in\x20the\x20descriptor\x20only,\x20and\x20do\x20not\x20gen\
+ erate\x20any\x20API.\x20Synthetic\n\x20oneofs\x20must\x20be\x20ordered\
+ \x20after\x20all\x20\"real\"\x20oneofs.\n\n\x20For\x20message\x20fields,\
+ \x20proto3_optional\x20doesn't\x20create\x20any\x20semantic\x20change,\n\
+ \x20since\x20non-repeated\x20message\x20fields\x20always\x20track\x20pre\
+ sence.\x20However\x20it\x20still\n\x20indicates\x20the\x20semantic\x20de\
+ tail\x20of\x20whether\x20the\x20user\x20wrote\x20\"optional\"\x20or\x20n\
+ ot.\n\x20This\x20can\x20be\x20useful\x20for\x20round-tripping\x20the\x20\
+ .proto\x20file.\x20For\x20consistency\x20we\n\x20give\x20message\x20fiel\
+ ds\x20a\x20synthetic\x20oneof\x20also,\x20even\x20though\x20it\x20is\x20\
+ not\x20required\n\x20to\x20track\x20presence.\x20This\x20is\x20especiall\
+ y\x20important\x20because\x20the\x20parser\x20can't\n\x20tell\x20if\x20a\
+ \x20field\x20is\x20a\x20message\x20or\x20an\x20enum,\x20so\x20it\x20must\
+ \x20always\x20create\x20a\n\x20synthetic\x20oneof.\n\n\x20Proto2\x20opti\
+ onal\x20fields\x20do\x20not\x20set\x20this\x20flag,\x20because\x20they\
+ \x20already\x20indicate\n\x20optional\x20with\x20`LABEL_OPTIONAL`.\n\n\r\
+ \n\x05\x04\x04\x02\n\x04\x12\x04\xed\x01\x02\n\n\r\n\x05\x04\x04\x02\n\
+ \x05\x12\x04\xed\x01\x0b\x0f\n\r\n\x05\x04\x04\x02\n\x01\x12\x04\xed\x01\
+ \x10\x1f\n\r\n\x05\x04\x04\x02\n\x03\x12\x04\xed\x01\"$\n\"\n\x02\x04\
+ \x05\x12\x06\xf1\x01\0\xf4\x01\x01\x1a\x14\x20Describes\x20a\x20oneof.\n\
+ \n\x0b\n\x03\x04\x05\x01\x12\x04\xf1\x01\x08\x1c\n\x0c\n\x04\x04\x05\x02\
+ \0\x12\x04\xf2\x01\x02\x1b\n\r\n\x05\x04\x05\x02\0\x04\x12\x04\xf2\x01\
+ \x02\n\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\xf2\x01\x0b\x11\n\r\n\x05\x04\
+ \x05\x02\0\x01\x12\x04\xf2\x01\x12\x16\n\r\n\x05\x04\x05\x02\0\x03\x12\
+ \x04\xf2\x01\x19\x1a\n\x0c\n\x04\x04\x05\x02\x01\x12\x04\xf3\x01\x02$\n\
+ \r\n\x05\x04\x05\x02\x01\x04\x12\x04\xf3\x01\x02\n\n\r\n\x05\x04\x05\x02\
+ \x01\x06\x12\x04\xf3\x01\x0b\x17\n\r\n\x05\x04\x05\x02\x01\x01\x12\x04\
+ \xf3\x01\x18\x1f\n\r\n\x05\x04\x05\x02\x01\x03\x12\x04\xf3\x01\"#\n'\n\
+ \x02\x04\x06\x12\x06\xf7\x01\0\x91\x02\x01\x1a\x19\x20Describes\x20an\
+ \x20enum\x20type.\n\n\x0b\n\x03\x04\x06\x01\x12\x04\xf7\x01\x08\x1b\n\
+ \x0c\n\x04\x04\x06\x02\0\x12\x04\xf8\x01\x02\x1b\n\r\n\x05\x04\x06\x02\0\
+ \x04\x12\x04\xf8\x01\x02\n\n\r\n\x05\x04\x06\x02\0\x05\x12\x04\xf8\x01\
+ \x0b\x11\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\xf8\x01\x12\x16\n\r\n\x05\
+ \x04\x06\x02\0\x03\x12\x04\xf8\x01\x19\x1a\n\x0c\n\x04\x04\x06\x02\x01\
+ \x12\x04\xfa\x01\x02.\n\r\n\x05\x04\x06\x02\x01\x04\x12\x04\xfa\x01\x02\
+ \n\n\r\n\x05\x04\x06\x02\x01\x06\x12\x04\xfa\x01\x0b#\n\r\n\x05\x04\x06\
+ \x02\x01\x01\x12\x04\xfa\x01$)\n\r\n\x05\x04\x06\x02\x01\x03\x12\x04\xfa\
+ \x01,-\n\x0c\n\x04\x04\x06\x02\x02\x12\x04\xfc\x01\x02#\n\r\n\x05\x04\
+ \x06\x02\x02\x04\x12\x04\xfc\x01\x02\n\n\r\n\x05\x04\x06\x02\x02\x06\x12\
+ \x04\xfc\x01\x0b\x16\n\r\n\x05\x04\x06\x02\x02\x01\x12\x04\xfc\x01\x17\
+ \x1e\n\r\n\x05\x04\x06\x02\x02\x03\x12\x04\xfc\x01!\"\n\xaf\x02\n\x04\
+ \x04\x06\x03\0\x12\x06\x84\x02\x02\x87\x02\x03\x1a\x9e\x02\x20Range\x20o\
+ f\x20reserved\x20numeric\x20values.\x20Reserved\x20values\x20may\x20not\
+ \x20be\x20used\x20by\n\x20entries\x20in\x20the\x20same\x20enum.\x20Reser\
+ ved\x20ranges\x20may\x20not\x20overlap.\n\n\x20Note\x20that\x20this\x20i\
+ s\x20distinct\x20from\x20DescriptorProto.ReservedRange\x20in\x20that\x20\
+ it\n\x20is\x20inclusive\x20such\x20that\x20it\x20can\x20appropriately\
+ \x20represent\x20the\x20entire\x20int32\n\x20domain.\n\n\r\n\x05\x04\x06\
+ \x03\0\x01\x12\x04\x84\x02\n\x1b\n\x1c\n\x06\x04\x06\x03\0\x02\0\x12\x04\
+ \x85\x02\x04\x1d\"\x0c\x20Inclusive.\n\n\x0f\n\x07\x04\x06\x03\0\x02\0\
+ \x04\x12\x04\x85\x02\x04\x0c\n\x0f\n\x07\x04\x06\x03\0\x02\0\x05\x12\x04\
+ \x85\x02\r\x12\n\x0f\n\x07\x04\x06\x03\0\x02\0\x01\x12\x04\x85\x02\x13\
+ \x18\n\x0f\n\x07\x04\x06\x03\0\x02\0\x03\x12\x04\x85\x02\x1b\x1c\n\x1c\n\
+ \x06\x04\x06\x03\0\x02\x01\x12\x04\x86\x02\x04\x1b\"\x0c\x20Inclusive.\n\
+ \n\x0f\n\x07\x04\x06\x03\0\x02\x01\x04\x12\x04\x86\x02\x04\x0c\n\x0f\n\
+ \x07\x04\x06\x03\0\x02\x01\x05\x12\x04\x86\x02\r\x12\n\x0f\n\x07\x04\x06\
+ \x03\0\x02\x01\x01\x12\x04\x86\x02\x13\x16\n\x0f\n\x07\x04\x06\x03\0\x02\
+ \x01\x03\x12\x04\x86\x02\x19\x1a\n\xaa\x01\n\x04\x04\x06\x02\x03\x12\x04\
+ \x8c\x02\x020\x1a\x9b\x01\x20Range\x20of\x20reserved\x20numeric\x20value\
+ s.\x20Reserved\x20numeric\x20values\x20may\x20not\x20be\x20used\n\x20by\
+ \x20enum\x20values\x20in\x20the\x20same\x20enum\x20declaration.\x20Reser\
+ ved\x20ranges\x20may\x20not\n\x20overlap.\n\n\r\n\x05\x04\x06\x02\x03\
+ \x04\x12\x04\x8c\x02\x02\n\n\r\n\x05\x04\x06\x02\x03\x06\x12\x04\x8c\x02\
+ \x0b\x1c\n\r\n\x05\x04\x06\x02\x03\x01\x12\x04\x8c\x02\x1d+\n\r\n\x05\
+ \x04\x06\x02\x03\x03\x12\x04\x8c\x02./\nl\n\x04\x04\x06\x02\x04\x12\x04\
+ \x90\x02\x02$\x1a^\x20Reserved\x20enum\x20value\x20names,\x20which\x20ma\
+ y\x20not\x20be\x20reused.\x20A\x20given\x20name\x20may\x20only\n\x20be\
+ \x20reserved\x20once.\n\n\r\n\x05\x04\x06\x02\x04\x04\x12\x04\x90\x02\
+ \x02\n\n\r\n\x05\x04\x06\x02\x04\x05\x12\x04\x90\x02\x0b\x11\n\r\n\x05\
+ \x04\x06\x02\x04\x01\x12\x04\x90\x02\x12\x1f\n\r\n\x05\x04\x06\x02\x04\
+ \x03\x12\x04\x90\x02\"#\n1\n\x02\x04\x07\x12\x06\x94\x02\0\x99\x02\x01\
+ \x1a#\x20Describes\x20a\x20value\x20within\x20an\x20enum.\n\n\x0b\n\x03\
+ \x04\x07\x01\x12\x04\x94\x02\x08\x20\n\x0c\n\x04\x04\x07\x02\0\x12\x04\
+ \x95\x02\x02\x1b\n\r\n\x05\x04\x07\x02\0\x04\x12\x04\x95\x02\x02\n\n\r\n\
+ \x05\x04\x07\x02\0\x05\x12\x04\x95\x02\x0b\x11\n\r\n\x05\x04\x07\x02\0\
+ \x01\x12\x04\x95\x02\x12\x16\n\r\n\x05\x04\x07\x02\0\x03\x12\x04\x95\x02\
+ \x19\x1a\n\x0c\n\x04\x04\x07\x02\x01\x12\x04\x96\x02\x02\x1c\n\r\n\x05\
+ \x04\x07\x02\x01\x04\x12\x04\x96\x02\x02\n\n\r\n\x05\x04\x07\x02\x01\x05\
+ \x12\x04\x96\x02\x0b\x10\n\r\n\x05\x04\x07\x02\x01\x01\x12\x04\x96\x02\
+ \x11\x17\n\r\n\x05\x04\x07\x02\x01\x03\x12\x04\x96\x02\x1a\x1b\n\x0c\n\
+ \x04\x04\x07\x02\x02\x12\x04\x98\x02\x02(\n\r\n\x05\x04\x07\x02\x02\x04\
+ \x12\x04\x98\x02\x02\n\n\r\n\x05\x04\x07\x02\x02\x06\x12\x04\x98\x02\x0b\
+ \x1b\n\r\n\x05\x04\x07\x02\x02\x01\x12\x04\x98\x02\x1c#\n\r\n\x05\x04\
+ \x07\x02\x02\x03\x12\x04\x98\x02&'\n$\n\x02\x04\x08\x12\x06\x9c\x02\0\
+ \xa1\x02\x01\x1a\x16\x20Describes\x20a\x20service.\n\n\x0b\n\x03\x04\x08\
+ \x01\x12\x04\x9c\x02\x08\x1e\n\x0c\n\x04\x04\x08\x02\0\x12\x04\x9d\x02\
+ \x02\x1b\n\r\n\x05\x04\x08\x02\0\x04\x12\x04\x9d\x02\x02\n\n\r\n\x05\x04\
+ \x08\x02\0\x05\x12\x04\x9d\x02\x0b\x11\n\r\n\x05\x04\x08\x02\0\x01\x12\
+ \x04\x9d\x02\x12\x16\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\x9d\x02\x19\x1a\
+ \n\x0c\n\x04\x04\x08\x02\x01\x12\x04\x9e\x02\x02,\n\r\n\x05\x04\x08\x02\
+ \x01\x04\x12\x04\x9e\x02\x02\n\n\r\n\x05\x04\x08\x02\x01\x06\x12\x04\x9e\
+ \x02\x0b\x20\n\r\n\x05\x04\x08\x02\x01\x01\x12\x04\x9e\x02!'\n\r\n\x05\
+ \x04\x08\x02\x01\x03\x12\x04\x9e\x02*+\n\x0c\n\x04\x04\x08\x02\x02\x12\
+ \x04\xa0\x02\x02&\n\r\n\x05\x04\x08\x02\x02\x04\x12\x04\xa0\x02\x02\n\n\
+ \r\n\x05\x04\x08\x02\x02\x06\x12\x04\xa0\x02\x0b\x19\n\r\n\x05\x04\x08\
+ \x02\x02\x01\x12\x04\xa0\x02\x1a!\n\r\n\x05\x04\x08\x02\x02\x03\x12\x04\
+ \xa0\x02$%\n0\n\x02\x04\t\x12\x06\xa4\x02\0\xb2\x02\x01\x1a\"\x20Describ\
+ es\x20a\x20method\x20of\x20a\x20service.\n\n\x0b\n\x03\x04\t\x01\x12\x04\
+ \xa4\x02\x08\x1d\n\x0c\n\x04\x04\t\x02\0\x12\x04\xa5\x02\x02\x1b\n\r\n\
+ \x05\x04\t\x02\0\x04\x12\x04\xa5\x02\x02\n\n\r\n\x05\x04\t\x02\0\x05\x12\
+ \x04\xa5\x02\x0b\x11\n\r\n\x05\x04\t\x02\0\x01\x12\x04\xa5\x02\x12\x16\n\
+ \r\n\x05\x04\t\x02\0\x03\x12\x04\xa5\x02\x19\x1a\n\x97\x01\n\x04\x04\t\
+ \x02\x01\x12\x04\xa9\x02\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\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\x1c\n\r\n\x05\x04\t\x02\x01\x03\
+ \x12\x04\xa9\x02\x1f\x20\n\x0c\n\x04\x04\t\x02\x02\x12\x04\xaa\x02\x02\"\
+ \n\r\n\x05\x04\t\x02\x02\x04\x12\x04\xaa\x02\x02\n\n\r\n\x05\x04\t\x02\
+ \x02\x05\x12\x04\xaa\x02\x0b\x11\n\r\n\x05\x04\t\x02\x02\x01\x12\x04\xaa\
+ \x02\x12\x1d\n\r\n\x05\x04\t\x02\x02\x03\x12\x04\xaa\x02\x20!\n\x0c\n\
+ \x04\x04\t\x02\x03\x12\x04\xac\x02\x02%\n\r\n\x05\x04\t\x02\x03\x04\x12\
+ \x04\xac\x02\x02\n\n\r\n\x05\x04\t\x02\x03\x06\x12\x04\xac\x02\x0b\x18\n\
+ \r\n\x05\x04\t\x02\x03\x01\x12\x04\xac\x02\x19\x20\n\r\n\x05\x04\t\x02\
+ \x03\x03\x12\x04\xac\x02#$\nE\n\x04\x04\t\x02\x04\x12\x04\xaf\x02\x027\
+ \x1a7\x20Identifies\x20if\x20client\x20streams\x20multiple\x20client\x20\
+ messages\n\n\r\n\x05\x04\t\x02\x04\x04\x12\x04\xaf\x02\x02\n\n\r\n\x05\
+ \x04\t\x02\x04\x05\x12\x04\xaf\x02\x0b\x0f\n\r\n\x05\x04\t\x02\x04\x01\
+ \x12\x04\xaf\x02\x10\x20\n\r\n\x05\x04\t\x02\x04\x03\x12\x04\xaf\x02#$\n\
+ \r\n\x05\x04\t\x02\x04\x08\x12\x04\xaf\x02%6\n\r\n\x05\x04\t\x02\x04\x07\
+ \x12\x04\xaf\x0205\nE\n\x04\x04\t\x02\x05\x12\x04\xb1\x02\x027\x1a7\x20I\
+ dentifies\x20if\x20server\x20streams\x20multiple\x20server\x20messages\n\
+ \n\r\n\x05\x04\t\x02\x05\x04\x12\x04\xb1\x02\x02\n\n\r\n\x05\x04\t\x02\
+ \x05\x05\x12\x04\xb1\x02\x0b\x0f\n\r\n\x05\x04\t\x02\x05\x01\x12\x04\xb1\
+ \x02\x10\x20\n\r\n\x05\x04\t\x02\x05\x03\x12\x04\xb1\x02#$\n\r\n\x05\x04\
+ \t\x02\x05\x08\x12\x04\xb1\x02%6\n\r\n\x05\x04\t\x02\x05\x07\x12\x04\xb1\
+ \x0205\n\xaf\x0e\n\x02\x04\n\x12\x06\xd5\x02\0\xd0\x03\x012N\x20========\
+ ===========================================================\n\x20Options\
+ \n2\xd0\r\x20Each\x20of\x20the\x20definitions\x20above\x20may\x20have\
+ \x20\"options\"\x20attached.\x20\x20These\x20are\n\x20just\x20annotation\
+ s\x20which\x20may\x20cause\x20code\x20to\x20be\x20generated\x20slightly\
+ \x20differently\n\x20or\x20may\x20contain\x20hints\x20for\x20code\x20tha\
+ t\x20manipulates\x20protocol\x20messages.\n\n\x20Clients\x20may\x20defin\
+ e\x20custom\x20options\x20as\x20extensions\x20of\x20the\x20*Options\x20m\
+ essages.\n\x20These\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\x20field\x20in\x20the\x20*Options\n\x20message\x20called\x20\
+ uninterpreted_option.\x20This\x20field\x20must\x20have\x20the\x20same\
+ \x20name\n\x20across\x20all\x20*Options\x20messages.\x20We\x20then\x20us\
+ e\x20this\x20field\x20to\x20populate\x20the\n\x20extensions\x20when\x20w\
+ e\x20build\x20a\x20descriptor,\x20at\x20which\x20point\x20all\x20protos\
+ \x20have\x20been\n\x20parsed\x20and\x20so\x20all\x20extensions\x20are\
+ \x20known.\n\n\x20Extension\x20numbers\x20for\x20custom\x20options\x20ma\
+ y\x20be\x20chosen\x20as\x20follows:\n\x20*\x20For\x20options\x20which\
+ \x20will\x20only\x20be\x20used\x20within\x20a\x20single\x20application\
+ \x20or\n\x20\x20\x20organization,\x20or\x20for\x20experimental\x20option\
+ s,\x20use\x20field\x20numbers\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\x20\
+ options.\n\x20*\x20For\x20options\x20which\x20will\x20be\x20published\
+ \x20and\x20used\x20publicly\x20by\x20multiple\n\x20\x20\x20independent\
+ \x20entities,\x20e-mail\x20protobuf-global-extension-registry@google.com\
+ \n\x20\x20\x20to\x20reserve\x20extension\x20numbers.\x20Simply\x20provid\
+ e\x20your\x20project\x20name\x20(e.g.\n\x20\x20\x20Objective-C\x20plugin\
+ )\x20and\x20your\x20project\x20website\x20(if\x20available)\x20--\x20the\
+ re's\x20no\n\x20\x20\x20need\x20to\x20explain\x20how\x20you\x20intend\
+ \x20to\x20use\x20them.\x20Usually\x20you\x20only\x20need\x20one\n\x20\
+ \x20\x20extension\x20number.\x20You\x20can\x20declare\x20multiple\x20opt\
+ ions\x20with\x20only\x20one\x20extension\n\x20\x20\x20number\x20by\x20pu\
+ tting\x20them\x20in\x20a\x20sub-message.\x20See\x20the\x20Custom\x20Opti\
+ ons\x20section\x20of\n\x20\x20\x20the\x20docs\x20for\x20examples:\n\x20\
+ \x20\x20https://developers.google.com/protocol-buffers/docs/proto#option\
+ s\n\x20\x20\x20If\x20this\x20turns\x20out\x20to\x20be\x20popular,\x20a\
+ \x20web\x20service\x20will\x20be\x20set\x20up\n\x20\x20\x20to\x20automat\
+ ically\x20assign\x20option\x20numbers.\n\n\x0b\n\x03\x04\n\x01\x12\x04\
+ \xd5\x02\x08\x13\n\xf4\x01\n\x04\x04\n\x02\0\x12\x04\xdb\x02\x02#\x1a\
+ \xe5\x01\x20Sets\x20the\x20Java\x20package\x20where\x20classes\x20genera\
+ ted\x20from\x20this\x20.proto\x20will\x20be\n\x20placed.\x20\x20By\x20de\
+ fault,\x20the\x20proto\x20package\x20is\x20used,\x20but\x20this\x20is\
+ \x20often\n\x20inappropriate\x20because\x20proto\x20packages\x20do\x20no\
+ t\x20normally\x20start\x20with\x20backwards\n\x20domain\x20names.\n\n\r\
+ \n\x05\x04\n\x02\0\x04\x12\x04\xdb\x02\x02\n\n\r\n\x05\x04\n\x02\0\x05\
+ \x12\x04\xdb\x02\x0b\x11\n\r\n\x05\x04\n\x02\0\x01\x12\x04\xdb\x02\x12\
+ \x1e\n\r\n\x05\x04\n\x02\0\x03\x12\x04\xdb\x02!\"\n\xbf\x02\n\x04\x04\n\
+ \x02\x01\x12\x04\xe3\x02\x02+\x1a\xb0\x02\x20If\x20set,\x20all\x20the\
+ \x20classes\x20from\x20the\x20.proto\x20file\x20are\x20wrapped\x20in\x20\
+ a\x20single\n\x20outer\x20class\x20with\x20the\x20given\x20name.\x20\x20\
+ This\x20applies\x20to\x20both\x20Proto1\n\x20(equivalent\x20to\x20the\
+ \x20old\x20\"--one_java_file\"\x20option)\x20and\x20Proto2\x20(where\n\
+ \x20a\x20.proto\x20always\x20translates\x20to\x20a\x20single\x20class,\
+ \x20but\x20you\x20may\x20want\x20to\n\x20explicitly\x20choose\x20the\x20\
+ class\x20name).\n\n\r\n\x05\x04\n\x02\x01\x04\x12\x04\xe3\x02\x02\n\n\r\
+ \n\x05\x04\n\x02\x01\x05\x12\x04\xe3\x02\x0b\x11\n\r\n\x05\x04\n\x02\x01\
+ \x01\x12\x04\xe3\x02\x12&\n\r\n\x05\x04\n\x02\x01\x03\x12\x04\xe3\x02)*\
+ \n\xa3\x03\n\x04\x04\n\x02\x02\x12\x04\xeb\x02\x02;\x1a\x94\x03\x20If\
+ \x20set\x20true,\x20then\x20the\x20Java\x20code\x20generator\x20will\x20\
+ generate\x20a\x20separate\x20.java\n\x20file\x20for\x20each\x20top-level\
+ \x20message,\x20enum,\x20and\x20service\x20defined\x20in\x20the\x20.prot\
+ o\n\x20file.\x20\x20Thus,\x20these\x20types\x20will\x20*not*\x20be\x20ne\
+ sted\x20inside\x20the\x20outer\x20class\n\x20named\x20by\x20java_outer_c\
+ lassname.\x20\x20However,\x20the\x20outer\x20class\x20will\x20still\x20b\
+ e\n\x20generated\x20to\x20contain\x20the\x20file's\x20getDescriptor()\
+ \x20method\x20as\x20well\x20as\x20any\n\x20top-level\x20extensions\x20de\
+ fined\x20in\x20the\x20file.\n\n\r\n\x05\x04\n\x02\x02\x04\x12\x04\xeb\
+ \x02\x02\n\n\r\n\x05\x04\n\x02\x02\x05\x12\x04\xeb\x02\x0b\x0f\n\r\n\x05\
+ \x04\n\x02\x02\x01\x12\x04\xeb\x02\x10#\n\r\n\x05\x04\n\x02\x02\x03\x12\
+ \x04\xeb\x02&(\n\r\n\x05\x04\n\x02\x02\x08\x12\x04\xeb\x02):\n\r\n\x05\
+ \x04\n\x02\x02\x07\x12\x04\xeb\x0249\n)\n\x04\x04\n\x02\x03\x12\x04\xee\
+ \x02\x02E\x1a\x1b\x20This\x20option\x20does\x20nothing.\n\n\r\n\x05\x04\
+ \n\x02\x03\x04\x12\x04\xee\x02\x02\n\n\r\n\x05\x04\n\x02\x03\x05\x12\x04\
+ \xee\x02\x0b\x0f\n\r\n\x05\x04\n\x02\x03\x01\x12\x04\xee\x02\x10-\n\r\n\
+ \x05\x04\n\x02\x03\x03\x12\x04\xee\x0202\n\r\n\x05\x04\n\x02\x03\x08\x12\
+ \x04\xee\x023D\n\x0e\n\x06\x04\n\x02\x03\x08\x03\x12\x04\xee\x024C\n\xe6\
+ \x02\n\x04\x04\n\x02\x04\x12\x04\xf6\x02\x02>\x1a\xd7\x02\x20If\x20set\
+ \x20true,\x20then\x20the\x20Java2\x20code\x20generator\x20will\x20genera\
+ te\x20code\x20that\n\x20throws\x20an\x20exception\x20whenever\x20an\x20a\
+ ttempt\x20is\x20made\x20to\x20assign\x20a\x20non-UTF-8\n\x20byte\x20sequ\
+ ence\x20to\x20a\x20string\x20field.\n\x20Message\x20reflection\x20will\
+ \x20do\x20the\x20same.\n\x20However,\x20an\x20extension\x20field\x20stil\
+ l\x20accepts\x20non-UTF-8\x20byte\x20sequences.\n\x20This\x20option\x20h\
+ as\x20no\x20effect\x20on\x20when\x20used\x20with\x20the\x20lite\x20runti\
+ me.\n\n\r\n\x05\x04\n\x02\x04\x04\x12\x04\xf6\x02\x02\n\n\r\n\x05\x04\n\
+ \x02\x04\x05\x12\x04\xf6\x02\x0b\x0f\n\r\n\x05\x04\n\x02\x04\x01\x12\x04\
+ \xf6\x02\x10&\n\r\n\x05\x04\n\x02\x04\x03\x12\x04\xf6\x02)+\n\r\n\x05\
+ \x04\n\x02\x04\x08\x12\x04\xf6\x02,=\n\r\n\x05\x04\n\x02\x04\x07\x12\x04\
+ \xf6\x027<\nL\n\x04\x04\n\x04\0\x12\x06\xfa\x02\x02\xff\x02\x03\x1a<\x20\
+ Generated\x20classes\x20can\x20be\x20optimized\x20for\x20speed\x20or\x20\
+ code\x20size.\n\n\r\n\x05\x04\n\x04\0\x01\x12\x04\xfa\x02\x07\x13\nD\n\
+ \x06\x04\n\x04\0\x02\0\x12\x04\xfb\x02\x04\x0e\"4\x20Generate\x20complet\
+ e\x20code\x20for\x20parsing,\x20serialization,\n\n\x0f\n\x07\x04\n\x04\0\
+ \x02\0\x01\x12\x04\xfb\x02\x04\t\n\x0f\n\x07\x04\n\x04\0\x02\0\x02\x12\
+ \x04\xfb\x02\x0c\r\nG\n\x06\x04\n\x04\0\x02\x01\x12\x04\xfd\x02\x04\x12\
+ \x1a\x06\x20etc.\n\"/\x20Use\x20ReflectionOps\x20to\x20implement\x20thes\
+ e\x20methods.\n\n\x0f\n\x07\x04\n\x04\0\x02\x01\x01\x12\x04\xfd\x02\x04\
+ \r\n\x0f\n\x07\x04\n\x04\0\x02\x01\x02\x12\x04\xfd\x02\x10\x11\nG\n\x06\
+ \x04\n\x04\0\x02\x02\x12\x04\xfe\x02\x04\x15\"7\x20Generate\x20code\x20u\
+ sing\x20MessageLite\x20and\x20the\x20lite\x20runtime.\n\n\x0f\n\x07\x04\
+ \n\x04\0\x02\x02\x01\x12\x04\xfe\x02\x04\x10\n\x0f\n\x07\x04\n\x04\0\x02\
+ \x02\x02\x12\x04\xfe\x02\x13\x14\n\x0c\n\x04\x04\n\x02\x05\x12\x04\x80\
+ \x03\x02;\n\r\n\x05\x04\n\x02\x05\x04\x12\x04\x80\x03\x02\n\n\r\n\x05\
+ \x04\n\x02\x05\x06\x12\x04\x80\x03\x0b\x17\n\r\n\x05\x04\n\x02\x05\x01\
+ \x12\x04\x80\x03\x18$\n\r\n\x05\x04\n\x02\x05\x03\x12\x04\x80\x03'(\n\r\
+ \n\x05\x04\n\x02\x05\x08\x12\x04\x80\x03):\n\r\n\x05\x04\n\x02\x05\x07\
+ \x12\x04\x80\x0349\n\xe2\x02\n\x04\x04\n\x02\x06\x12\x04\x87\x03\x02\"\
+ \x1a\xd3\x02\x20Sets\x20the\x20Go\x20package\x20where\x20structs\x20gene\
+ rated\x20from\x20this\x20.proto\x20will\x20be\n\x20placed.\x20If\x20omit\
+ ted,\x20the\x20Go\x20package\x20will\x20be\x20derived\x20from\x20the\x20\
+ following:\n\x20\x20\x20-\x20The\x20basename\x20of\x20the\x20package\x20\
+ import\x20path,\x20if\x20provided.\n\x20\x20\x20-\x20Otherwise,\x20the\
+ \x20package\x20statement\x20in\x20the\x20.proto\x20file,\x20if\x20presen\
+ t.\n\x20\x20\x20-\x20Otherwise,\x20the\x20basename\x20of\x20the\x20.prot\
+ o\x20file,\x20without\x20extension.\n\n\r\n\x05\x04\n\x02\x06\x04\x12\
+ \x04\x87\x03\x02\n\n\r\n\x05\x04\n\x02\x06\x05\x12\x04\x87\x03\x0b\x11\n\
+ \r\n\x05\x04\n\x02\x06\x01\x12\x04\x87\x03\x12\x1c\n\r\n\x05\x04\n\x02\
+ \x06\x03\x12\x04\x87\x03\x1f!\n\xd4\x04\n\x04\x04\n\x02\x07\x12\x04\x96\
+ \x03\x02;\x1a\xc5\x04\x20Should\x20generic\x20services\x20be\x20generate\
+ d\x20in\x20each\x20language?\x20\x20\"Generic\"\x20services\n\x20are\x20\
+ not\x20specific\x20to\x20any\x20particular\x20RPC\x20system.\x20\x20They\
+ \x20are\x20generated\x20by\x20the\n\x20main\x20code\x20generators\x20in\
+ \x20each\x20language\x20(without\x20additional\x20plugins).\n\x20Generic\
+ \x20services\x20were\x20the\x20only\x20kind\x20of\x20service\x20generati\
+ on\x20supported\x20by\n\x20early\x20versions\x20of\x20google.protobuf.\n\
+ \n\x20Generic\x20services\x20are\x20now\x20considered\x20deprecated\x20i\
+ n\x20favor\x20of\x20using\x20plugins\n\x20that\x20generate\x20code\x20sp\
+ ecific\x20to\x20your\x20particular\x20RPC\x20system.\x20\x20Therefore,\n\
+ \x20these\x20default\x20to\x20false.\x20\x20Old\x20code\x20which\x20depe\
+ nds\x20on\x20generic\x20services\x20should\n\x20explicitly\x20set\x20the\
+ m\x20to\x20true.\n\n\r\n\x05\x04\n\x02\x07\x04\x12\x04\x96\x03\x02\n\n\r\
+ \n\x05\x04\n\x02\x07\x05\x12\x04\x96\x03\x0b\x0f\n\r\n\x05\x04\n\x02\x07\
+ \x01\x12\x04\x96\x03\x10#\n\r\n\x05\x04\n\x02\x07\x03\x12\x04\x96\x03&(\
+ \n\r\n\x05\x04\n\x02\x07\x08\x12\x04\x96\x03):\n\r\n\x05\x04\n\x02\x07\
+ \x07\x12\x04\x96\x0349\n\x0c\n\x04\x04\n\x02\x08\x12\x04\x97\x03\x02=\n\
+ \r\n\x05\x04\n\x02\x08\x04\x12\x04\x97\x03\x02\n\n\r\n\x05\x04\n\x02\x08\
+ \x05\x12\x04\x97\x03\x0b\x0f\n\r\n\x05\x04\n\x02\x08\x01\x12\x04\x97\x03\
+ \x10%\n\r\n\x05\x04\n\x02\x08\x03\x12\x04\x97\x03(*\n\r\n\x05\x04\n\x02\
+ \x08\x08\x12\x04\x97\x03+<\n\r\n\x05\x04\n\x02\x08\x07\x12\x04\x97\x036;\
+ \n\x0c\n\x04\x04\n\x02\t\x12\x04\x98\x03\x02;\n\r\n\x05\x04\n\x02\t\x04\
+ \x12\x04\x98\x03\x02\n\n\r\n\x05\x04\n\x02\t\x05\x12\x04\x98\x03\x0b\x0f\
+ \n\r\n\x05\x04\n\x02\t\x01\x12\x04\x98\x03\x10#\n\r\n\x05\x04\n\x02\t\
+ \x03\x12\x04\x98\x03&(\n\r\n\x05\x04\n\x02\t\x08\x12\x04\x98\x03):\n\r\n\
+ \x05\x04\n\x02\t\x07\x12\x04\x98\x0349\n\x0c\n\x04\x04\n\x02\n\x12\x04\
+ \x99\x03\x02<\n\r\n\x05\x04\n\x02\n\x04\x12\x04\x99\x03\x02\n\n\r\n\x05\
+ \x04\n\x02\n\x05\x12\x04\x99\x03\x0b\x0f\n\r\n\x05\x04\n\x02\n\x01\x12\
+ \x04\x99\x03\x10$\n\r\n\x05\x04\n\x02\n\x03\x12\x04\x99\x03')\n\r\n\x05\
+ \x04\n\x02\n\x08\x12\x04\x99\x03*;\n\r\n\x05\x04\n\x02\n\x07\x12\x04\x99\
+ \x035:\n\xf3\x01\n\x04\x04\n\x02\x0b\x12\x04\x9f\x03\x022\x1a\xe4\x01\
+ \x20Is\x20this\x20file\x20deprecated?\n\x20Depending\x20on\x20the\x20tar\
+ get\x20platform,\x20this\x20can\x20emit\x20Deprecated\x20annotations\n\
+ \x20for\x20everything\x20in\x20the\x20file,\x20or\x20it\x20will\x20be\
+ \x20completely\x20ignored;\x20in\x20the\x20very\n\x20least,\x20this\x20i\
+ s\x20a\x20formalization\x20for\x20deprecating\x20files.\n\n\r\n\x05\x04\
+ \n\x02\x0b\x04\x12\x04\x9f\x03\x02\n\n\r\n\x05\x04\n\x02\x0b\x05\x12\x04\
+ \x9f\x03\x0b\x0f\n\r\n\x05\x04\n\x02\x0b\x01\x12\x04\x9f\x03\x10\x1a\n\r\
+ \n\x05\x04\n\x02\x0b\x03\x12\x04\x9f\x03\x1d\x1f\n\r\n\x05\x04\n\x02\x0b\
+ \x08\x12\x04\x9f\x03\x201\n\r\n\x05\x04\n\x02\x0b\x07\x12\x04\x9f\x03+0\
+ \n\x7f\n\x04\x04\n\x02\x0c\x12\x04\xa3\x03\x027\x1aq\x20Enables\x20the\
+ \x20use\x20of\x20arenas\x20for\x20the\x20proto\x20messages\x20in\x20this\
+ \x20file.\x20This\x20applies\n\x20only\x20to\x20generated\x20classes\x20\
+ for\x20C++.\n\n\r\n\x05\x04\n\x02\x0c\x04\x12\x04\xa3\x03\x02\n\n\r\n\
+ \x05\x04\n\x02\x0c\x05\x12\x04\xa3\x03\x0b\x0f\n\r\n\x05\x04\n\x02\x0c\
+ \x01\x12\x04\xa3\x03\x10\x20\n\r\n\x05\x04\n\x02\x0c\x03\x12\x04\xa3\x03\
+ #%\n\r\n\x05\x04\n\x02\x0c\x08\x12\x04\xa3\x03&6\n\r\n\x05\x04\n\x02\x0c\
+ \x07\x12\x04\xa3\x0315\n\x92\x01\n\x04\x04\n\x02\r\x12\x04\xa8\x03\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\n\x02\r\x04\x12\x04\xa8\x03\x02\n\n\r\n\x05\x04\n\x02\r\x05\
+ \x12\x04\xa8\x03\x0b\x11\n\r\n\x05\x04\n\x02\r\x01\x12\x04\xa8\x03\x12#\
+ \n\r\n\x05\x04\n\x02\r\x03\x12\x04\xa8\x03&(\nI\n\x04\x04\n\x02\x0e\x12\
+ \x04\xab\x03\x02(\x1a;\x20Namespace\x20for\x20generated\x20classes;\x20d\
+ efaults\x20to\x20the\x20package.\n\n\r\n\x05\x04\n\x02\x0e\x04\x12\x04\
+ \xab\x03\x02\n\n\r\n\x05\x04\n\x02\x0e\x05\x12\x04\xab\x03\x0b\x11\n\r\n\
+ \x05\x04\n\x02\x0e\x01\x12\x04\xab\x03\x12\"\n\r\n\x05\x04\n\x02\x0e\x03\
+ \x12\x04\xab\x03%'\n\x91\x02\n\x04\x04\n\x02\x0f\x12\x04\xb1\x03\x02$\
+ \x1a\x82\x02\x20By\x20default\x20Swift\x20generators\x20will\x20take\x20\
+ the\x20proto\x20package\x20and\x20CamelCase\x20it\n\x20replacing\x20'.'\
+ \x20with\x20underscore\x20and\x20use\x20that\x20to\x20prefix\x20the\x20t\
+ ypes/symbols\n\x20defined.\x20When\x20this\x20options\x20is\x20provided,\
+ \x20they\x20will\x20use\x20this\x20value\x20instead\n\x20to\x20prefix\
+ \x20the\x20types/symbols\x20defined.\n\n\r\n\x05\x04\n\x02\x0f\x04\x12\
+ \x04\xb1\x03\x02\n\n\r\n\x05\x04\n\x02\x0f\x05\x12\x04\xb1\x03\x0b\x11\n\
+ \r\n\x05\x04\n\x02\x0f\x01\x12\x04\xb1\x03\x12\x1e\n\r\n\x05\x04\n\x02\
+ \x0f\x03\x12\x04\xb1\x03!#\n~\n\x04\x04\n\x02\x10\x12\x04\xb5\x03\x02(\
+ \x1ap\x20Sets\x20the\x20php\x20class\x20prefix\x20which\x20is\x20prepend\
+ ed\x20to\x20all\x20php\x20generated\x20classes\n\x20from\x20this\x20.pro\
+ to.\x20Default\x20is\x20empty.\n\n\r\n\x05\x04\n\x02\x10\x04\x12\x04\xb5\
+ \x03\x02\n\n\r\n\x05\x04\n\x02\x10\x05\x12\x04\xb5\x03\x0b\x11\n\r\n\x05\
+ \x04\n\x02\x10\x01\x12\x04\xb5\x03\x12\"\n\r\n\x05\x04\n\x02\x10\x03\x12\
+ \x04\xb5\x03%'\n\xbe\x01\n\x04\x04\n\x02\x11\x12\x04\xba\x03\x02%\x1a\
+ \xaf\x01\x20Use\x20this\x20option\x20to\x20change\x20the\x20namespace\
+ \x20of\x20php\x20generated\x20classes.\x20Default\n\x20is\x20empty.\x20W\
+ hen\x20this\x20option\x20is\x20empty,\x20the\x20package\x20name\x20will\
+ \x20be\x20used\x20for\n\x20determining\x20the\x20namespace.\n\n\r\n\x05\
+ \x04\n\x02\x11\x04\x12\x04\xba\x03\x02\n\n\r\n\x05\x04\n\x02\x11\x05\x12\
+ \x04\xba\x03\x0b\x11\n\r\n\x05\x04\n\x02\x11\x01\x12\x04\xba\x03\x12\x1f\
+ \n\r\n\x05\x04\n\x02\x11\x03\x12\x04\xba\x03\"$\n\xca\x01\n\x04\x04\n\
+ \x02\x12\x12\x04\xbf\x03\x02.\x1a\xbb\x01\x20Use\x20this\x20option\x20to\
+ \x20change\x20the\x20namespace\x20of\x20php\x20generated\x20metadata\x20\
+ classes.\n\x20Default\x20is\x20empty.\x20When\x20this\x20option\x20is\
+ \x20empty,\x20the\x20proto\x20file\x20name\x20will\x20be\n\x20used\x20fo\
+ r\x20determining\x20the\x20namespace.\n\n\r\n\x05\x04\n\x02\x12\x04\x12\
+ \x04\xbf\x03\x02\n\n\r\n\x05\x04\n\x02\x12\x05\x12\x04\xbf\x03\x0b\x11\n\
+ \r\n\x05\x04\n\x02\x12\x01\x12\x04\xbf\x03\x12(\n\r\n\x05\x04\n\x02\x12\
+ \x03\x12\x04\xbf\x03+-\n\xc2\x01\n\x04\x04\n\x02\x13\x12\x04\xc4\x03\x02\
+ $\x1a\xb3\x01\x20Use\x20this\x20option\x20to\x20change\x20the\x20package\
+ \x20of\x20ruby\x20generated\x20classes.\x20Default\n\x20is\x20empty.\x20\
+ When\x20this\x20option\x20is\x20not\x20set,\x20the\x20package\x20name\
+ \x20will\x20be\x20used\x20for\n\x20determining\x20the\x20ruby\x20package\
+ .\n\n\r\n\x05\x04\n\x02\x13\x04\x12\x04\xc4\x03\x02\n\n\r\n\x05\x04\n\
+ \x02\x13\x05\x12\x04\xc4\x03\x0b\x11\n\r\n\x05\x04\n\x02\x13\x01\x12\x04\
+ \xc4\x03\x12\x1e\n\r\n\x05\x04\n\x02\x13\x03\x12\x04\xc4\x03!#\n|\n\x04\
+ \x04\n\x02\x14\x12\x04\xc9\x03\x02:\x1an\x20The\x20parser\x20stores\x20o\
+ ptions\x20it\x20doesn't\x20recognize\x20here.\n\x20See\x20the\x20documen\
+ tation\x20for\x20the\x20\"Options\"\x20section\x20above.\n\n\r\n\x05\x04\
+ \n\x02\x14\x04\x12\x04\xc9\x03\x02\n\n\r\n\x05\x04\n\x02\x14\x06\x12\x04\
+ \xc9\x03\x0b\x1e\n\r\n\x05\x04\n\x02\x14\x01\x12\x04\xc9\x03\x1f3\n\r\n\
+ \x05\x04\n\x02\x14\x03\x12\x04\xc9\x0369\n\x87\x01\n\x03\x04\n\x05\x12\
+ \x04\xcd\x03\x02\x19\x1az\x20Clients\x20can\x20define\x20custom\x20optio\
+ ns\x20in\x20extensions\x20of\x20this\x20message.\n\x20See\x20the\x20docu\
+ mentation\x20for\x20the\x20\"Options\"\x20section\x20above.\n\n\x0c\n\
+ \x04\x04\n\x05\0\x12\x04\xcd\x03\r\x18\n\r\n\x05\x04\n\x05\0\x01\x12\x04\
+ \xcd\x03\r\x11\n\r\n\x05\x04\n\x05\0\x02\x12\x04\xcd\x03\x15\x18\n\x0b\n\
+ \x03\x04\n\t\x12\x04\xcf\x03\x02\x0e\n\x0c\n\x04\x04\n\t\0\x12\x04\xcf\
+ \x03\x0b\r\n\r\n\x05\x04\n\t\0\x01\x12\x04\xcf\x03\x0b\r\n\r\n\x05\x04\n\
+ \t\0\x02\x12\x04\xcf\x03\x0b\r\n\x0c\n\x02\x04\x0b\x12\x06\xd2\x03\0\x92\
+ \x04\x01\n\x0b\n\x03\x04\x0b\x01\x12\x04\xd2\x03\x08\x16\n\xd8\x05\n\x04\
+ \x04\x0b\x02\0\x12\x04\xe5\x03\x02>\x1a\xc9\x05\x20Set\x20true\x20to\x20\
+ use\x20the\x20old\x20proto1\x20MessageSet\x20wire\x20format\x20for\x20ex\
+ tensions.\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\x20\
+ less\n\x20efficient,\x20has\x20fewer\x20features,\x20and\x20is\x20more\
+ \x20complicated.\n\n\x20The\x20message\x20must\x20be\x20defined\x20exact\
+ ly\x20as\x20follows:\n\x20\x20\x20message\x20Foo\x20{\n\x20\x20\x20\x20\
+ \x20option\x20message_set_wire_format\x20=\x20true;\n\x20\x20\x20\x20\
+ \x20extensions\x204\x20to\x20max;\n\x20\x20\x20}\n\x20Note\x20that\x20th\
+ e\x20message\x20cannot\x20have\x20any\x20defined\x20fields;\x20MessageSe\
+ ts\x20only\n\x20have\x20extensions.\n\n\x20All\x20extensions\x20of\x20yo\
+ ur\x20type\x20must\x20be\x20singular\x20messages;\x20e.g.\x20they\x20can\
+ not\n\x20be\x20int32s,\x20enums,\x20or\x20repeated\x20messages.\n\n\x20B\
+ ecause\x20this\x20is\x20an\x20option,\x20the\x20above\x20two\x20restrict\
+ ions\x20are\x20not\x20enforced\x20by\n\x20the\x20protocol\x20compiler.\n\
+ \n\r\n\x05\x04\x0b\x02\0\x04\x12\x04\xe5\x03\x02\n\n\r\n\x05\x04\x0b\x02\
+ \0\x05\x12\x04\xe5\x03\x0b\x0f\n\r\n\x05\x04\x0b\x02\0\x01\x12\x04\xe5\
+ \x03\x10'\n\r\n\x05\x04\x0b\x02\0\x03\x12\x04\xe5\x03*+\n\r\n\x05\x04\
+ \x0b\x02\0\x08\x12\x04\xe5\x03,=\n\r\n\x05\x04\x0b\x02\0\x07\x12\x04\xe5\
+ \x037<\n\xeb\x01\n\x04\x04\x0b\x02\x01\x12\x04\xea\x03\x02F\x1a\xdc\x01\
+ \x20Disables\x20the\x20generation\x20of\x20the\x20standard\x20\"descript\
+ or()\"\x20accessor,\x20which\x20can\n\x20conflict\x20with\x20a\x20field\
+ \x20of\x20the\x20same\x20name.\x20\x20This\x20is\x20meant\x20to\x20make\
+ \x20migration\n\x20from\x20proto1\x20easier;\x20new\x20code\x20should\
+ \x20avoid\x20fields\x20named\x20\"descriptor\".\n\n\r\n\x05\x04\x0b\x02\
+ \x01\x04\x12\x04\xea\x03\x02\n\n\r\n\x05\x04\x0b\x02\x01\x05\x12\x04\xea\
+ \x03\x0b\x0f\n\r\n\x05\x04\x0b\x02\x01\x01\x12\x04\xea\x03\x10/\n\r\n\
+ \x05\x04\x0b\x02\x01\x03\x12\x04\xea\x0323\n\r\n\x05\x04\x0b\x02\x01\x08\
+ \x12\x04\xea\x034E\n\r\n\x05\x04\x0b\x02\x01\x07\x12\x04\xea\x03?D\n\xee\
+ \x01\n\x04\x04\x0b\x02\x02\x12\x04\xf0\x03\x021\x1a\xdf\x01\x20Is\x20thi\
+ s\x20message\x20deprecated?\n\x20Depending\x20on\x20the\x20target\x20pla\
+ tform,\x20this\x20can\x20emit\x20Deprecated\x20annotations\n\x20for\x20t\
+ he\x20message,\x20or\x20it\x20will\x20be\x20completely\x20ignored;\x20in\
+ \x20the\x20very\x20least,\n\x20this\x20is\x20a\x20formalization\x20for\
+ \x20deprecating\x20messages.\n\n\r\n\x05\x04\x0b\x02\x02\x04\x12\x04\xf0\
+ \x03\x02\n\n\r\n\x05\x04\x0b\x02\x02\x05\x12\x04\xf0\x03\x0b\x0f\n\r\n\
+ \x05\x04\x0b\x02\x02\x01\x12\x04\xf0\x03\x10\x1a\n\r\n\x05\x04\x0b\x02\
+ \x02\x03\x12\x04\xf0\x03\x1d\x1e\n\r\n\x05\x04\x0b\x02\x02\x08\x12\x04\
+ \xf0\x03\x1f0\n\r\n\x05\x04\x0b\x02\x02\x07\x12\x04\xf0\x03*/\n\xa0\x06\
+ \n\x04\x04\x0b\x02\x03\x12\x04\x87\x04\x02\x1e\x1a\x91\x06\x20Whether\
+ \x20the\x20message\x20is\x20an\x20automatically\x20generated\x20map\x20e\
+ ntry\x20type\x20for\x20the\n\x20maps\x20field.\n\n\x20For\x20maps\x20fie\
+ lds:\n\x20\x20\x20\x20\x20map<KeyType,\x20ValueType>\x20map_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_field\x20=\x201;\
+ \n\n\x20Implementations\x20may\x20choose\x20not\x20to\x20generate\x20the\
+ \x20map_entry=true\x20message,\x20but\n\x20use\x20a\x20native\x20map\x20\
+ in\x20the\x20target\x20language\x20to\x20hold\x20the\x20keys\x20and\x20v\
+ alues.\n\x20The\x20reflection\x20APIs\x20in\x20such\x20implementations\
+ \x20still\x20need\x20to\x20work\x20as\n\x20if\x20the\x20field\x20is\x20a\
+ \x20repeated\x20message\x20field.\n\n\x20NOTE:\x20Do\x20not\x20set\x20th\
+ e\x20option\x20in\x20.proto\x20files.\x20Always\x20use\x20the\x20maps\
+ \x20syntax\n\x20instead.\x20The\x20option\x20should\x20only\x20be\x20imp\
+ licitly\x20set\x20by\x20the\x20proto\x20compiler\n\x20parser.\n\n\r\n\
+ \x05\x04\x0b\x02\x03\x04\x12\x04\x87\x04\x02\n\n\r\n\x05\x04\x0b\x02\x03\
+ \x05\x12\x04\x87\x04\x0b\x0f\n\r\n\x05\x04\x0b\x02\x03\x01\x12\x04\x87\
+ \x04\x10\x19\n\r\n\x05\x04\x0b\x02\x03\x03\x12\x04\x87\x04\x1c\x1d\n$\n\
+ \x03\x04\x0b\t\x12\x04\x89\x04\x02\r\"\x17\x20javalite_serializable\n\n\
+ \x0c\n\x04\x04\x0b\t\0\x12\x04\x89\x04\x0b\x0c\n\r\n\x05\x04\x0b\t\0\x01\
+ \x12\x04\x89\x04\x0b\x0c\n\r\n\x05\x04\x0b\t\0\x02\x12\x04\x89\x04\x0b\
+ \x0c\n\x1f\n\x03\x04\x0b\t\x12\x04\x8a\x04\x02\r\"\x12\x20javanano_as_li\
+ te\n\n\x0c\n\x04\x04\x0b\t\x01\x12\x04\x8a\x04\x0b\x0c\n\r\n\x05\x04\x0b\
+ \t\x01\x01\x12\x04\x8a\x04\x0b\x0c\n\r\n\x05\x04\x0b\t\x01\x02\x12\x04\
+ \x8a\x04\x0b\x0c\nO\n\x04\x04\x0b\x02\x04\x12\x04\x8e\x04\x02:\x1aA\x20T\
+ he\x20parser\x20stores\x20options\x20it\x20doesn't\x20recognize\x20here.\
+ \x20See\x20above.\n\n\r\n\x05\x04\x0b\x02\x04\x04\x12\x04\x8e\x04\x02\n\
+ \n\r\n\x05\x04\x0b\x02\x04\x06\x12\x04\x8e\x04\x0b\x1e\n\r\n\x05\x04\x0b\
+ \x02\x04\x01\x12\x04\x8e\x04\x1f3\n\r\n\x05\x04\x0b\x02\x04\x03\x12\x04\
+ \x8e\x0469\nZ\n\x03\x04\x0b\x05\x12\x04\x91\x04\x02\x19\x1aM\x20Clients\
+ \x20can\x20define\x20custom\x20options\x20in\x20extensions\x20of\x20this\
+ \x20message.\x20See\x20above.\n\n\x0c\n\x04\x04\x0b\x05\0\x12\x04\x91\
+ \x04\r\x18\n\r\n\x05\x04\x0b\x05\0\x01\x12\x04\x91\x04\r\x11\n\r\n\x05\
+ \x04\x0b\x05\0\x02\x12\x04\x91\x04\x15\x18\n\x0c\n\x02\x04\x0c\x12\x06\
+ \x94\x04\0\xef\x04\x01\n\x0b\n\x03\x04\x0c\x01\x12\x04\x94\x04\x08\x14\n\
+ \xa3\x02\n\x04\x04\x0c\x02\0\x12\x04\x99\x04\x02.\x1a\x94\x02\x20The\x20\
+ ctype\x20option\x20instructs\x20the\x20C++\x20code\x20generator\x20to\
+ \x20use\x20a\x20different\n\x20representation\x20of\x20the\x20field\x20t\
+ han\x20it\x20normally\x20would.\x20\x20See\x20the\x20specific\n\x20optio\
+ ns\x20below.\x20\x20This\x20option\x20is\x20not\x20yet\x20implemented\
+ \x20in\x20the\x20open\x20source\n\x20release\x20--\x20sorry,\x20we'll\
+ \x20try\x20to\x20include\x20it\x20in\x20a\x20future\x20version!\n\n\r\n\
+ \x05\x04\x0c\x02\0\x04\x12\x04\x99\x04\x02\n\n\r\n\x05\x04\x0c\x02\0\x06\
+ \x12\x04\x99\x04\x0b\x10\n\r\n\x05\x04\x0c\x02\0\x01\x12\x04\x99\x04\x11\
+ \x16\n\r\n\x05\x04\x0c\x02\0\x03\x12\x04\x99\x04\x19\x1a\n\r\n\x05\x04\
+ \x0c\x02\0\x08\x12\x04\x99\x04\x1b-\n\r\n\x05\x04\x0c\x02\0\x07\x12\x04\
+ \x99\x04&,\n\x0e\n\x04\x04\x0c\x04\0\x12\x06\x9a\x04\x02\xa1\x04\x03\n\r\
+ \n\x05\x04\x0c\x04\0\x01\x12\x04\x9a\x04\x07\x0c\n\x1f\n\x06\x04\x0c\x04\
+ \0\x02\0\x12\x04\x9c\x04\x04\x0f\x1a\x0f\x20Default\x20mode.\n\n\x0f\n\
+ \x07\x04\x0c\x04\0\x02\0\x01\x12\x04\x9c\x04\x04\n\n\x0f\n\x07\x04\x0c\
+ \x04\0\x02\0\x02\x12\x04\x9c\x04\r\x0e\n\x0e\n\x06\x04\x0c\x04\0\x02\x01\
+ \x12\x04\x9e\x04\x04\r\n\x0f\n\x07\x04\x0c\x04\0\x02\x01\x01\x12\x04\x9e\
+ \x04\x04\x08\n\x0f\n\x07\x04\x0c\x04\0\x02\x01\x02\x12\x04\x9e\x04\x0b\
+ \x0c\n\x0e\n\x06\x04\x0c\x04\0\x02\x02\x12\x04\xa0\x04\x04\x15\n\x0f\n\
+ \x07\x04\x0c\x04\0\x02\x02\x01\x12\x04\xa0\x04\x04\x10\n\x0f\n\x07\x04\
+ \x0c\x04\0\x02\x02\x02\x12\x04\xa0\x04\x13\x14\n\xda\x02\n\x04\x04\x0c\
+ \x02\x01\x12\x04\xa7\x04\x02\x1b\x1a\xcb\x02\x20The\x20packed\x20option\
+ \x20can\x20be\x20enabled\x20for\x20repeated\x20primitive\x20fields\x20to\
+ \x20enable\n\x20a\x20more\x20efficient\x20representation\x20on\x20the\
+ \x20wire.\x20Rather\x20than\x20repeatedly\n\x20writing\x20the\x20tag\x20\
+ and\x20type\x20for\x20each\x20element,\x20the\x20entire\x20array\x20is\
+ \x20encoded\x20as\n\x20a\x20single\x20length-delimited\x20blob.\x20In\
+ \x20proto3,\x20only\x20explicit\x20setting\x20it\x20to\n\x20false\x20wil\
+ l\x20avoid\x20using\x20packed\x20encoding.\n\n\r\n\x05\x04\x0c\x02\x01\
+ \x04\x12\x04\xa7\x04\x02\n\n\r\n\x05\x04\x0c\x02\x01\x05\x12\x04\xa7\x04\
+ \x0b\x0f\n\r\n\x05\x04\x0c\x02\x01\x01\x12\x04\xa7\x04\x10\x16\n\r\n\x05\
+ \x04\x0c\x02\x01\x03\x12\x04\xa7\x04\x19\x1a\n\x9a\x05\n\x04\x04\x0c\x02\
+ \x02\x12\x04\xb4\x04\x023\x1a\x8b\x05\x20The\x20jstype\x20option\x20dete\
+ rmines\x20the\x20JavaScript\x20type\x20used\x20for\x20values\x20of\x20th\
+ e\n\x20field.\x20\x20The\x20option\x20is\x20permitted\x20only\x20for\x20\
+ 64\x20bit\x20integral\x20and\x20fixed\x20types\n\x20(int64,\x20uint64,\
+ \x20sint64,\x20fixed64,\x20sfixed64).\x20\x20A\x20field\x20with\x20jstyp\
+ e\x20JS_STRING\n\x20is\x20represented\x20as\x20JavaScript\x20string,\x20\
+ which\x20avoids\x20loss\x20of\x20precision\x20that\n\x20can\x20happen\
+ \x20when\x20a\x20large\x20value\x20is\x20converted\x20to\x20a\x20floatin\
+ g\x20point\x20JavaScript.\n\x20Specifying\x20JS_NUMBER\x20for\x20the\x20\
+ jstype\x20causes\x20the\x20generated\x20JavaScript\x20code\x20to\n\x20us\
+ e\x20the\x20JavaScript\x20\"number\"\x20type.\x20\x20The\x20behavior\x20\
+ of\x20the\x20default\x20option\n\x20JS_NORMAL\x20is\x20implementation\
+ \x20dependent.\n\n\x20This\x20option\x20is\x20an\x20enum\x20to\x20permit\
+ \x20additional\x20types\x20to\x20be\x20added,\x20e.g.\n\x20goog.math.Int\
+ eger.\n\n\r\n\x05\x04\x0c\x02\x02\x04\x12\x04\xb4\x04\x02\n\n\r\n\x05\
+ \x04\x0c\x02\x02\x06\x12\x04\xb4\x04\x0b\x11\n\r\n\x05\x04\x0c\x02\x02\
+ \x01\x12\x04\xb4\x04\x12\x18\n\r\n\x05\x04\x0c\x02\x02\x03\x12\x04\xb4\
+ \x04\x1b\x1c\n\r\n\x05\x04\x0c\x02\x02\x08\x12\x04\xb4\x04\x1d2\n\r\n\
+ \x05\x04\x0c\x02\x02\x07\x12\x04\xb4\x04(1\n\x0e\n\x04\x04\x0c\x04\x01\
+ \x12\x06\xb5\x04\x02\xbe\x04\x03\n\r\n\x05\x04\x0c\x04\x01\x01\x12\x04\
+ \xb5\x04\x07\r\n'\n\x06\x04\x0c\x04\x01\x02\0\x12\x04\xb7\x04\x04\x12\
+ \x1a\x17\x20Use\x20the\x20default\x20type.\n\n\x0f\n\x07\x04\x0c\x04\x01\
+ \x02\0\x01\x12\x04\xb7\x04\x04\r\n\x0f\n\x07\x04\x0c\x04\x01\x02\0\x02\
+ \x12\x04\xb7\x04\x10\x11\n)\n\x06\x04\x0c\x04\x01\x02\x01\x12\x04\xba\
+ \x04\x04\x12\x1a\x19\x20Use\x20JavaScript\x20strings.\n\n\x0f\n\x07\x04\
+ \x0c\x04\x01\x02\x01\x01\x12\x04\xba\x04\x04\r\n\x0f\n\x07\x04\x0c\x04\
+ \x01\x02\x01\x02\x12\x04\xba\x04\x10\x11\n)\n\x06\x04\x0c\x04\x01\x02\
+ \x02\x12\x04\xbd\x04\x04\x12\x1a\x19\x20Use\x20JavaScript\x20numbers.\n\
+ \n\x0f\n\x07\x04\x0c\x04\x01\x02\x02\x01\x12\x04\xbd\x04\x04\r\n\x0f\n\
+ \x07\x04\x0c\x04\x01\x02\x02\x02\x12\x04\xbd\x04\x10\x11\n\xef\x0c\n\x04\
+ \x04\x0c\x02\x03\x12\x04\xdc\x04\x02+\x1a\xe0\x0c\x20Should\x20this\x20f\
+ ield\x20be\x20parsed\x20lazily?\x20\x20Lazy\x20applies\x20only\x20to\x20\
+ message-type\n\x20fields.\x20\x20It\x20means\x20that\x20when\x20the\x20o\
+ uter\x20message\x20is\x20initially\x20parsed,\x20the\n\x20inner\x20messa\
+ ge's\x20contents\x20will\x20not\x20be\x20parsed\x20but\x20instead\x20sto\
+ red\x20in\x20encoded\n\x20form.\x20\x20The\x20inner\x20message\x20will\
+ \x20actually\x20be\x20parsed\x20when\x20it\x20is\x20first\x20accessed.\n\
+ \n\x20This\x20is\x20only\x20a\x20hint.\x20\x20Implementations\x20are\x20\
+ free\x20to\x20choose\x20whether\x20to\x20use\n\x20eager\x20or\x20lazy\
+ \x20parsing\x20regardless\x20of\x20the\x20value\x20of\x20this\x20option.\
+ \x20\x20However,\n\x20setting\x20this\x20option\x20true\x20suggests\x20t\
+ hat\x20the\x20protocol\x20author\x20believes\x20that\n\x20using\x20lazy\
+ \x20parsing\x20on\x20this\x20field\x20is\x20worth\x20the\x20additional\
+ \x20bookkeeping\n\x20overhead\x20typically\x20needed\x20to\x20implement\
+ \x20it.\n\n\x20This\x20option\x20does\x20not\x20affect\x20the\x20public\
+ \x20interface\x20of\x20any\x20generated\x20code;\n\x20all\x20method\x20s\
+ ignatures\x20remain\x20the\x20same.\x20\x20Furthermore,\x20thread-safety\
+ \x20of\x20the\n\x20interface\x20is\x20not\x20affected\x20by\x20this\x20o\
+ ption;\x20const\x20methods\x20remain\x20safe\x20to\n\x20call\x20from\x20\
+ multiple\x20threads\x20concurrently,\x20while\x20non-const\x20methods\
+ \x20continue\n\x20to\x20require\x20exclusive\x20access.\n\n\n\x20Note\
+ \x20that\x20implementations\x20may\x20choose\x20not\x20to\x20check\x20re\
+ quired\x20fields\x20within\n\x20a\x20lazy\x20sub-message.\x20\x20That\
+ \x20is,\x20calling\x20IsInitialized()\x20on\x20the\x20outer\x20message\n\
+ \x20may\x20return\x20true\x20even\x20if\x20the\x20inner\x20message\x20ha\
+ s\x20missing\x20required\x20fields.\n\x20This\x20is\x20necessary\x20beca\
+ use\x20otherwise\x20the\x20inner\x20message\x20would\x20have\x20to\x20be\
+ \n\x20parsed\x20in\x20order\x20to\x20perform\x20the\x20check,\x20defeati\
+ ng\x20the\x20purpose\x20of\x20lazy\n\x20parsing.\x20\x20An\x20implementa\
+ tion\x20which\x20chooses\x20not\x20to\x20check\x20required\x20fields\n\
+ \x20must\x20be\x20consistent\x20about\x20it.\x20\x20That\x20is,\x20for\
+ \x20any\x20particular\x20sub-message,\x20the\n\x20implementation\x20must\
+ \x20either\x20*always*\x20check\x20its\x20required\x20fields,\x20or\x20*\
+ never*\n\x20check\x20its\x20required\x20fields,\x20regardless\x20of\x20w\
+ hether\x20or\x20not\x20the\x20message\x20has\n\x20been\x20parsed.\n\n\r\
+ \n\x05\x04\x0c\x02\x03\x04\x12\x04\xdc\x04\x02\n\n\r\n\x05\x04\x0c\x02\
+ \x03\x05\x12\x04\xdc\x04\x0b\x0f\n\r\n\x05\x04\x0c\x02\x03\x01\x12\x04\
+ \xdc\x04\x10\x14\n\r\n\x05\x04\x0c\x02\x03\x03\x12\x04\xdc\x04\x17\x18\n\
+ \r\n\x05\x04\x0c\x02\x03\x08\x12\x04\xdc\x04\x19*\n\r\n\x05\x04\x0c\x02\
+ \x03\x07\x12\x04\xdc\x04$)\n\xe8\x01\n\x04\x04\x0c\x02\x04\x12\x04\xe2\
+ \x04\x021\x1a\xd9\x01\x20Is\x20this\x20field\x20deprecated?\n\x20Dependi\
+ ng\x20on\x20the\x20target\x20platform,\x20this\x20can\x20emit\x20Depreca\
+ ted\x20annotations\n\x20for\x20accessors,\x20or\x20it\x20will\x20be\x20c\
+ ompletely\x20ignored;\x20in\x20the\x20very\x20least,\x20this\n\x20is\x20\
+ a\x20formalization\x20for\x20deprecating\x20fields.\n\n\r\n\x05\x04\x0c\
+ \x02\x04\x04\x12\x04\xe2\x04\x02\n\n\r\n\x05\x04\x0c\x02\x04\x05\x12\x04\
+ \xe2\x04\x0b\x0f\n\r\n\x05\x04\x0c\x02\x04\x01\x12\x04\xe2\x04\x10\x1a\n\
+ \r\n\x05\x04\x0c\x02\x04\x03\x12\x04\xe2\x04\x1d\x1e\n\r\n\x05\x04\x0c\
+ \x02\x04\x08\x12\x04\xe2\x04\x1f0\n\r\n\x05\x04\x0c\x02\x04\x07\x12\x04\
+ \xe2\x04*/\n?\n\x04\x04\x0c\x02\x05\x12\x04\xe5\x04\x02,\x1a1\x20For\x20\
+ Google-internal\x20migration\x20only.\x20Do\x20not\x20use.\n\n\r\n\x05\
+ \x04\x0c\x02\x05\x04\x12\x04\xe5\x04\x02\n\n\r\n\x05\x04\x0c\x02\x05\x05\
+ \x12\x04\xe5\x04\x0b\x0f\n\r\n\x05\x04\x0c\x02\x05\x01\x12\x04\xe5\x04\
+ \x10\x14\n\r\n\x05\x04\x0c\x02\x05\x03\x12\x04\xe5\x04\x17\x19\n\r\n\x05\
+ \x04\x0c\x02\x05\x08\x12\x04\xe5\x04\x1a+\n\r\n\x05\x04\x0c\x02\x05\x07\
+ \x12\x04\xe5\x04%*\nO\n\x04\x04\x0c\x02\x06\x12\x04\xe9\x04\x02:\x1aA\
+ \x20The\x20parser\x20stores\x20options\x20it\x20doesn't\x20recognize\x20\
+ here.\x20See\x20above.\n\n\r\n\x05\x04\x0c\x02\x06\x04\x12\x04\xe9\x04\
+ \x02\n\n\r\n\x05\x04\x0c\x02\x06\x06\x12\x04\xe9\x04\x0b\x1e\n\r\n\x05\
+ \x04\x0c\x02\x06\x01\x12\x04\xe9\x04\x1f3\n\r\n\x05\x04\x0c\x02\x06\x03\
+ \x12\x04\xe9\x0469\nZ\n\x03\x04\x0c\x05\x12\x04\xec\x04\x02\x19\x1aM\x20\
+ Clients\x20can\x20define\x20custom\x20options\x20in\x20extensions\x20of\
+ \x20this\x20message.\x20See\x20above.\n\n\x0c\n\x04\x04\x0c\x05\0\x12\
+ \x04\xec\x04\r\x18\n\r\n\x05\x04\x0c\x05\0\x01\x12\x04\xec\x04\r\x11\n\r\
+ \n\x05\x04\x0c\x05\0\x02\x12\x04\xec\x04\x15\x18\n\x1c\n\x03\x04\x0c\t\
+ \x12\x04\xee\x04\x02\r\"\x0f\x20removed\x20jtype\n\n\x0c\n\x04\x04\x0c\t\
+ \0\x12\x04\xee\x04\x0b\x0c\n\r\n\x05\x04\x0c\t\0\x01\x12\x04\xee\x04\x0b\
+ \x0c\n\r\n\x05\x04\x0c\t\0\x02\x12\x04\xee\x04\x0b\x0c\n\x0c\n\x02\x04\r\
+ \x12\x06\xf1\x04\0\xf7\x04\x01\n\x0b\n\x03\x04\r\x01\x12\x04\xf1\x04\x08\
+ \x14\nO\n\x04\x04\r\x02\0\x12\x04\xf3\x04\x02:\x1aA\x20The\x20parser\x20\
+ stores\x20options\x20it\x20doesn't\x20recognize\x20here.\x20See\x20above\
+ .\n\n\r\n\x05\x04\r\x02\0\x04\x12\x04\xf3\x04\x02\n\n\r\n\x05\x04\r\x02\
+ \0\x06\x12\x04\xf3\x04\x0b\x1e\n\r\n\x05\x04\r\x02\0\x01\x12\x04\xf3\x04\
+ \x1f3\n\r\n\x05\x04\r\x02\0\x03\x12\x04\xf3\x0469\nZ\n\x03\x04\r\x05\x12\
+ \x04\xf6\x04\x02\x19\x1aM\x20Clients\x20can\x20define\x20custom\x20optio\
+ ns\x20in\x20extensions\x20of\x20this\x20message.\x20See\x20above.\n\n\
+ \x0c\n\x04\x04\r\x05\0\x12\x04\xf6\x04\r\x18\n\r\n\x05\x04\r\x05\0\x01\
+ \x12\x04\xf6\x04\r\x11\n\r\n\x05\x04\r\x05\0\x02\x12\x04\xf6\x04\x15\x18\
+ \n\x0c\n\x02\x04\x0e\x12\x06\xf9\x04\0\x8c\x05\x01\n\x0b\n\x03\x04\x0e\
+ \x01\x12\x04\xf9\x04\x08\x13\n`\n\x04\x04\x0e\x02\0\x12\x04\xfd\x04\x02\
+ \x20\x1aR\x20Set\x20this\x20option\x20to\x20true\x20to\x20allow\x20mappi\
+ ng\x20different\x20tag\x20names\x20to\x20the\x20same\n\x20value.\n\n\r\n\
+ \x05\x04\x0e\x02\0\x04\x12\x04\xfd\x04\x02\n\n\r\n\x05\x04\x0e\x02\0\x05\
+ \x12\x04\xfd\x04\x0b\x0f\n\r\n\x05\x04\x0e\x02\0\x01\x12\x04\xfd\x04\x10\
+ \x1b\n\r\n\x05\x04\x0e\x02\0\x03\x12\x04\xfd\x04\x1e\x1f\n\xe5\x01\n\x04\
+ \x04\x0e\x02\x01\x12\x04\x83\x05\x021\x1a\xd6\x01\x20Is\x20this\x20enum\
+ \x20deprecated?\n\x20Depending\x20on\x20the\x20target\x20platform,\x20th\
+ is\x20can\x20emit\x20Deprecated\x20annotations\n\x20for\x20the\x20enum,\
+ \x20or\x20it\x20will\x20be\x20completely\x20ignored;\x20in\x20the\x20ver\
+ y\x20least,\x20this\n\x20is\x20a\x20formalization\x20for\x20deprecating\
+ \x20enums.\n\n\r\n\x05\x04\x0e\x02\x01\x04\x12\x04\x83\x05\x02\n\n\r\n\
+ \x05\x04\x0e\x02\x01\x05\x12\x04\x83\x05\x0b\x0f\n\r\n\x05\x04\x0e\x02\
+ \x01\x01\x12\x04\x83\x05\x10\x1a\n\r\n\x05\x04\x0e\x02\x01\x03\x12\x04\
+ \x83\x05\x1d\x1e\n\r\n\x05\x04\x0e\x02\x01\x08\x12\x04\x83\x05\x1f0\n\r\
+ \n\x05\x04\x0e\x02\x01\x07\x12\x04\x83\x05*/\n\x1f\n\x03\x04\x0e\t\x12\
+ \x04\x85\x05\x02\r\"\x12\x20javanano_as_lite\n\n\x0c\n\x04\x04\x0e\t\0\
+ \x12\x04\x85\x05\x0b\x0c\n\r\n\x05\x04\x0e\t\0\x01\x12\x04\x85\x05\x0b\
+ \x0c\n\r\n\x05\x04\x0e\t\0\x02\x12\x04\x85\x05\x0b\x0c\nO\n\x04\x04\x0e\
+ \x02\x02\x12\x04\x88\x05\x02:\x1aA\x20The\x20parser\x20stores\x20options\
+ \x20it\x20doesn't\x20recognize\x20here.\x20See\x20above.\n\n\r\n\x05\x04\
+ \x0e\x02\x02\x04\x12\x04\x88\x05\x02\n\n\r\n\x05\x04\x0e\x02\x02\x06\x12\
+ \x04\x88\x05\x0b\x1e\n\r\n\x05\x04\x0e\x02\x02\x01\x12\x04\x88\x05\x1f3\
+ \n\r\n\x05\x04\x0e\x02\x02\x03\x12\x04\x88\x0569\nZ\n\x03\x04\x0e\x05\
+ \x12\x04\x8b\x05\x02\x19\x1aM\x20Clients\x20can\x20define\x20custom\x20o\
+ ptions\x20in\x20extensions\x20of\x20this\x20message.\x20See\x20above.\n\
+ \n\x0c\n\x04\x04\x0e\x05\0\x12\x04\x8b\x05\r\x18\n\r\n\x05\x04\x0e\x05\0\
+ \x01\x12\x04\x8b\x05\r\x11\n\r\n\x05\x04\x0e\x05\0\x02\x12\x04\x8b\x05\
+ \x15\x18\n\x0c\n\x02\x04\x0f\x12\x06\x8e\x05\0\x9a\x05\x01\n\x0b\n\x03\
+ \x04\x0f\x01\x12\x04\x8e\x05\x08\x18\n\xf7\x01\n\x04\x04\x0f\x02\0\x12\
+ \x04\x93\x05\x021\x1a\xe8\x01\x20Is\x20this\x20enum\x20value\x20deprecat\
+ ed?\n\x20Depending\x20on\x20the\x20target\x20platform,\x20this\x20can\
+ \x20emit\x20Deprecated\x20annotations\n\x20for\x20the\x20enum\x20value,\
+ \x20or\x20it\x20will\x20be\x20completely\x20ignored;\x20in\x20the\x20ver\
+ y\x20least,\n\x20this\x20is\x20a\x20formalization\x20for\x20deprecating\
+ \x20enum\x20values.\n\n\r\n\x05\x04\x0f\x02\0\x04\x12\x04\x93\x05\x02\n\
+ \n\r\n\x05\x04\x0f\x02\0\x05\x12\x04\x93\x05\x0b\x0f\n\r\n\x05\x04\x0f\
+ \x02\0\x01\x12\x04\x93\x05\x10\x1a\n\r\n\x05\x04\x0f\x02\0\x03\x12\x04\
+ \x93\x05\x1d\x1e\n\r\n\x05\x04\x0f\x02\0\x08\x12\x04\x93\x05\x1f0\n\r\n\
+ \x05\x04\x0f\x02\0\x07\x12\x04\x93\x05*/\nO\n\x04\x04\x0f\x02\x01\x12\
+ \x04\x96\x05\x02:\x1aA\x20The\x20parser\x20stores\x20options\x20it\x20do\
+ esn't\x20recognize\x20here.\x20See\x20above.\n\n\r\n\x05\x04\x0f\x02\x01\
+ \x04\x12\x04\x96\x05\x02\n\n\r\n\x05\x04\x0f\x02\x01\x06\x12\x04\x96\x05\
+ \x0b\x1e\n\r\n\x05\x04\x0f\x02\x01\x01\x12\x04\x96\x05\x1f3\n\r\n\x05\
+ \x04\x0f\x02\x01\x03\x12\x04\x96\x0569\nZ\n\x03\x04\x0f\x05\x12\x04\x99\
+ \x05\x02\x19\x1aM\x20Clients\x20can\x20define\x20custom\x20options\x20in\
+ \x20extensions\x20of\x20this\x20message.\x20See\x20above.\n\n\x0c\n\x04\
+ \x04\x0f\x05\0\x12\x04\x99\x05\r\x18\n\r\n\x05\x04\x0f\x05\0\x01\x12\x04\
+ \x99\x05\r\x11\n\r\n\x05\x04\x0f\x05\0\x02\x12\x04\x99\x05\x15\x18\n\x0c\
+ \n\x02\x04\x10\x12\x06\x9c\x05\0\xae\x05\x01\n\x0b\n\x03\x04\x10\x01\x12\
+ \x04\x9c\x05\x08\x16\n\xd9\x03\n\x04\x04\x10\x02\0\x12\x04\xa7\x05\x022\
+ \x1a\xdf\x01\x20Is\x20this\x20service\x20deprecated?\n\x20Depending\x20o\
+ n\x20the\x20target\x20platform,\x20this\x20can\x20emit\x20Deprecated\x20\
+ annotations\n\x20for\x20the\x20service,\x20or\x20it\x20will\x20be\x20com\
+ pletely\x20ignored;\x20in\x20the\x20very\x20least,\n\x20this\x20is\x20a\
+ \x20formalization\x20for\x20deprecating\x20services.\n2\xe8\x01\x20Note:\
+ \x20\x20Field\x20numbers\x201\x20through\x2032\x20are\x20reserved\x20for\
+ \x20Google's\x20internal\x20RPC\n\x20\x20\x20framework.\x20\x20We\x20apo\
+ logize\x20for\x20hoarding\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\x10\x02\0\x04\x12\x04\xa7\x05\x02\n\n\r\n\x05\x04\x10\x02\0\
+ \x05\x12\x04\xa7\x05\x0b\x0f\n\r\n\x05\x04\x10\x02\0\x01\x12\x04\xa7\x05\
+ \x10\x1a\n\r\n\x05\x04\x10\x02\0\x03\x12\x04\xa7\x05\x1d\x1f\n\r\n\x05\
+ \x04\x10\x02\0\x08\x12\x04\xa7\x05\x201\n\r\n\x05\x04\x10\x02\0\x07\x12\
+ \x04\xa7\x05+0\nO\n\x04\x04\x10\x02\x01\x12\x04\xaa\x05\x02:\x1aA\x20The\
+ \x20parser\x20stores\x20options\x20it\x20doesn't\x20recognize\x20here.\
+ \x20See\x20above.\n\n\r\n\x05\x04\x10\x02\x01\x04\x12\x04\xaa\x05\x02\n\
+ \n\r\n\x05\x04\x10\x02\x01\x06\x12\x04\xaa\x05\x0b\x1e\n\r\n\x05\x04\x10\
+ \x02\x01\x01\x12\x04\xaa\x05\x1f3\n\r\n\x05\x04\x10\x02\x01\x03\x12\x04\
+ \xaa\x0569\nZ\n\x03\x04\x10\x05\x12\x04\xad\x05\x02\x19\x1aM\x20Clients\
+ \x20can\x20define\x20custom\x20options\x20in\x20extensions\x20of\x20this\
+ \x20message.\x20See\x20above.\n\n\x0c\n\x04\x04\x10\x05\0\x12\x04\xad\
+ \x05\r\x18\n\r\n\x05\x04\x10\x05\0\x01\x12\x04\xad\x05\r\x11\n\r\n\x05\
+ \x04\x10\x05\0\x02\x12\x04\xad\x05\x15\x18\n\x0c\n\x02\x04\x11\x12\x06\
+ \xb0\x05\0\xcd\x05\x01\n\x0b\n\x03\x04\x11\x01\x12\x04\xb0\x05\x08\x15\n\
+ \xd6\x03\n\x04\x04\x11\x02\0\x12\x04\xbb\x05\x022\x1a\xdc\x01\x20Is\x20t\
+ his\x20method\x20deprecated?\n\x20Depending\x20on\x20the\x20target\x20pl\
+ atform,\x20this\x20can\x20emit\x20Deprecated\x20annotations\n\x20for\x20\
+ the\x20method,\x20or\x20it\x20will\x20be\x20completely\x20ignored;\x20in\
+ \x20the\x20very\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\x20hoardin\
+ g\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\x11\x02\0\
+ \x04\x12\x04\xbb\x05\x02\n\n\r\n\x05\x04\x11\x02\0\x05\x12\x04\xbb\x05\
+ \x0b\x0f\n\r\n\x05\x04\x11\x02\0\x01\x12\x04\xbb\x05\x10\x1a\n\r\n\x05\
+ \x04\x11\x02\0\x03\x12\x04\xbb\x05\x1d\x1f\n\r\n\x05\x04\x11\x02\0\x08\
+ \x12\x04\xbb\x05\x201\n\r\n\x05\x04\x11\x02\0\x07\x12\x04\xbb\x05+0\n\
+ \xf0\x01\n\x04\x04\x11\x04\0\x12\x06\xc0\x05\x02\xc4\x05\x03\x1a\xdf\x01\
+ \x20Is\x20this\x20method\x20side-effect-free\x20(or\x20safe\x20in\x20HTT\
+ P\x20parlance),\x20or\x20idempotent,\n\x20or\x20neither?\x20HTTP\x20base\
+ d\x20RPC\x20implementation\x20may\x20choose\x20GET\x20verb\x20for\x20saf\
+ e\n\x20methods,\x20and\x20PUT\x20verb\x20for\x20idempotent\x20methods\
+ \x20instead\x20of\x20the\x20default\x20POST.\n\n\r\n\x05\x04\x11\x04\0\
+ \x01\x12\x04\xc0\x05\x07\x17\n\x0e\n\x06\x04\x11\x04\0\x02\0\x12\x04\xc1\
+ \x05\x04\x1c\n\x0f\n\x07\x04\x11\x04\0\x02\0\x01\x12\x04\xc1\x05\x04\x17\
+ \n\x0f\n\x07\x04\x11\x04\0\x02\0\x02\x12\x04\xc1\x05\x1a\x1b\n$\n\x06\
+ \x04\x11\x04\0\x02\x01\x12\x04\xc2\x05\x04\x18\"\x14\x20implies\x20idemp\
+ otent\n\n\x0f\n\x07\x04\x11\x04\0\x02\x01\x01\x12\x04\xc2\x05\x04\x13\n\
+ \x0f\n\x07\x04\x11\x04\0\x02\x01\x02\x12\x04\xc2\x05\x16\x17\n7\n\x06\
+ \x04\x11\x04\0\x02\x02\x12\x04\xc3\x05\x04\x13\"'\x20idempotent,\x20but\
+ \x20may\x20have\x20side\x20effects\n\n\x0f\n\x07\x04\x11\x04\0\x02\x02\
+ \x01\x12\x04\xc3\x05\x04\x0e\n\x0f\n\x07\x04\x11\x04\0\x02\x02\x02\x12\
+ \x04\xc3\x05\x11\x12\n\x0e\n\x04\x04\x11\x02\x01\x12\x06\xc5\x05\x02\xc6\
+ \x05&\n\r\n\x05\x04\x11\x02\x01\x04\x12\x04\xc5\x05\x02\n\n\r\n\x05\x04\
+ \x11\x02\x01\x06\x12\x04\xc5\x05\x0b\x1b\n\r\n\x05\x04\x11\x02\x01\x01\
+ \x12\x04\xc5\x05\x1c-\n\r\n\x05\x04\x11\x02\x01\x03\x12\x04\xc5\x0502\n\
+ \r\n\x05\x04\x11\x02\x01\x08\x12\x04\xc6\x05\x06%\n\r\n\x05\x04\x11\x02\
+ \x01\x07\x12\x04\xc6\x05\x11$\nO\n\x04\x04\x11\x02\x02\x12\x04\xc9\x05\
+ \x02:\x1aA\x20The\x20parser\x20stores\x20options\x20it\x20doesn't\x20rec\
+ ognize\x20here.\x20See\x20above.\n\n\r\n\x05\x04\x11\x02\x02\x04\x12\x04\
+ \xc9\x05\x02\n\n\r\n\x05\x04\x11\x02\x02\x06\x12\x04\xc9\x05\x0b\x1e\n\r\
+ \n\x05\x04\x11\x02\x02\x01\x12\x04\xc9\x05\x1f3\n\r\n\x05\x04\x11\x02\
+ \x02\x03\x12\x04\xc9\x0569\nZ\n\x03\x04\x11\x05\x12\x04\xcc\x05\x02\x19\
+ \x1aM\x20Clients\x20can\x20define\x20custom\x20options\x20in\x20extensio\
+ ns\x20of\x20this\x20message.\x20See\x20above.\n\n\x0c\n\x04\x04\x11\x05\
+ \0\x12\x04\xcc\x05\r\x18\n\r\n\x05\x04\x11\x05\0\x01\x12\x04\xcc\x05\r\
+ \x11\n\r\n\x05\x04\x11\x05\0\x02\x12\x04\xcc\x05\x15\x18\n\x8b\x03\n\x02\
+ \x04\x12\x12\x06\xd6\x05\0\xea\x05\x01\x1a\xfc\x02\x20A\x20message\x20re\
+ presenting\x20a\x20option\x20the\x20parser\x20does\x20not\x20recognize.\
+ \x20This\x20only\n\x20appears\x20in\x20options\x20protos\x20created\x20b\
+ y\x20the\x20compiler::Parser\x20class.\n\x20DescriptorPool\x20resolves\
+ \x20these\x20when\x20building\x20Descriptor\x20objects.\x20Therefore,\n\
+ \x20options\x20protos\x20in\x20descriptor\x20objects\x20(e.g.\x20returne\
+ d\x20by\x20Descriptor::options(),\n\x20or\x20produced\x20by\x20Descripto\
+ r::CopyTo())\x20will\x20never\x20have\x20UninterpretedOptions\n\x20in\
+ \x20them.\n\n\x0b\n\x03\x04\x12\x01\x12\x04\xd6\x05\x08\x1b\n\xcb\x02\n\
+ \x04\x04\x12\x03\0\x12\x06\xdc\x05\x02\xdf\x05\x03\x1a\xba\x02\x20The\
+ \x20name\x20of\x20the\x20uninterpreted\x20option.\x20\x20Each\x20string\
+ \x20represents\x20a\x20segment\x20in\n\x20a\x20dot-separated\x20name.\
+ \x20\x20is_extension\x20is\x20true\x20iff\x20a\x20segment\x20represents\
+ \x20an\n\x20extension\x20(denoted\x20with\x20parentheses\x20in\x20option\
+ s\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\x12\x03\0\x01\x12\x04\xdc\x05\
+ \n\x12\n\x0e\n\x06\x04\x12\x03\0\x02\0\x12\x04\xdd\x05\x04\"\n\x0f\n\x07\
+ \x04\x12\x03\0\x02\0\x04\x12\x04\xdd\x05\x04\x0c\n\x0f\n\x07\x04\x12\x03\
+ \0\x02\0\x05\x12\x04\xdd\x05\r\x13\n\x0f\n\x07\x04\x12\x03\0\x02\0\x01\
+ \x12\x04\xdd\x05\x14\x1d\n\x0f\n\x07\x04\x12\x03\0\x02\0\x03\x12\x04\xdd\
+ \x05\x20!\n\x0e\n\x06\x04\x12\x03\0\x02\x01\x12\x04\xde\x05\x04#\n\x0f\n\
+ \x07\x04\x12\x03\0\x02\x01\x04\x12\x04\xde\x05\x04\x0c\n\x0f\n\x07\x04\
+ \x12\x03\0\x02\x01\x05\x12\x04\xde\x05\r\x11\n\x0f\n\x07\x04\x12\x03\0\
+ \x02\x01\x01\x12\x04\xde\x05\x12\x1e\n\x0f\n\x07\x04\x12\x03\0\x02\x01\
+ \x03\x12\x04\xde\x05!\"\n\x0c\n\x04\x04\x12\x02\0\x12\x04\xe0\x05\x02\
+ \x1d\n\r\n\x05\x04\x12\x02\0\x04\x12\x04\xe0\x05\x02\n\n\r\n\x05\x04\x12\
+ \x02\0\x06\x12\x04\xe0\x05\x0b\x13\n\r\n\x05\x04\x12\x02\0\x01\x12\x04\
+ \xe0\x05\x14\x18\n\r\n\x05\x04\x12\x02\0\x03\x12\x04\xe0\x05\x1b\x1c\n\
+ \x9c\x01\n\x04\x04\x12\x02\x01\x12\x04\xe4\x05\x02'\x1a\x8d\x01\x20The\
+ \x20value\x20of\x20the\x20uninterpreted\x20option,\x20in\x20whatever\x20\
+ type\x20the\x20tokenizer\n\x20identified\x20it\x20as\x20during\x20parsin\
+ g.\x20Exactly\x20one\x20of\x20these\x20should\x20be\x20set.\n\n\r\n\x05\
+ \x04\x12\x02\x01\x04\x12\x04\xe4\x05\x02\n\n\r\n\x05\x04\x12\x02\x01\x05\
+ \x12\x04\xe4\x05\x0b\x11\n\r\n\x05\x04\x12\x02\x01\x01\x12\x04\xe4\x05\
+ \x12\"\n\r\n\x05\x04\x12\x02\x01\x03\x12\x04\xe4\x05%&\n\x0c\n\x04\x04\
+ \x12\x02\x02\x12\x04\xe5\x05\x02)\n\r\n\x05\x04\x12\x02\x02\x04\x12\x04\
+ \xe5\x05\x02\n\n\r\n\x05\x04\x12\x02\x02\x05\x12\x04\xe5\x05\x0b\x11\n\r\
+ \n\x05\x04\x12\x02\x02\x01\x12\x04\xe5\x05\x12$\n\r\n\x05\x04\x12\x02\
+ \x02\x03\x12\x04\xe5\x05'(\n\x0c\n\x04\x04\x12\x02\x03\x12\x04\xe6\x05\
+ \x02(\n\r\n\x05\x04\x12\x02\x03\x04\x12\x04\xe6\x05\x02\n\n\r\n\x05\x04\
+ \x12\x02\x03\x05\x12\x04\xe6\x05\x0b\x10\n\r\n\x05\x04\x12\x02\x03\x01\
+ \x12\x04\xe6\x05\x11#\n\r\n\x05\x04\x12\x02\x03\x03\x12\x04\xe6\x05&'\n\
+ \x0c\n\x04\x04\x12\x02\x04\x12\x04\xe7\x05\x02#\n\r\n\x05\x04\x12\x02\
+ \x04\x04\x12\x04\xe7\x05\x02\n\n\r\n\x05\x04\x12\x02\x04\x05\x12\x04\xe7\
+ \x05\x0b\x11\n\r\n\x05\x04\x12\x02\x04\x01\x12\x04\xe7\x05\x12\x1e\n\r\n\
+ \x05\x04\x12\x02\x04\x03\x12\x04\xe7\x05!\"\n\x0c\n\x04\x04\x12\x02\x05\
+ \x12\x04\xe8\x05\x02\"\n\r\n\x05\x04\x12\x02\x05\x04\x12\x04\xe8\x05\x02\
+ \n\n\r\n\x05\x04\x12\x02\x05\x05\x12\x04\xe8\x05\x0b\x10\n\r\n\x05\x04\
+ \x12\x02\x05\x01\x12\x04\xe8\x05\x11\x1d\n\r\n\x05\x04\x12\x02\x05\x03\
+ \x12\x04\xe8\x05\x20!\n\x0c\n\x04\x04\x12\x02\x06\x12\x04\xe9\x05\x02&\n\
+ \r\n\x05\x04\x12\x02\x06\x04\x12\x04\xe9\x05\x02\n\n\r\n\x05\x04\x12\x02\
+ \x06\x05\x12\x04\xe9\x05\x0b\x11\n\r\n\x05\x04\x12\x02\x06\x01\x12\x04\
+ \xe9\x05\x12!\n\r\n\x05\x04\x12\x02\x06\x03\x12\x04\xe9\x05$%\n\xda\x01\
+ \n\x02\x04\x13\x12\x06\xf1\x05\0\xf2\x06\x01\x1aj\x20Encapsulates\x20inf\
+ ormation\x20about\x20the\x20original\x20source\x20file\x20from\x20which\
+ \x20a\n\x20FileDescriptorProto\x20was\x20generated.\n2`\x20=============\
+ ======================================================\n\x20Optional\x20\
+ source\x20code\x20info\n\n\x0b\n\x03\x04\x13\x01\x12\x04\xf1\x05\x08\x16\
+ \n\x82\x11\n\x04\x04\x13\x02\0\x12\x04\x9d\x06\x02!\x1a\xf3\x10\x20A\x20\
+ Location\x20identifies\x20a\x20piece\x20of\x20source\x20code\x20in\x20a\
+ \x20.proto\x20file\x20which\n\x20corresponds\x20to\x20a\x20particular\
+ \x20definition.\x20\x20This\x20information\x20is\x20intended\n\x20to\x20\
+ be\x20useful\x20to\x20IDEs,\x20code\x20indexers,\x20documentation\x20gen\
+ erators,\x20and\x20similar\n\x20tools.\n\n\x20For\x20example,\x20say\x20\
+ we\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\x20definition:\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\x20\
+ represents\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\x20label\x20(opti\
+ onal).\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,\x20\
+ 2,\x200,\x201\x20]\x20\x20The\x20name\x20(foo).\n\x20\x20\x20[g,h)\x20\
+ \x20[\x204,\x200,\x202,\x200,\x203\x20]\x20\x20The\x20number\x20(1).\n\n\
+ \x20Notes:\n\x20-\x20A\x20location\x20may\x20refer\x20to\x20a\x20repeate\
+ d\x20field\x20itself\x20(i.e.\x20not\x20to\x20any\n\x20\x20\x20particula\
+ r\x20index\x20within\x20it).\x20\x20This\x20is\x20used\x20whenever\x20a\
+ \x20set\x20of\x20elements\x20are\n\x20\x20\x20logically\x20enclosed\x20i\
+ n\x20a\x20single\x20code\x20segment.\x20\x20For\x20example,\x20an\x20ent\
+ ire\n\x20\x20\x20extend\x20block\x20(possibly\x20containing\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-\x20Mul\
+ tiple\x20locations\x20may\x20have\x20the\x20same\x20path.\x20\x20This\
+ \x20happens\x20when\x20a\x20single\n\x20\x20\x20logical\x20declaration\
+ \x20is\x20spread\x20out\x20across\x20multiple\x20places.\x20\x20The\x20m\
+ ost\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\x20which\x20will\
+ \x20have\x20the\x20same\x20path.\n\x20-\x20A\x20location's\x20span\x20is\
+ \x20not\x20always\x20a\x20subset\x20of\x20its\x20parent's\x20span.\x20\
+ \x20For\n\x20\x20\x20example,\x20the\x20\"extendee\"\x20of\x20an\x20exte\
+ nsion\x20declaration\x20appears\x20at\x20the\n\x20\x20\x20beginning\x20o\
+ f\x20the\x20\"extend\"\x20block\x20and\x20is\x20shared\x20by\x20all\x20e\
+ xtensions\x20within\n\x20\x20\x20the\x20block.\n\x20-\x20Just\x20because\
+ \x20a\x20location's\x20span\x20is\x20a\x20subset\x20of\x20some\x20other\
+ \x20location's\x20span\n\x20\x20\x20does\x20not\x20mean\x20that\x20it\
+ \x20is\x20a\x20descendant.\x20\x20For\x20example,\x20a\x20\"group\"\x20d\
+ efines\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\x20their\
+ \x20components\x20will\x20overlap.\n\x20-\x20Code\x20which\x20tries\x20t\
+ o\x20interpret\x20locations\x20should\x20probably\x20be\x20designed\x20t\
+ o\n\x20\x20\x20ignore\x20those\x20that\x20it\x20doesn't\x20understand,\
+ \x20as\x20more\x20types\x20of\x20locations\x20could\n\x20\x20\x20be\x20r\
+ ecorded\x20in\x20the\x20future.\n\n\r\n\x05\x04\x13\x02\0\x04\x12\x04\
+ \x9d\x06\x02\n\n\r\n\x05\x04\x13\x02\0\x06\x12\x04\x9d\x06\x0b\x13\n\r\n\
+ \x05\x04\x13\x02\0\x01\x12\x04\x9d\x06\x14\x1c\n\r\n\x05\x04\x13\x02\0\
+ \x03\x12\x04\x9d\x06\x1f\x20\n\x0e\n\x04\x04\x13\x03\0\x12\x06\x9e\x06\
+ \x02\xf1\x06\x03\n\r\n\x05\x04\x13\x03\0\x01\x12\x04\x9e\x06\n\x12\n\x83\
+ \x07\n\x06\x04\x13\x03\0\x02\0\x12\x04\xb6\x06\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\x13\x03\0\x02\0\x04\x12\x04\xb6\x06\x04\x0c\n\x0f\
+ \n\x07\x04\x13\x03\0\x02\0\x05\x12\x04\xb6\x06\r\x12\n\x0f\n\x07\x04\x13\
+ \x03\0\x02\0\x01\x12\x04\xb6\x06\x13\x17\n\x0f\n\x07\x04\x13\x03\0\x02\0\
+ \x03\x12\x04\xb6\x06\x1a\x1b\n\x0f\n\x07\x04\x13\x03\0\x02\0\x08\x12\x04\
+ \xb6\x06\x1c+\n\x10\n\x08\x04\x13\x03\0\x02\0\x08\x02\x12\x04\xb6\x06\
+ \x1d*\n\xd2\x02\n\x06\x04\x13\x03\0\x02\x01\x12\x04\xbd\x06\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\x13\x03\0\x02\x01\x04\x12\x04\xbd\x06\x04\x0c\n\x0f\n\x07\x04\
+ \x13\x03\0\x02\x01\x05\x12\x04\xbd\x06\r\x12\n\x0f\n\x07\x04\x13\x03\0\
+ \x02\x01\x01\x12\x04\xbd\x06\x13\x17\n\x0f\n\x07\x04\x13\x03\0\x02\x01\
+ \x03\x12\x04\xbd\x06\x1a\x1b\n\x0f\n\x07\x04\x13\x03\0\x02\x01\x08\x12\
+ \x04\xbd\x06\x1c+\n\x10\n\x08\x04\x13\x03\0\x02\x01\x08\x02\x12\x04\xbd\
+ \x06\x1d*\n\xa5\x0c\n\x06\x04\x13\x03\0\x02\x02\x12\x04\xee\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\x13\x03\0\x02\x02\x04\x12\x04\xee\x06\x04\x0c\n\x0f\n\
+ \x07\x04\x13\x03\0\x02\x02\x05\x12\x04\xee\x06\r\x13\n\x0f\n\x07\x04\x13\
+ \x03\0\x02\x02\x01\x12\x04\xee\x06\x14$\n\x0f\n\x07\x04\x13\x03\0\x02\
+ \x02\x03\x12\x04\xee\x06'(\n\x0e\n\x06\x04\x13\x03\0\x02\x03\x12\x04\xef\
+ \x06\x04*\n\x0f\n\x07\x04\x13\x03\0\x02\x03\x04\x12\x04\xef\x06\x04\x0c\
+ \n\x0f\n\x07\x04\x13\x03\0\x02\x03\x05\x12\x04\xef\x06\r\x13\n\x0f\n\x07\
+ \x04\x13\x03\0\x02\x03\x01\x12\x04\xef\x06\x14%\n\x0f\n\x07\x04\x13\x03\
+ \0\x02\x03\x03\x12\x04\xef\x06()\n\x0e\n\x06\x04\x13\x03\0\x02\x04\x12\
+ \x04\xf0\x06\x042\n\x0f\n\x07\x04\x13\x03\0\x02\x04\x04\x12\x04\xf0\x06\
+ \x04\x0c\n\x0f\n\x07\x04\x13\x03\0\x02\x04\x05\x12\x04\xf0\x06\r\x13\n\
+ \x0f\n\x07\x04\x13\x03\0\x02\x04\x01\x12\x04\xf0\x06\x14-\n\x0f\n\x07\
+ \x04\x13\x03\0\x02\x04\x03\x12\x04\xf0\x0601\n\xee\x01\n\x02\x04\x14\x12\
+ \x06\xf7\x06\0\x8c\x07\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\x14\x01\x12\x04\xf7\x06\x08\x19\nx\n\x04\x04\x14\x02\0\
+ \x12\x04\xfa\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\x14\x02\0\x04\
+ \x12\x04\xfa\x06\x02\n\n\r\n\x05\x04\x14\x02\0\x06\x12\x04\xfa\x06\x0b\
+ \x15\n\r\n\x05\x04\x14\x02\0\x01\x12\x04\xfa\x06\x16\x20\n\r\n\x05\x04\
+ \x14\x02\0\x03\x12\x04\xfa\x06#$\n\x0e\n\x04\x04\x14\x03\0\x12\x06\xfb\
+ \x06\x02\x8b\x07\x03\n\r\n\x05\x04\x14\x03\0\x01\x12\x04\xfb\x06\n\x14\n\
+ \x8f\x01\n\x06\x04\x14\x03\0\x02\0\x12\x04\xfe\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\x14\x03\0\x02\0\x04\x12\x04\
+ \xfe\x06\x04\x0c\n\x0f\n\x07\x04\x14\x03\0\x02\0\x05\x12\x04\xfe\x06\r\
+ \x12\n\x0f\n\x07\x04\x14\x03\0\x02\0\x01\x12\x04\xfe\x06\x13\x17\n\x0f\n\
+ \x07\x04\x14\x03\0\x02\0\x03\x12\x04\xfe\x06\x1a\x1b\n\x0f\n\x07\x04\x14\
+ \x03\0\x02\0\x08\x12\x04\xfe\x06\x1c+\n\x10\n\x08\x04\x14\x03\0\x02\0\
+ \x08\x02\x12\x04\xfe\x06\x1d*\nO\n\x06\x04\x14\x03\0\x02\x01\x12\x04\x81\
+ \x07\x04$\x1a?\x20Identifies\x20the\x20filesystem\x20path\x20to\x20the\
+ \x20original\x20source\x20.proto.\n\n\x0f\n\x07\x04\x14\x03\0\x02\x01\
+ \x04\x12\x04\x81\x07\x04\x0c\n\x0f\n\x07\x04\x14\x03\0\x02\x01\x05\x12\
+ \x04\x81\x07\r\x13\n\x0f\n\x07\x04\x14\x03\0\x02\x01\x01\x12\x04\x81\x07\
+ \x14\x1f\n\x0f\n\x07\x04\x14\x03\0\x02\x01\x03\x12\x04\x81\x07\"#\nw\n\
+ \x06\x04\x14\x03\0\x02\x02\x12\x04\x85\x07\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\x14\x03\0\x02\x02\x04\x12\x04\x85\x07\x04\x0c\n\x0f\n\x07\
+ \x04\x14\x03\0\x02\x02\x05\x12\x04\x85\x07\r\x12\n\x0f\n\x07\x04\x14\x03\
+ \0\x02\x02\x01\x12\x04\x85\x07\x13\x18\n\x0f\n\x07\x04\x14\x03\0\x02\x02\
+ \x03\x12\x04\x85\x07\x1b\x1c\n\xdb\x01\n\x06\x04\x14\x03\0\x02\x03\x12\
+ \x04\x8a\x07\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\x14\x03\0\x02\x03\x04\x12\x04\x8a\x07\x04\x0c\n\x0f\n\x07\x04\
+ \x14\x03\0\x02\x03\x05\x12\x04\x8a\x07\r\x12\n\x0f\n\x07\x04\x14\x03\0\
+ \x02\x03\x01\x12\x04\x8a\x07\x13\x16\n\x0f\n\x07\x04\x14\x03\0\x02\x03\
+ \x03\x12\x04\x8a\x07\x19\x1a\
+";
+
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+ crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
+ file_descriptor_proto_lazy.get(|| {
+ parse_descriptor_proto()
+ })
+}
diff --git a/2.27.1/src/descriptorx.rs b/2.27.1/src/descriptorx.rs
new file mode 100644
index 0000000..7b046ec
--- /dev/null
+++ b/2.27.1/src/descriptorx.rs
@@ -0,0 +1,656 @@
+// Should not be a part of public API
+#![doc(hidden)]
+
+use crate::descriptor::DescriptorProto;
+use crate::descriptor::EnumDescriptorProto;
+use crate::descriptor::EnumValueDescriptorProto;
+use crate::descriptor::FieldDescriptorProto;
+/// utilities to work with descriptor
+use crate::descriptor::FileDescriptorProto;
+use crate::descriptor::OneofDescriptorProto;
+use crate::rust;
+use crate::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/2.27.1/src/enums.rs b/2.27.1/src/enums.rs
new file mode 100644
index 0000000..558d6ff
--- /dev/null
+++ b/2.27.1/src/enums.rs
@@ -0,0 +1,32 @@
+use crate::reflect::EnumDescriptor;
+use crate::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/2.27.1/src/error.rs b/2.27.1/src/error.rs
new file mode 100644
index 0000000..3f06909
--- /dev/null
+++ b/2.27.1/src/error.rs
@@ -0,0 +1,151 @@
+//! Protobuf error type
+
+use std::error::Error;
+use std::fmt;
+use std::io;
+use std::str;
+
+use crate::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<&dyn 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/2.27.1/src/ext.rs b/2.27.1/src/ext.rs
new file mode 100644
index 0000000..a1c18f6
--- /dev/null
+++ b/2.27.1/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 crate::message::Message;
+use crate::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/2.27.1/src/json/json_name.rs b/2.27.1/src/json/json_name.rs
new file mode 100644
index 0000000..f5c9364
--- /dev/null
+++ b/2.27.1/src/json/json_name.rs
@@ -0,0 +1,19 @@
+/// Implementation must match exactly
+/// `ToJsonName()` function in C++ `descriptor.cc`.
+pub fn json_name(input: &str) -> String {
+ let mut capitalize_next = false;
+ let mut result = String::with_capacity(input.len());
+
+ for c in input.chars() {
+ if c == '_' {
+ capitalize_next = true;
+ } else if capitalize_next {
+ result.extend(c.to_uppercase());
+ capitalize_next = false;
+ } else {
+ result.push(c);
+ }
+ }
+
+ result
+}
diff --git a/2.27.1/src/json/mod.rs b/2.27.1/src/json/mod.rs
new file mode 100644
index 0000000..2755aad
--- /dev/null
+++ b/2.27.1/src/json/mod.rs
@@ -0,0 +1,8 @@
+//! JSON serialization and deserialization.
+//!
+//! (Implemented in master, but not ported to stable branch yet).
+
+mod json_name;
+
+#[doc(hidden)]
+pub use self::json_name::json_name;
diff --git a/2.27.1/src/lazy.rs b/2.27.1/src/lazy.rs
new file mode 100644
index 0000000..3575dd0
--- /dev/null
+++ b/2.27.1/src/lazy.rs
@@ -0,0 +1,113 @@
+//! Lazily initialized data.
+//! Used in generated code.
+
+// Avoid deprecation warnings when compiling rust-protobuf
+#![allow(deprecated)]
+
+use std::mem;
+use std::sync;
+
+/// Lasily initialized data.
+#[deprecated(
+ since = "2.16",
+ note = "Please regenerate .rs files from .proto files to use newer APIs"
+)]
+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 std::sync::atomic::AtomicIsize;
+ use std::sync::atomic::Ordering;
+ use std::sync::Arc;
+ use std::sync::Barrier;
+ use std::thread;
+
+ use super::Lazy;
+
+ #[test]
+ fn many_threads_calling_get() {
+ const N_THREADS: usize = 32;
+ 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/2.27.1/src/lazy_v2.rs b/2.27.1/src/lazy_v2.rs
new file mode 100644
index 0000000..6f9ac1e
--- /dev/null
+++ b/2.27.1/src/lazy_v2.rs
@@ -0,0 +1,90 @@
+//! Lazily initialized data.
+//! Used in generated code.
+
+use std::cell::UnsafeCell;
+use std::sync;
+
+/// Lazily initialized data.
+pub struct LazyV2<T: Sync> {
+ lock: sync::Once,
+ ptr: UnsafeCell<*const T>,
+}
+
+unsafe impl<T: Sync> Sync for LazyV2<T> {}
+
+impl<T: Sync> LazyV2<T> {
+ /// Uninitialized `Lazy` object.
+ pub const INIT: LazyV2<T> = LazyV2 {
+ lock: sync::Once::new(),
+ ptr: UnsafeCell::new(0 as *const T),
+ };
+
+ /// Get lazy field value, initialize it with given function if not yet.
+ pub fn get<F>(&'static self, init: F) -> &'static T
+ where
+ F: FnOnce() -> T,
+ {
+ self.lock.call_once(|| unsafe {
+ *self.ptr.get() = Box::into_raw(Box::new(init()));
+ });
+ unsafe { &**self.ptr.get() }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use std::sync::atomic::AtomicIsize;
+ use std::sync::atomic::Ordering;
+ use std::sync::Arc;
+ use std::sync::Barrier;
+ use std::thread;
+
+ use super::LazyV2;
+
+ #[test]
+ fn many_threads_calling_get() {
+ const N_THREADS: usize = 32;
+ const N_ITERS_IN_THREAD: usize = 32;
+ const N_ITERS: usize = 16;
+
+ static mut LAZY: LazyV2<String> = LazyV2::INIT;
+ static CALL_COUNT: AtomicIsize = AtomicIsize::new(0);
+
+ let value = "Hello, world!".to_owned();
+
+ for _ in 0..N_ITERS {
+ // Reset mutable state.
+ unsafe {
+ LAZY = LazyV2::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/2.27.1/src/lib.rs b/2.27.1/src/lib.rs
new file mode 100644
index 0000000..d88e029
--- /dev/null
+++ b/2.27.1/src/lib.rs
@@ -0,0 +1,192 @@
+//! # Library to read and write protocol buffers data
+//!
+//! # Version 2 is stable
+//!
+//! Currently developed branch of rust-protobuf [is 3](https://docs.rs/protobuf/%3E=3.0.0-alpha).
+//! It has the same spirit as version 2, but contains numerous improvements like:
+//! * runtime reflection for mutability, not just for access
+//! * protobuf text format and JSON parsing (which rely on reflection)
+//! * dynamic message support: work with protobuf data without generating code from schema
+//!
+//! Stable version of rust-protobuf will be supported until version 3 released.
+//!
+//! [Tracking issue for version 3](https://github.com/stepancheg/rust-protobuf/issues/518).
+//!
+//! # How to generate rust code
+//!
+//! There are several ways to generate rust code from `.proto` files
+//!
+//! ## Invoke `protoc` programmatically with protoc-rust crate (recommended)
+//!
+//! Have a look at readme in [protoc-rust crate](https://docs.rs/protoc-rust/=2).
+//!
+//! ## Use pure rust protobuf parser and code generator
+//!
+//! Readme should be in
+//! [protobuf-codegen-pure crate](https://docs.rs/protobuf-codegen-pure/=2).
+//!
+//! ## Use protoc-gen-rust plugin
+//!
+//! Readme is [here](https://docs.rs/protobuf-codegen/=2).
+//!
+//! ## Generated code
+//!
+//! Have a look at generated files (for current development version),
+//! used internally in rust-protobuf:
+//!
+//! * [descriptor.rs](https://github.com/stepancheg/rust-protobuf/blob/master/protobuf/src/descriptor.rs)
+//! for [descriptor.proto](https://github.com/stepancheg/rust-protobuf/blob/master/protoc-bin-vendored/include/google/protobuf/descriptor.proto)
+//! (that is part of Google protobuf)
+//!
+//! # Copy on write
+//!
+//! Rust-protobuf can be used with [bytes crate](https://github.com/tokio-rs/bytes).
+//!
+//! To enable `Bytes` you need to:
+//!
+//! 1. Enable `with-bytes` feature in rust-protobuf:
+//!
+//! ```
+//! [dependencies]
+//! protobuf = { version = "~2.0", features = ["with-bytes"] }
+//! ```
+//!
+//! 2. Enable bytes option
+//!
+//! with `Customize` when codegen is invoked programmatically:
+//!
+//! ```ignore
+//! protoc_rust::run(protoc_rust::Args {
+//! ...
+//! customize: Customize {
+//! carllerche_bytes_for_bytes: Some(true),
+//! carllerche_bytes_for_string: Some(true),
+//! ..Default::default()
+//! },
+//! });
+//! ```
+//!
+//! or in `.proto` file:
+//!
+//! ```ignore
+//! import "rustproto.proto";
+//!
+//! option (rustproto.carllerche_bytes_for_bytes_all) = true;
+//! option (rustproto.carllerche_bytes_for_string_all) = true;
+//! ```
+//!
+//! With these options enabled, fields of type `bytes` or `string` are
+//! generated as `Bytes` or `Chars` respectively. When `CodedInputStream` is constructed
+//! from `Bytes` object, fields of these types get subslices of original `Bytes` object,
+//! instead of being allocated on heap.
+//!
+//! # Accompanying crates
+//!
+//! * [`protoc-rust`](https://docs.rs/protoc-rust/=2)
+//! and [`protobuf-codegen-pure`](https://docs.rs/protobuf-codegen-pure/=2)
+//! can be used to rust code from `.proto` crates.
+//! * [`protobuf-codegen`](https://docs.rs/protobuf-codegen/=2) for `protoc-gen-rust` protoc plugin.
+//! * [`protoc`](https://docs.rs/protoc/=2) crate can be used to invoke `protoc` programmatically.
+//! * [`protoc-bin-vendored`](https://docs.rs/protoc-bin-vendored/=2) contains `protoc` command
+//! packed into the crate.
+
+#![deny(missing_docs)]
+#![deny(rustdoc::broken_intra_doc_links)]
+
+#[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 crate::cached_size::CachedSize;
+#[cfg(feature = "bytes")]
+pub use crate::chars::Chars;
+pub use crate::clear::Clear;
+pub use crate::coded_input_stream::CodedInputStream;
+pub use crate::coded_output_stream::CodedOutputStream;
+pub use crate::enums::ProtobufEnum;
+pub use crate::error::ProtobufError;
+pub use crate::error::ProtobufResult;
+#[allow(deprecated)]
+pub use crate::message::parse_from_bytes;
+#[cfg(feature = "bytes")]
+#[allow(deprecated)]
+pub use crate::message::parse_from_carllerche_bytes;
+#[allow(deprecated)]
+pub use crate::message::parse_from_reader;
+#[allow(deprecated)]
+pub use crate::message::parse_length_delimited_from;
+#[allow(deprecated)]
+pub use crate::message::parse_length_delimited_from_bytes;
+#[allow(deprecated)]
+pub use crate::message::parse_length_delimited_from_reader;
+pub use crate::message::Message;
+pub use crate::repeated::RepeatedField;
+pub use crate::singular::SingularField;
+pub use crate::singular::SingularPtrField;
+pub use crate::unknown::UnknownFields;
+pub use crate::unknown::UnknownFieldsIter;
+pub use crate::unknown::UnknownValue;
+pub use crate::unknown::UnknownValueRef;
+pub use crate::unknown::UnknownValues;
+pub use crate::unknown::UnknownValuesIter;
+
+// generated
+pub mod descriptor;
+pub mod plugin;
+pub mod rustproto;
+
+pub mod wire_format;
+
+mod clear;
+mod coded_input_stream;
+mod coded_output_stream;
+pub mod compiler_plugin;
+mod enums;
+pub mod error;
+pub mod ext;
+pub mod json;
+pub mod lazy;
+mod lazy_v2;
+mod message;
+pub mod reflect;
+mod repeated;
+pub mod rt;
+mod singular;
+pub mod text_format;
+pub mod types;
+pub mod well_known_types;
+mod well_known_types_util;
+
+// used by test
+#[cfg(test)]
+#[path = "../../protobuf-test-common/src/hex.rs"]
+mod hex;
+
+// used by rust-grpc
+pub mod descriptorx;
+
+mod cached_size;
+mod chars;
+#[doc(hidden)] // used by codegen
+pub mod rust;
+mod strx;
+mod unknown;
+mod varint;
+mod zigzag;
+
+mod misc;
+
+mod buf_read_iter;
+mod buf_read_or_reader;
+
+/// 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!(concat!(env!("OUT_DIR"), "/version.rs"));
diff --git a/2.27.1/src/message.rs b/2.27.1/src/message.rs
new file mode 100644
index 0000000..e9d6b30
--- /dev/null
+++ b/2.27.1/src/message.rs
@@ -0,0 +1,312 @@
+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 crate::clear::Clear;
+use crate::coded_input_stream::CodedInputStream;
+use crate::coded_input_stream::WithCodedInputStream;
+use crate::coded_output_stream::with_coded_output_stream_to_bytes;
+use crate::coded_output_stream::CodedOutputStream;
+use crate::coded_output_stream::WithCodedOutputStream;
+use crate::error::ProtobufError;
+use crate::error::ProtobufResult;
+use crate::reflect::MessageDescriptor;
+use crate::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<()>;
+
+ /// Parse message from stream.
+ fn parse_from(is: &mut CodedInputStream) -> ProtobufResult<Self>
+ where
+ Self: Sized,
+ {
+ let mut r: Self = Message::new();
+ r.merge_from(is)?;
+ r.check_initialized()?;
+ Ok(r)
+ }
+
+ /// 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)
+ }
+
+ /// Parse message from reader.
+ /// Parse stops on EOF or when error encountered.
+ fn parse_from_reader(reader: &mut dyn Read) -> ProtobufResult<Self>
+ where
+ Self: Sized,
+ {
+ let mut is = CodedInputStream::new(reader);
+ let r = Message::parse_from(&mut is)?;
+ is.check_eof()?;
+ Ok(r)
+ }
+
+ /// Parse message from byte array.
+ fn parse_from_bytes(bytes: &[u8]) -> ProtobufResult<Self>
+ where
+ Self: Sized,
+ {
+ let mut is = CodedInputStream::from_bytes(bytes);
+ let r = Message::parse_from(&mut is)?;
+ is.check_eof()?;
+ Ok(r)
+ }
+
+ /// Parse message from `Bytes` object.
+ /// Resulting message may share references to the passed bytes object.
+ #[cfg(feature = "bytes")]
+ fn parse_from_carllerche_bytes(bytes: &Bytes) -> ProtobufResult<Self>
+ where
+ Self: Sized,
+ {
+ let mut is = CodedInputStream::from_carllerche_bytes(bytes);
+ let r = Self::parse_from(&mut is)?;
+ is.check_eof()?;
+ Ok(r)
+ }
+
+ /// 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 dyn 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 dyn 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) -> &dyn Any;
+
+ /// View self as mutable `Any`.
+ fn as_any_mut(&mut self) -> &mut dyn Any {
+ panic!()
+ }
+
+ /// Convert boxed self to boxed `Any`.
+ fn into_any(self: Box<Self>) -> Box<dyn 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 dyn Message) -> &'a M {
+ m.as_any().downcast_ref::<M>().unwrap()
+}
+
+/// Parse message from reader.
+/// Parse stops on EOF or when error encountered.
+#[deprecated(since = "2.19", note = "Use Message::parse_from_reader instead")]
+pub fn parse_from_reader<M: Message>(reader: &mut dyn Read) -> ProtobufResult<M> {
+ M::parse_from_reader(reader)
+}
+
+/// Parse message from byte array.
+#[deprecated(since = "2.19", note = "Use Message::parse_from_bytes instead")]
+pub fn parse_from_bytes<M: Message>(bytes: &[u8]) -> ProtobufResult<M> {
+ M::parse_from_bytes(bytes)
+}
+
+/// Parse message from `Bytes` object.
+/// Resulting message may share references to the passed bytes object.
+#[cfg(feature = "bytes")]
+#[deprecated(
+ since = "2.19",
+ note = "Use Message::parse_from_carllerche_bytes instead"
+)]
+pub fn parse_from_carllerche_bytes<M: Message>(bytes: &Bytes) -> ProtobufResult<M> {
+ M::parse_from_carllerche_bytes(bytes)
+}
+
+/// 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 dyn 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/2.27.1/src/misc.rs b/2.27.1/src/misc.rs
new file mode 100644
index 0000000..faef34f
--- /dev/null
+++ b/2.27.1/src/misc.rs
@@ -0,0 +1,52 @@
+use std::mem;
+use std::mem::MaybeUninit;
+use std::slice;
+
+/// `Vec::spare_capacity_mut` is not stable until Rust 1.60.
+pub(crate) fn vec_spare_capacity_mut<A>(vec: &mut Vec<A>) -> &mut [MaybeUninit<A>] {
+ // SAFETY: copy-paste from rust stdlib.
+ unsafe {
+ slice::from_raw_parts_mut(
+ vec.as_mut_ptr().add(vec.len()) as *mut MaybeUninit<A>,
+ vec.capacity() - vec.len(),
+ )
+ }
+}
+
+/// `MaybeUninit::write_slice` is not stable.
+pub(crate) fn maybe_uninit_write_slice<'a, T>(
+ this: &'a mut [MaybeUninit<T>],
+ src: &[T],
+) -> &'a mut [T]
+where
+ T: Copy,
+{
+ // SAFETY: copy-paste from rust stdlib.
+
+ let uninit_src: &[MaybeUninit<T>] = unsafe { mem::transmute(src) };
+
+ this.copy_from_slice(uninit_src);
+
+ unsafe { &mut *(this as *mut [MaybeUninit<T>] as *mut [T]) }
+}
+
+/// `MaybeUninit::array_assume_init` is not stable.
+#[inline]
+pub(crate) unsafe fn maybe_ununit_array_assume_init<T, const N: usize>(
+ array: [MaybeUninit<T>; N],
+) -> [T; N] {
+ // SAFETY:
+ // * The caller guarantees that all elements of the array are initialized
+ // * `MaybeUninit<T>` and T are guaranteed to have the same layout
+ // * `MaybeUninit` does not drop, so there are no double-frees
+ // And thus the conversion is safe
+ (&array as *const _ as *const [T; N]).read()
+}
+
+/// `MaybeUninit::write` is stable since 1.55.
+#[inline]
+pub(crate) fn maybe_uninit_write<T>(uninit: &mut MaybeUninit<T>, val: T) -> &mut T {
+ // SAFETY: copy-paste from rust stdlib.
+ *uninit = MaybeUninit::new(val);
+ unsafe { &mut *uninit.as_mut_ptr() }
+}
diff --git a/2.27.1/src/plugin.rs b/2.27.1/src/plugin.rs
new file mode 100644
index 0000000..93f2ca8
--- /dev/null
+++ b/2.27.1/src/plugin.rs
@@ -0,0 +1,1528 @@
+// This file is generated by rust-protobuf 2.26.0. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(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(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `google/protobuf/compiler/plugin.proto`
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct Version {
+ // message fields
+ major: ::std::option::Option<i32>,
+ minor: ::std::option::Option<i32>,
+ patch: ::std::option::Option<i32>,
+ suffix: crate::SingularField<::std::string::String>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Version {
+ fn default() -> &'a Version {
+ <Version as crate::Message>::default_instance()
+ }
+}
+
+impl Version {
+ pub fn new() -> Version {
+ ::std::default::Default::default()
+ }
+
+ // optional int32 major = 1;
+
+
+ pub fn get_major(&self) -> i32 {
+ self.major.unwrap_or(0)
+ }
+ pub fn clear_major(&mut self) {
+ self.major = ::std::option::Option::None;
+ }
+
+ pub fn has_major(&self) -> bool {
+ self.major.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_major(&mut self, v: i32) {
+ self.major = ::std::option::Option::Some(v);
+ }
+
+ // optional int32 minor = 2;
+
+
+ pub fn get_minor(&self) -> i32 {
+ self.minor.unwrap_or(0)
+ }
+ pub fn clear_minor(&mut self) {
+ self.minor = ::std::option::Option::None;
+ }
+
+ pub fn has_minor(&self) -> bool {
+ self.minor.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_minor(&mut self, v: i32) {
+ self.minor = ::std::option::Option::Some(v);
+ }
+
+ // optional int32 patch = 3;
+
+
+ pub fn get_patch(&self) -> i32 {
+ self.patch.unwrap_or(0)
+ }
+ pub fn clear_patch(&mut self) {
+ self.patch = ::std::option::Option::None;
+ }
+
+ pub fn has_patch(&self) -> bool {
+ self.patch.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_patch(&mut self, v: i32) {
+ self.patch = ::std::option::Option::Some(v);
+ }
+
+ // optional string suffix = 4;
+
+
+ pub fn get_suffix(&self) -> &str {
+ match self.suffix.as_ref() {
+ Some(v) => &v,
+ None => "",
+ }
+ }
+ pub fn clear_suffix(&mut self) {
+ self.suffix.clear();
+ }
+
+ pub fn has_suffix(&self) -> bool {
+ self.suffix.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_suffix(&mut self, v: ::std::string::String) {
+ self.suffix = crate::SingularField::some(v);
+ }
+
+ // Mutable pointer to the field.
+ // If field is not initialized, it is initialized with default value first.
+ pub fn mut_suffix(&mut self) -> &mut ::std::string::String {
+ if self.suffix.is_none() {
+ self.suffix.set_default();
+ }
+ self.suffix.as_mut().unwrap()
+ }
+
+ // Take field
+ pub fn take_suffix(&mut self) -> ::std::string::String {
+ self.suffix.take().unwrap_or_else(|| ::std::string::String::new())
+ }
+}
+
+impl crate::Message for Version {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.major = ::std::option::Option::Some(tmp);
+ },
+ 2 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.minor = ::std::option::Option::Some(tmp);
+ },
+ 3 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.patch = ::std::option::Option::Some(tmp);
+ },
+ 4 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.suffix)?;
+ },
+ _ => {
+ crate::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.major {
+ my_size += crate::rt::value_size(1, v, crate::wire_format::WireTypeVarint);
+ }
+ if let Some(v) = self.minor {
+ my_size += crate::rt::value_size(2, v, crate::wire_format::WireTypeVarint);
+ }
+ if let Some(v) = self.patch {
+ my_size += crate::rt::value_size(3, v, crate::wire_format::WireTypeVarint);
+ }
+ if let Some(ref v) = self.suffix.as_ref() {
+ my_size += crate::rt::string_size(4, &v);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if let Some(v) = self.major {
+ os.write_int32(1, v)?;
+ }
+ if let Some(v) = self.minor {
+ os.write_int32(2, v)?;
+ }
+ if let Some(v) = self.patch {
+ os.write_int32(3, v)?;
+ }
+ if let Some(ref v) = self.suffix.as_ref() {
+ os.write_string(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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Version {
+ Version::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "major",
+ |m: &Version| { &m.major },
+ |m: &mut Version| { &mut m.major },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "minor",
+ |m: &Version| { &m.minor },
+ |m: &mut Version| { &mut m.minor },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "patch",
+ |m: &Version| { &m.patch },
+ |m: &mut Version| { &mut m.patch },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "suffix",
+ |m: &Version| { &m.suffix },
+ |m: &mut Version| { &mut m.suffix },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Version>(
+ "Version",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Version {
+ static instance: crate::rt::LazyV2<Version> = crate::rt::LazyV2::INIT;
+ instance.get(Version::new)
+ }
+}
+
+impl crate::Clear for Version {
+ fn clear(&mut self) {
+ self.major = ::std::option::Option::None;
+ self.minor = ::std::option::Option::None;
+ self.patch = ::std::option::Option::None;
+ self.suffix.clear();
+ self.unknown_fields.clear();
+ }
+}
+
+impl ::std::fmt::Debug for Version {
+ fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Version {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct CodeGeneratorRequest {
+ // message fields
+ pub file_to_generate: crate::RepeatedField<::std::string::String>,
+ parameter: crate::SingularField<::std::string::String>,
+ pub proto_file: crate::RepeatedField<crate::descriptor::FileDescriptorProto>,
+ pub compiler_version: crate::SingularPtrField<Version>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a CodeGeneratorRequest {
+ fn default() -> &'a CodeGeneratorRequest {
+ <CodeGeneratorRequest as crate::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: crate::RepeatedField<::std::string::String>) {
+ self.file_to_generate = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_file_to_generate(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
+ &mut self.file_to_generate
+ }
+
+ // Take field
+ pub fn take_file_to_generate(&mut self) -> crate::RepeatedField<::std::string::String> {
+ ::std::mem::replace(&mut self.file_to_generate, crate::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 = crate::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) -> &[crate::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: crate::RepeatedField<crate::descriptor::FileDescriptorProto>) {
+ self.proto_file = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_proto_file(&mut self) -> &mut crate::RepeatedField<crate::descriptor::FileDescriptorProto> {
+ &mut self.proto_file
+ }
+
+ // Take field
+ pub fn take_proto_file(&mut self) -> crate::RepeatedField<crate::descriptor::FileDescriptorProto> {
+ ::std::mem::replace(&mut self.proto_file, crate::RepeatedField::new())
+ }
+
+ // optional .google.protobuf.compiler.Version compiler_version = 3;
+
+
+ pub fn get_compiler_version(&self) -> &Version {
+ self.compiler_version.as_ref().unwrap_or_else(|| <Version as crate::Message>::default_instance())
+ }
+ pub fn clear_compiler_version(&mut self) {
+ self.compiler_version.clear();
+ }
+
+ pub fn has_compiler_version(&self) -> bool {
+ self.compiler_version.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_compiler_version(&mut self, v: Version) {
+ self.compiler_version = crate::SingularPtrField::some(v);
+ }
+
+ // Mutable pointer to the field.
+ // If field is not initialized, it is initialized with default value first.
+ pub fn mut_compiler_version(&mut self) -> &mut Version {
+ if self.compiler_version.is_none() {
+ self.compiler_version.set_default();
+ }
+ self.compiler_version.as_mut().unwrap()
+ }
+
+ // Take field
+ pub fn take_compiler_version(&mut self) -> Version {
+ self.compiler_version.take().unwrap_or_else(|| Version::new())
+ }
+}
+
+impl crate::Message for CodeGeneratorRequest {
+ fn is_initialized(&self) -> bool {
+ for v in &self.proto_file {
+ if !v.is_initialized() {
+ return false;
+ }
+ };
+ for v in &self.compiler_version {
+ if !v.is_initialized() {
+ return false;
+ }
+ };
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_repeated_string_into(wire_type, is, &mut self.file_to_generate)?;
+ },
+ 2 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.parameter)?;
+ },
+ 15 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.proto_file)?;
+ },
+ 3 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.compiler_version)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &value);
+ };
+ if let Some(ref v) = self.parameter.as_ref() {
+ my_size += crate::rt::string_size(2, &v);
+ }
+ for value in &self.proto_file {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ if let Some(ref v) = self.compiler_version.as_ref() {
+ let len = v.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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, crate::wire_format::WireTypeLengthDelimited)?;
+ os.write_raw_varint32(v.get_cached_size())?;
+ v.write_to_with_cached_sizes(os)?;
+ };
+ if let Some(ref v) = self.compiler_version.as_ref() {
+ os.write_tag(3, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> CodeGeneratorRequest {
+ CodeGeneratorRequest::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "file_to_generate",
+ |m: &CodeGeneratorRequest| { &m.file_to_generate },
+ |m: &mut CodeGeneratorRequest| { &mut m.file_to_generate },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "parameter",
+ |m: &CodeGeneratorRequest| { &m.parameter },
+ |m: &mut CodeGeneratorRequest| { &mut m.parameter },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::descriptor::FileDescriptorProto>>(
+ "proto_file",
+ |m: &CodeGeneratorRequest| { &m.proto_file },
+ |m: &mut CodeGeneratorRequest| { &mut m.proto_file },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<Version>>(
+ "compiler_version",
+ |m: &CodeGeneratorRequest| { &m.compiler_version },
+ |m: &mut CodeGeneratorRequest| { &mut m.compiler_version },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorRequest>(
+ "CodeGeneratorRequest",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static CodeGeneratorRequest {
+ static instance: crate::rt::LazyV2<CodeGeneratorRequest> = crate::rt::LazyV2::INIT;
+ instance.get(CodeGeneratorRequest::new)
+ }
+}
+
+impl crate::Clear for CodeGeneratorRequest {
+ fn clear(&mut self) {
+ self.file_to_generate.clear();
+ self.parameter.clear();
+ self.proto_file.clear();
+ self.compiler_version.clear();
+ self.unknown_fields.clear();
+ }
+}
+
+impl ::std::fmt::Debug for CodeGeneratorRequest {
+ fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for CodeGeneratorRequest {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct CodeGeneratorResponse {
+ // message fields
+ error: crate::SingularField<::std::string::String>,
+ supported_features: ::std::option::Option<u64>,
+ pub file: crate::RepeatedField<CodeGeneratorResponse_File>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a CodeGeneratorResponse {
+ fn default() -> &'a CodeGeneratorResponse {
+ <CodeGeneratorResponse as crate::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 = crate::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())
+ }
+
+ // optional uint64 supported_features = 2;
+
+
+ pub fn get_supported_features(&self) -> u64 {
+ self.supported_features.unwrap_or(0)
+ }
+ pub fn clear_supported_features(&mut self) {
+ self.supported_features = ::std::option::Option::None;
+ }
+
+ pub fn has_supported_features(&self) -> bool {
+ self.supported_features.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_supported_features(&mut self, v: u64) {
+ self.supported_features = ::std::option::Option::Some(v);
+ }
+
+ // 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: crate::RepeatedField<CodeGeneratorResponse_File>) {
+ self.file = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_file(&mut self) -> &mut crate::RepeatedField<CodeGeneratorResponse_File> {
+ &mut self.file
+ }
+
+ // Take field
+ pub fn take_file(&mut self) -> crate::RepeatedField<CodeGeneratorResponse_File> {
+ ::std::mem::replace(&mut self.file, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.error)?;
+ },
+ 2 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_uint64()?;
+ self.supported_features = ::std::option::Option::Some(tmp);
+ },
+ 15 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.file)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &v);
+ }
+ if let Some(v) = self.supported_features {
+ my_size += crate::rt::value_size(2, v, crate::wire_format::WireTypeVarint);
+ }
+ for value in &self.file {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if let Some(ref v) = self.error.as_ref() {
+ os.write_string(1, &v)?;
+ }
+ if let Some(v) = self.supported_features {
+ os.write_uint64(2, v)?;
+ }
+ for v in &self.file {
+ os.write_tag(15, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> CodeGeneratorResponse {
+ CodeGeneratorResponse::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "error",
+ |m: &CodeGeneratorResponse| { &m.error },
+ |m: &mut CodeGeneratorResponse| { &mut m.error },
+ ));
+ fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeUint64>(
+ "supported_features",
+ |m: &CodeGeneratorResponse| { &m.supported_features },
+ |m: &mut CodeGeneratorResponse| { &mut m.supported_features },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<CodeGeneratorResponse_File>>(
+ "file",
+ |m: &CodeGeneratorResponse| { &m.file },
+ |m: &mut CodeGeneratorResponse| { &mut m.file },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorResponse>(
+ "CodeGeneratorResponse",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static CodeGeneratorResponse {
+ static instance: crate::rt::LazyV2<CodeGeneratorResponse> = crate::rt::LazyV2::INIT;
+ instance.get(CodeGeneratorResponse::new)
+ }
+}
+
+impl crate::Clear for CodeGeneratorResponse {
+ fn clear(&mut self) {
+ self.error.clear();
+ self.supported_features = ::std::option::Option::None;
+ self.file.clear();
+ self.unknown_fields.clear();
+ }
+}
+
+impl ::std::fmt::Debug for CodeGeneratorResponse {
+ fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for CodeGeneratorResponse {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct CodeGeneratorResponse_File {
+ // message fields
+ name: crate::SingularField<::std::string::String>,
+ insertion_point: crate::SingularField<::std::string::String>,
+ content: crate::SingularField<::std::string::String>,
+ pub generated_code_info: crate::SingularPtrField<crate::descriptor::GeneratedCodeInfo>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a CodeGeneratorResponse_File {
+ fn default() -> &'a CodeGeneratorResponse_File {
+ <CodeGeneratorResponse_File as crate::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 = crate::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 = crate::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 = crate::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())
+ }
+
+ // optional .google.protobuf.GeneratedCodeInfo generated_code_info = 16;
+
+
+ pub fn get_generated_code_info(&self) -> &crate::descriptor::GeneratedCodeInfo {
+ self.generated_code_info.as_ref().unwrap_or_else(|| <crate::descriptor::GeneratedCodeInfo as crate::Message>::default_instance())
+ }
+ pub fn clear_generated_code_info(&mut self) {
+ self.generated_code_info.clear();
+ }
+
+ pub fn has_generated_code_info(&self) -> bool {
+ self.generated_code_info.is_some()
+ }
+
+ // Param is passed by value, moved
+ pub fn set_generated_code_info(&mut self, v: crate::descriptor::GeneratedCodeInfo) {
+ self.generated_code_info = crate::SingularPtrField::some(v);
+ }
+
+ // Mutable pointer to the field.
+ // If field is not initialized, it is initialized with default value first.
+ pub fn mut_generated_code_info(&mut self) -> &mut crate::descriptor::GeneratedCodeInfo {
+ if self.generated_code_info.is_none() {
+ self.generated_code_info.set_default();
+ }
+ self.generated_code_info.as_mut().unwrap()
+ }
+
+ // Take field
+ pub fn take_generated_code_info(&mut self) -> crate::descriptor::GeneratedCodeInfo {
+ self.generated_code_info.take().unwrap_or_else(|| crate::descriptor::GeneratedCodeInfo::new())
+ }
+}
+
+impl crate::Message for CodeGeneratorResponse_File {
+ fn is_initialized(&self) -> bool {
+ for v in &self.generated_code_info {
+ if !v.is_initialized() {
+ return false;
+ }
+ };
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.insertion_point)?;
+ },
+ 15 => {
+ crate::rt::read_singular_string_into(wire_type, is, &mut self.content)?;
+ },
+ 16 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.generated_code_info)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &v);
+ }
+ if let Some(ref v) = self.insertion_point.as_ref() {
+ my_size += crate::rt::string_size(2, &v);
+ }
+ if let Some(ref v) = self.content.as_ref() {
+ my_size += crate::rt::string_size(15, &v);
+ }
+ if let Some(ref v) = self.generated_code_info.as_ref() {
+ let len = v.compute_size();
+ my_size += 2 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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)?;
+ }
+ if let Some(ref v) = self.generated_code_info.as_ref() {
+ os.write_tag(16, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> CodeGeneratorResponse_File {
+ CodeGeneratorResponse_File::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &CodeGeneratorResponse_File| { &m.name },
+ |m: &mut CodeGeneratorResponse_File| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "insertion_point",
+ |m: &CodeGeneratorResponse_File| { &m.insertion_point },
+ |m: &mut CodeGeneratorResponse_File| { &mut m.insertion_point },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "content",
+ |m: &CodeGeneratorResponse_File| { &m.content },
+ |m: &mut CodeGeneratorResponse_File| { &mut m.content },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::descriptor::GeneratedCodeInfo>>(
+ "generated_code_info",
+ |m: &CodeGeneratorResponse_File| { &m.generated_code_info },
+ |m: &mut CodeGeneratorResponse_File| { &mut m.generated_code_info },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorResponse_File>(
+ "CodeGeneratorResponse.File",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static CodeGeneratorResponse_File {
+ static instance: crate::rt::LazyV2<CodeGeneratorResponse_File> = crate::rt::LazyV2::INIT;
+ instance.get(CodeGeneratorResponse_File::new)
+ }
+}
+
+impl crate::Clear for CodeGeneratorResponse_File {
+ fn clear(&mut self) {
+ self.name.clear();
+ self.insertion_point.clear();
+ self.content.clear();
+ self.generated_code_info.clear();
+ self.unknown_fields.clear();
+ }
+}
+
+impl ::std::fmt::Debug for CodeGeneratorResponse_File {
+ fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for CodeGeneratorResponse_File {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub enum CodeGeneratorResponse_Feature {
+ FEATURE_NONE = 0,
+ FEATURE_PROTO3_OPTIONAL = 1,
+}
+
+impl crate::ProtobufEnum for CodeGeneratorResponse_Feature {
+ fn value(&self) -> i32 {
+ *self as i32
+ }
+
+ fn from_i32(value: i32) -> ::std::option::Option<CodeGeneratorResponse_Feature> {
+ match value {
+ 0 => ::std::option::Option::Some(CodeGeneratorResponse_Feature::FEATURE_NONE),
+ 1 => ::std::option::Option::Some(CodeGeneratorResponse_Feature::FEATURE_PROTO3_OPTIONAL),
+ _ => ::std::option::Option::None
+ }
+ }
+
+ fn values() -> &'static [Self] {
+ static values: &'static [CodeGeneratorResponse_Feature] = &[
+ CodeGeneratorResponse_Feature::FEATURE_NONE,
+ CodeGeneratorResponse_Feature::FEATURE_PROTO3_OPTIONAL,
+ ];
+ values
+ }
+
+ fn enum_descriptor_static() -> &'static crate::reflect::EnumDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ crate::reflect::EnumDescriptor::new_pb_name::<CodeGeneratorResponse_Feature>("CodeGeneratorResponse.Feature", file_descriptor_proto())
+ })
+ }
+}
+
+impl ::std::marker::Copy for CodeGeneratorResponse_Feature {
+}
+
+impl ::std::default::Default for CodeGeneratorResponse_Feature {
+ fn default() -> Self {
+ CodeGeneratorResponse_Feature::FEATURE_NONE
+ }
+}
+
+impl crate::reflect::ProtobufValue for CodeGeneratorResponse_Feature {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
+ }
+}
+
+static file_descriptor_proto_data: &'static [u8] = b"\
+ \n%google/protobuf/compiler/plugin.proto\x12\x18google.protobuf.compiler\
+ \x1a\x20google/protobuf/descriptor.proto\"c\n\x07Version\x12\x14\n\x05ma\
+ jor\x18\x01\x20\x01(\x05R\x05major\x12\x14\n\x05minor\x18\x02\x20\x01(\
+ \x05R\x05minor\x12\x14\n\x05patch\x18\x03\x20\x01(\x05R\x05patch\x12\x16\
+ \n\x06suffix\x18\x04\x20\x01(\tR\x06suffix\"\xf1\x01\n\x14CodeGeneratorR\
+ equest\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\
+ \x12L\n\x10compiler_version\x18\x03\x20\x01(\x0b2!.google.protobuf.compi\
+ ler.VersionR\x0fcompilerVersion\"\x94\x03\n\x15CodeGeneratorResponse\x12\
+ \x14\n\x05error\x18\x01\x20\x01(\tR\x05error\x12-\n\x12supported_feature\
+ s\x18\x02\x20\x01(\x04R\x11supportedFeatures\x12H\n\x04file\x18\x0f\x20\
+ \x03(\x0b24.google.protobuf.compiler.CodeGeneratorResponse.FileR\x04file\
+ \x1a\xb1\x01\n\x04File\x12\x12\n\x04name\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\x07content\x12R\n\x13generated_code_info\
+ \x18\x10\x20\x01(\x0b2\".google.protobuf.GeneratedCodeInfoR\x11generated\
+ CodeInfo\"8\n\x07Feature\x12\x10\n\x0cFEATURE_NONE\x10\0\x12\x1b\n\x17FE\
+ ATURE_PROTO3_OPTIONAL\x10\x01BW\n\x1ccom.google.protobuf.compilerB\x0cPl\
+ uginProtosZ)google.golang.org/protobuf/types/pluginpbJ\xf9C\n\x07\x12\
+ \x05.\0\xb6\x01\x01\n\xca\x11\n\x01\x0c\x12\x03.\0\x122\xc1\x0c\x20Proto\
+ col\x20Buffers\x20-\x20Google's\x20data\x20interchange\x20format\n\x20Co\
+ pyright\x202008\x20Google\x20Inc.\x20\x20All\x20rights\x20reserved.\n\
+ \x20https://developers.google.com/protocol-buffers/\n\n\x20Redistributio\
+ n\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.\n2\xfb\
+ \x04\x20Author:\x20kenton@google.com\x20(Kenton\x20Varda)\n\n\x20WARNING\
+ :\x20\x20The\x20plugin\x20interface\x20is\x20currently\x20EXPERIMENTAL\
+ \x20and\x20is\x20subject\x20to\n\x20\x20\x20change.\n\n\x20protoc\x20(ak\
+ a\x20the\x20Protocol\x20Compiler)\x20can\x20be\x20extended\x20via\x20plu\
+ gins.\x20\x20A\x20plugin\x20is\n\x20just\x20a\x20program\x20that\x20read\
+ s\x20a\x20CodeGeneratorRequest\x20from\x20stdin\x20and\x20writes\x20a\n\
+ \x20CodeGeneratorResponse\x20to\x20stdout.\n\n\x20Plugins\x20written\x20\
+ using\x20C++\x20can\x20use\x20google/protobuf/compiler/plugin.h\x20inste\
+ ad\n\x20of\x20dealing\x20with\x20the\x20raw\x20protocol\x20defined\x20he\
+ re.\n\n\x20A\x20plugin\x20executable\x20needs\x20only\x20to\x20be\x20pla\
+ ced\x20somewhere\x20in\x20the\x20path.\x20\x20The\n\x20plugin\x20should\
+ \x20be\x20named\x20\"protoc-gen-$NAME\",\x20and\x20will\x20then\x20be\
+ \x20used\x20when\x20the\n\x20flag\x20\"--${NAME}_out\"\x20is\x20passed\
+ \x20to\x20protoc.\n\n\x08\n\x01\x02\x12\x030\0!\n\x08\n\x01\x08\x12\x031\
+ \05\n\t\n\x02\x08\x01\x12\x031\05\n\x08\n\x01\x08\x12\x032\0-\n\t\n\x02\
+ \x08\x08\x12\x032\0-\n\x08\n\x01\x08\x12\x034\0@\n\t\n\x02\x08\x0b\x12\
+ \x034\0@\n\t\n\x02\x03\0\x12\x036\0*\n6\n\x02\x04\0\x12\x049\0@\x01\x1a*\
+ \x20The\x20version\x20number\x20of\x20protocol\x20compiler.\n\n\n\n\x03\
+ \x04\0\x01\x12\x039\x08\x0f\n\x0b\n\x04\x04\0\x02\0\x12\x03:\x02\x1b\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\x10\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03:\x11\x16\n\x0c\n\
+ \x05\x04\0\x02\0\x03\x12\x03:\x19\x1a\n\x0b\n\x04\x04\0\x02\x01\x12\x03;\
+ \x02\x1b\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\x10\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03;\x11\
+ \x16\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03;\x19\x1a\n\x0b\n\x04\x04\0\
+ \x02\x02\x12\x03<\x02\x1b\n\x0c\n\x05\x04\0\x02\x02\x04\x12\x03<\x02\n\n\
+ \x0c\n\x05\x04\0\x02\x02\x05\x12\x03<\x0b\x10\n\x0c\n\x05\x04\0\x02\x02\
+ \x01\x12\x03<\x11\x16\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03<\x19\x1a\n\
+ \x80\x01\n\x04\x04\0\x02\x03\x12\x03?\x02\x1d\x1as\x20A\x20suffix\x20for\
+ \x20alpha,\x20beta\x20or\x20rc\x20release,\x20e.g.,\x20\"alpha-1\",\x20\
+ \"rc2\".\x20It\x20should\n\x20be\x20empty\x20for\x20mainline\x20stable\
+ \x20releases.\n\n\x0c\n\x05\x04\0\x02\x03\x04\x12\x03?\x02\n\n\x0c\n\x05\
+ \x04\0\x02\x03\x05\x12\x03?\x0b\x11\n\x0c\n\x05\x04\0\x02\x03\x01\x12\
+ \x03?\x12\x18\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03?\x1b\x1c\nO\n\x02\
+ \x04\x01\x12\x04C\0_\x01\x1aC\x20An\x20encoded\x20CodeGeneratorRequest\
+ \x20is\x20written\x20to\x20the\x20plugin's\x20stdin.\n\n\n\n\x03\x04\x01\
+ \x01\x12\x03C\x08\x1c\n\xd1\x01\n\x04\x04\x01\x02\0\x12\x03G\x02'\x1a\
+ \xc3\x01\x20The\x20.proto\x20files\x20that\x20were\x20explicitly\x20list\
+ ed\x20on\x20the\x20command-line.\x20\x20The\n\x20code\x20generator\x20sh\
+ ould\x20generate\x20code\x20only\x20for\x20these\x20files.\x20\x20Each\
+ \x20file's\n\x20descriptor\x20will\x20be\x20included\x20in\x20proto_file\
+ ,\x20below.\n\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03G\x02\n\n\x0c\n\x05\
+ \x04\x01\x02\0\x05\x12\x03G\x0b\x11\n\x0c\n\x05\x04\x01\x02\0\x01\x12\
+ \x03G\x12\"\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03G%&\nB\n\x04\x04\x01\
+ \x02\x01\x12\x03J\x02\x20\x1a5\x20The\x20generator\x20parameter\x20passe\
+ d\x20on\x20the\x20command-line.\n\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\
+ \x03J\x02\n\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03J\x0b\x11\n\x0c\n\x05\
+ \x04\x01\x02\x01\x01\x12\x03J\x12\x1b\n\x0c\n\x05\x04\x01\x02\x01\x03\
+ \x12\x03J\x1e\x1f\n\x87\x06\n\x04\x04\x01\x02\x02\x12\x03Z\x02/\x1a\xf9\
+ \x05\x20FileDescriptorProtos\x20for\x20all\x20files\x20in\x20files_to_ge\
+ nerate\x20and\x20everything\n\x20they\x20import.\x20\x20The\x20files\x20\
+ will\x20appear\x20in\x20topological\x20order,\x20so\x20each\x20file\n\
+ \x20appears\x20before\x20any\x20file\x20that\x20imports\x20it.\n\n\x20pr\
+ otoc\x20guarantees\x20that\x20all\x20proto_files\x20will\x20be\x20writte\
+ n\x20after\n\x20the\x20fields\x20above,\x20even\x20though\x20this\x20is\
+ \x20not\x20technically\x20guaranteed\x20by\x20the\n\x20protobuf\x20wire\
+ \x20format.\x20\x20This\x20theoretically\x20could\x20allow\x20a\x20plugi\
+ n\x20to\x20stream\n\x20in\x20the\x20FileDescriptorProtos\x20and\x20handl\
+ e\x20them\x20one\x20by\x20one\x20rather\x20than\x20read\n\x20the\x20enti\
+ re\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\x20t\
+ he\x20plugin.\n\n\x20Type\x20names\x20of\x20fields\x20and\x20extensions\
+ \x20in\x20the\x20FileDescriptorProto\x20are\x20always\n\x20fully\x20qual\
+ ified.\n\n\x0c\n\x05\x04\x01\x02\x02\x04\x12\x03Z\x02\n\n\x0c\n\x05\x04\
+ \x01\x02\x02\x06\x12\x03Z\x0b\x1e\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\
+ \x03Z\x1f)\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03Z,.\n7\n\x04\x04\x01\
+ \x02\x03\x12\x03]\x02(\x1a*\x20The\x20version\x20number\x20of\x20protoco\
+ l\x20compiler.\n\n\x0c\n\x05\x04\x01\x02\x03\x04\x12\x03]\x02\n\n\x0c\n\
+ \x05\x04\x01\x02\x03\x06\x12\x03]\x0b\x12\n\x0c\n\x05\x04\x01\x02\x03\
+ \x01\x12\x03]\x13#\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03]&'\nL\n\x02\
+ \x04\x02\x12\x05b\0\xb6\x01\x01\x1a?\x20The\x20plugin\x20writes\x20an\
+ \x20encoded\x20CodeGeneratorResponse\x20to\x20stdout.\n\n\n\n\x03\x04\
+ \x02\x01\x12\x03b\x08\x1d\n\xed\x03\n\x04\x04\x02\x02\0\x12\x03k\x02\x1c\
+ \x1a\xdf\x03\x20Error\x20message.\x20\x20If\x20non-empty,\x20code\x20gen\
+ eration\x20failed.\x20\x20The\x20plugin\x20process\n\x20should\x20exit\
+ \x20with\x20status\x20code\x20zero\x20even\x20if\x20it\x20reports\x20an\
+ \x20error\x20in\x20this\x20way.\n\n\x20This\x20should\x20be\x20used\x20t\
+ o\x20indicate\x20errors\x20in\x20.proto\x20files\x20which\x20prevent\x20\
+ the\n\x20code\x20generator\x20from\x20generating\x20correct\x20code.\x20\
+ \x20Errors\x20which\x20indicate\x20a\n\x20problem\x20in\x20protoc\x20its\
+ elf\x20--\x20such\x20as\x20the\x20input\x20CodeGeneratorRequest\x20being\
+ \n\x20unparseable\x20--\x20should\x20be\x20reported\x20by\x20writing\x20\
+ a\x20message\x20to\x20stderr\x20and\n\x20exiting\x20with\x20a\x20non-zer\
+ o\x20status\x20code.\n\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03k\x02\n\n\
+ \x0c\n\x05\x04\x02\x02\0\x05\x12\x03k\x0b\x11\n\x0c\n\x05\x04\x02\x02\0\
+ \x01\x12\x03k\x12\x17\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03k\x1a\x1b\n\
+ \x89\x01\n\x04\x04\x02\x02\x01\x12\x03o\x02)\x1a|\x20A\x20bitmask\x20of\
+ \x20supported\x20features\x20that\x20the\x20code\x20generator\x20support\
+ s.\n\x20This\x20is\x20a\x20bitwise\x20\"or\"\x20of\x20values\x20from\x20\
+ the\x20Feature\x20enum.\n\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\x03o\x02\n\
+ \n\x0c\n\x05\x04\x02\x02\x01\x05\x12\x03o\x0b\x11\n\x0c\n\x05\x04\x02\
+ \x02\x01\x01\x12\x03o\x12$\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03o'(\n+\
+ \n\x04\x04\x02\x04\0\x12\x04r\x02u\x03\x1a\x1d\x20Sync\x20with\x20code_g\
+ enerator.h.\n\n\x0c\n\x05\x04\x02\x04\0\x01\x12\x03r\x07\x0e\n\r\n\x06\
+ \x04\x02\x04\0\x02\0\x12\x03s\x04\x15\n\x0e\n\x07\x04\x02\x04\0\x02\0\
+ \x01\x12\x03s\x04\x10\n\x0e\n\x07\x04\x02\x04\0\x02\0\x02\x12\x03s\x13\
+ \x14\n\r\n\x06\x04\x02\x04\0\x02\x01\x12\x03t\x04\x20\n\x0e\n\x07\x04\
+ \x02\x04\0\x02\x01\x01\x12\x03t\x04\x1b\n\x0e\n\x07\x04\x02\x04\0\x02\
+ \x01\x02\x12\x03t\x1e\x1f\n4\n\x04\x04\x02\x03\0\x12\x05x\x02\xb4\x01\
+ \x03\x1a%\x20Represents\x20a\x20single\x20generated\x20file.\n\n\x0c\n\
+ \x05\x04\x02\x03\0\x01\x12\x03x\n\x0e\n\xae\x05\n\x06\x04\x02\x03\0\x02\
+ \0\x12\x04\x84\x01\x04\x1d\x1a\x9d\x05\x20The\x20file\x20name,\x20relati\
+ ve\x20to\x20the\x20output\x20directory.\x20\x20The\x20name\x20must\x20no\
+ t\n\x20contain\x20\".\"\x20or\x20\"..\"\x20components\x20and\x20must\x20\
+ be\x20relative,\x20not\x20be\x20absolute\x20(so,\n\x20the\x20file\x20can\
+ not\x20lie\x20outside\x20the\x20output\x20directory).\x20\x20\"/\"\x20mu\
+ st\x20be\x20used\x20as\n\x20the\x20path\x20separator,\x20not\x20\"\\\".\
+ \n\n\x20If\x20the\x20name\x20is\x20omitted,\x20the\x20content\x20will\
+ \x20be\x20appended\x20to\x20the\x20previous\n\x20file.\x20\x20This\x20al\
+ lows\x20the\x20generator\x20to\x20break\x20large\x20files\x20into\x20sma\
+ ll\x20chunks,\n\x20and\x20allows\x20the\x20generated\x20text\x20to\x20be\
+ \x20streamed\x20back\x20to\x20protoc\x20so\x20that\x20large\n\x20files\
+ \x20need\x20not\x20reside\x20completely\x20in\x20memory\x20at\x20one\x20\
+ time.\x20\x20Note\x20that\x20as\x20of\n\x20this\x20writing\x20protoc\x20\
+ does\x20not\x20optimize\x20for\x20this\x20--\x20it\x20will\x20read\x20th\
+ e\x20entire\n\x20CodeGeneratorResponse\x20before\x20writing\x20files\x20\
+ to\x20disk.\n\n\x0f\n\x07\x04\x02\x03\0\x02\0\x04\x12\x04\x84\x01\x04\
+ \x0c\n\x0f\n\x07\x04\x02\x03\0\x02\0\x05\x12\x04\x84\x01\r\x13\n\x0f\n\
+ \x07\x04\x02\x03\0\x02\0\x01\x12\x04\x84\x01\x14\x18\n\x0f\n\x07\x04\x02\
+ \x03\0\x02\0\x03\x12\x04\x84\x01\x1b\x1c\n\xae\x10\n\x06\x04\x02\x03\0\
+ \x02\x01\x12\x04\xab\x01\x04(\x1a\x9d\x10\x20If\x20non-empty,\x20indicat\
+ es\x20that\x20the\x20named\x20file\x20should\x20already\x20exist,\x20and\
+ \x20the\n\x20content\x20here\x20is\x20to\x20be\x20inserted\x20into\x20th\
+ at\x20file\x20at\x20a\x20defined\x20insertion\n\x20point.\x20\x20This\
+ \x20feature\x20allows\x20a\x20code\x20generator\x20to\x20extend\x20the\
+ \x20output\n\x20produced\x20by\x20another\x20code\x20generator.\x20\x20T\
+ he\x20original\x20generator\x20may\x20provide\n\x20insertion\x20points\
+ \x20by\x20placing\x20special\x20annotations\x20in\x20the\x20file\x20that\
+ \x20look\n\x20like:\n\x20\x20\x20@@protoc_insertion_point(NAME)\n\x20The\
+ \x20annotation\x20can\x20have\x20arbitrary\x20text\x20before\x20and\x20a\
+ fter\x20it\x20on\x20the\x20line,\n\x20which\x20allows\x20it\x20to\x20be\
+ \x20placed\x20in\x20a\x20comment.\x20\x20NAME\x20should\x20be\x20replace\
+ d\x20with\n\x20an\x20identifier\x20naming\x20the\x20point\x20--\x20this\
+ \x20is\x20what\x20other\x20generators\x20will\x20use\n\x20as\x20the\x20i\
+ nsertion_point.\x20\x20Code\x20inserted\x20at\x20this\x20point\x20will\
+ \x20be\x20placed\n\x20immediately\x20above\x20the\x20line\x20containing\
+ \x20the\x20insertion\x20point\x20(thus\x20multiple\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\x20generated\x20code\n\x20coul\
+ d\x20contain\x20things\x20that\x20look\x20like\x20insertion\x20points\
+ \x20by\x20accident.\n\n\x20For\x20example,\x20the\x20C++\x20code\x20gene\
+ rator\x20places\x20the\x20following\x20line\x20in\x20the\n\x20.pb.h\x20f\
+ iles\x20that\x20it\x20generates:\n\x20\x20\x20//\x20@@protoc_insertion_p\
+ oint(namespace_scope)\n\x20This\x20line\x20appears\x20within\x20the\x20s\
+ cope\x20of\x20the\x20file's\x20package\x20namespace,\x20but\n\x20outside\
+ \x20of\x20any\x20particular\x20class.\x20\x20Another\x20plugin\x20can\
+ \x20then\x20specify\x20the\n\x20insertion_point\x20\"namespace_scope\"\
+ \x20to\x20generate\x20additional\x20classes\x20or\n\x20other\x20declarat\
+ ions\x20that\x20should\x20be\x20placed\x20in\x20this\x20scope.\n\n\x20No\
+ te\x20that\x20if\x20the\x20line\x20containing\x20the\x20insertion\x20poi\
+ nt\x20begins\x20with\n\x20whitespace,\x20the\x20same\x20whitespace\x20wi\
+ ll\x20be\x20added\x20to\x20every\x20line\x20of\x20the\n\x20inserted\x20t\
+ ext.\x20\x20This\x20is\x20useful\x20for\x20languages\x20like\x20Python,\
+ \x20where\n\x20indentation\x20matters.\x20\x20In\x20these\x20languages,\
+ \x20the\x20insertion\x20point\x20comment\n\x20should\x20be\x20indented\
+ \x20the\x20same\x20amount\x20as\x20any\x20inserted\x20code\x20will\x20ne\
+ ed\x20to\x20be\n\x20in\x20order\x20to\x20work\x20correctly\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\x20a\x20single\x20invo\
+ cation\x20of\x20protoc.\n\x20Code\x20generators\x20are\x20executed\x20in\
+ \x20the\x20order\x20in\x20which\x20they\x20appear\x20on\x20the\n\x20comm\
+ and\x20line.\n\n\x20If\x20|insertion_point|\x20is\x20present,\x20|name|\
+ \x20must\x20also\x20be\x20present.\n\n\x0f\n\x07\x04\x02\x03\0\x02\x01\
+ \x04\x12\x04\xab\x01\x04\x0c\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x05\x12\
+ \x04\xab\x01\r\x13\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x01\x12\x04\xab\x01\
+ \x14#\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x03\x12\x04\xab\x01&'\n$\n\x06\
+ \x04\x02\x03\0\x02\x02\x12\x04\xae\x01\x04!\x1a\x14\x20The\x20file\x20co\
+ ntents.\n\n\x0f\n\x07\x04\x02\x03\0\x02\x02\x04\x12\x04\xae\x01\x04\x0c\
+ \n\x0f\n\x07\x04\x02\x03\0\x02\x02\x05\x12\x04\xae\x01\r\x13\n\x0f\n\x07\
+ \x04\x02\x03\0\x02\x02\x01\x12\x04\xae\x01\x14\x1b\n\x0f\n\x07\x04\x02\
+ \x03\0\x02\x02\x03\x12\x04\xae\x01\x1e\x20\n\xe1\x01\n\x06\x04\x02\x03\0\
+ \x02\x03\x12\x04\xb3\x01\x048\x1a\xd0\x01\x20Information\x20describing\
+ \x20the\x20file\x20content\x20being\x20inserted.\x20If\x20an\x20insertio\
+ n\n\x20point\x20is\x20used,\x20this\x20information\x20will\x20be\x20appr\
+ opriately\x20offset\x20and\x20inserted\n\x20into\x20the\x20code\x20gener\
+ ation\x20metadata\x20for\x20the\x20generated\x20files.\n\n\x0f\n\x07\x04\
+ \x02\x03\0\x02\x03\x04\x12\x04\xb3\x01\x04\x0c\n\x0f\n\x07\x04\x02\x03\0\
+ \x02\x03\x06\x12\x04\xb3\x01\r\x1e\n\x0f\n\x07\x04\x02\x03\0\x02\x03\x01\
+ \x12\x04\xb3\x01\x1f2\n\x0f\n\x07\x04\x02\x03\0\x02\x03\x03\x12\x04\xb3\
+ \x0157\n\x0c\n\x04\x04\x02\x02\x02\x12\x04\xb5\x01\x02\x1a\n\r\n\x05\x04\
+ \x02\x02\x02\x04\x12\x04\xb5\x01\x02\n\n\r\n\x05\x04\x02\x02\x02\x06\x12\
+ \x04\xb5\x01\x0b\x0f\n\r\n\x05\x04\x02\x02\x02\x01\x12\x04\xb5\x01\x10\
+ \x14\n\r\n\x05\x04\x02\x02\x02\x03\x12\x04\xb5\x01\x17\x19\
+";
+
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+ crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
+ file_descriptor_proto_lazy.get(|| {
+ parse_descriptor_proto()
+ })
+}
diff --git a/2.27.1/src/reflect/acc/mod.rs b/2.27.1/src/reflect/acc/mod.rs
new file mode 100644
index 0000000..288c183
--- /dev/null
+++ b/2.27.1/src/reflect/acc/mod.rs
@@ -0,0 +1,31 @@
+#![doc(hidden)]
+
+use crate::reflect::acc::v1::FieldAccessorFunctions;
+use crate::reflect::acc::v1::FieldAccessorImpl;
+use crate::reflect::acc::v1::FieldAccessorTrait;
+use crate::Message;
+
+pub(crate) mod v1;
+
+pub(crate) enum Accessor {
+ V1(Box<dyn FieldAccessorTrait + 'static>),
+}
+
+/// Accessor object is constructed in generated code.
+/// Should not be used directly.
+pub struct FieldAccessor {
+ pub(crate) name: &'static str,
+ pub(crate) accessor: Accessor,
+}
+
+impl FieldAccessor {
+ pub(crate) fn new_v1<M: Message>(
+ name: &'static str,
+ fns: FieldAccessorFunctions<M>,
+ ) -> FieldAccessor {
+ FieldAccessor {
+ name,
+ accessor: Accessor::V1(Box::new(FieldAccessorImpl { fns })),
+ }
+ }
+}
diff --git a/2.27.1/src/reflect/acc/v1.rs b/2.27.1/src/reflect/acc/v1.rs
new file mode 100644
index 0000000..4c55f8f
--- /dev/null
+++ b/2.27.1/src/reflect/acc/v1.rs
@@ -0,0 +1,792 @@
+#![doc(hidden)]
+
+//! Version 1 reflection accessors.
+
+use std::collections::HashMap;
+use std::fmt;
+use std::hash::Hash;
+
+use crate::enums::ProtobufEnum;
+use crate::message::message_down_cast;
+use crate::message::Message;
+use crate::reflect::map::ReflectMap;
+use crate::reflect::optional::ReflectOptional;
+use crate::reflect::repeated::ReflectRepeated;
+use crate::reflect::repeated::ReflectRepeatedEnum;
+use crate::reflect::repeated::ReflectRepeatedMessage;
+use crate::reflect::rt::FieldAccessor;
+use crate::reflect::EnumValueDescriptor;
+use crate::reflect::ProtobufValue;
+use crate::reflect::ReflectFieldRef;
+use crate::reflect::ReflectValueRef;
+use crate::repeated::RepeatedField;
+use crate::singular::SingularField;
+use crate::singular::SingularPtrField;
+use crate::types::*;
+
+/// this trait should not be used directly, use `FieldDescriptor` instead
+pub trait FieldAccessorTrait: Sync + 'static {
+ fn has_field_generic(&self, m: &dyn Message) -> bool;
+ fn len_field_generic(&self, m: &dyn Message) -> usize;
+ // TODO: should it return default value or panic on unset field?
+ fn get_message_generic<'a>(&self, m: &'a dyn Message) -> &'a dyn Message;
+ fn get_enum_generic(&self, m: &dyn Message) -> &'static EnumValueDescriptor;
+ fn get_str_generic<'a>(&self, m: &'a dyn Message) -> &'a str;
+ fn get_bytes_generic<'a>(&self, m: &'a dyn Message) -> &'a [u8];
+ fn get_u32_generic(&self, m: &dyn Message) -> u32;
+ fn get_u64_generic(&self, m: &dyn Message) -> u64;
+ fn get_i32_generic(&self, m: &dyn Message) -> i32;
+ fn get_i64_generic(&self, m: &dyn Message) -> i64;
+ fn get_bool_generic(&self, m: &dyn Message) -> bool;
+ fn get_f32_generic(&self, m: &dyn Message) -> f32;
+ fn get_f64_generic(&self, m: &dyn Message) -> f64;
+
+ fn get_reflect<'a>(&self, m: &'a dyn Message) -> ReflectFieldRef<'a>;
+}
+
+pub(crate) trait GetSingularMessage<M>: Sync {
+ fn get_message<'a>(&self, m: &'a M) -> &'a dyn 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 dyn Message {
+ (self.get)(m)
+ }
+}
+
+pub(crate) trait GetSingularEnum<M>: Sync {
+ 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>: Sync {
+ fn len_field(&self, m: &M) -> usize;
+ fn get_message_item<'a>(&self, m: &'a M, index: usize) -> &'a dyn Message;
+ fn reflect_repeated_message<'a>(&self, m: &'a M) -> Box<dyn ReflectRepeatedMessage<'a> + 'a>;
+}
+
+trait GetRepeatedEnum<M: Message + 'static>: Sync {
+ 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<dyn ReflectRepeatedEnum<'a> + 'a>;
+}
+
+pub(crate) trait GetSetCopyFns<M>: Sync {
+ 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 &dyn ProtobufValue).as_ref_copy()
+ }
+}
+
+pub(crate) enum SingularGetSet<M> {
+ Copy(Box<dyn 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<dyn GetSingularEnum<M> + 'static>),
+ Message(Box<dyn 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)),
+ }
+ }
+}
+
+pub(crate) trait FieldAccessor2<M, R: ?Sized>: Sync
+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,
+}
+
+pub(crate) 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<dyn FieldAccessor2<M, dyn ProtobufValue>>),
+ // optional, required or message
+ Optional(Box<dyn FieldAccessor2<M, dyn ReflectOptional>>),
+ // repeated
+ Repeated(Box<dyn FieldAccessor2<M, dyn ReflectRepeated>>),
+ // protobuf 3 map
+ Map(Box<dyn FieldAccessor2<M, dyn 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(..)"),
+ }
+ }
+}
+
+pub(crate) struct FieldAccessorImpl<M> {
+ pub(crate) 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> FieldAccessorTrait for FieldAccessorImpl<M> {
+ fn has_field_generic(&self, m: &dyn 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: &dyn 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 dyn Message) -> &'a dyn 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: &dyn Message) -> &'static EnumValueDescriptor {
+ match self.fns {
+ FieldAccessorFunctions::SingularHasGetSet {
+ get_set: SingularGetSet::Enum(ref get),
+ ..
+ } => get.get_enum(message_down_cast(m)),
+ FieldAccessorFunctions::Optional(ref t) => {
+ match t
+ .get_field(message_down_cast(m))
+ .to_option()
+ .expect("field unset")
+ .as_ref()
+ {
+ ReflectValueRef::Enum(e) => e,
+ _ => panic!("not an enum"),
+ }
+ }
+ FieldAccessorFunctions::Simple(ref t) => {
+ match t.get_field(message_down_cast(m)).as_ref() {
+ ReflectValueRef::Enum(e) => e,
+ _ => panic!("not an enum"),
+ }
+ }
+ ref fns => panic!("unknown accessor type: {:?}", fns),
+ }
+ }
+
+ fn get_str_generic<'a>(&self, m: &'a dyn 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 dyn 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: &dyn 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: &dyn 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: &dyn 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: &dyn 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_bool_generic(&self, m: &dyn 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_f32_generic(&self, m: &dyn 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: &dyn 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_reflect<'a>(&self, m: &'a dyn 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,
+) -> FieldAccessor {
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::SingularHasGetSet {
+ has,
+ get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
+ get,
+ _set: set_panic,
+ })),
+ },
+ )
+}
+
+pub fn make_singular_i32_accessor<M: Message + 'static>(
+ name: &'static str,
+ has: fn(&M) -> bool,
+ get: fn(&M) -> i32,
+) -> FieldAccessor {
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::SingularHasGetSet {
+ has,
+ get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
+ get,
+ _set: set_panic,
+ })),
+ },
+ )
+}
+
+pub fn make_singular_u64_accessor<M: Message + 'static>(
+ name: &'static str,
+ has: fn(&M) -> bool,
+ get: fn(&M) -> u64,
+) -> FieldAccessor {
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::SingularHasGetSet {
+ has,
+ get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
+ get,
+ _set: set_panic,
+ })),
+ },
+ )
+}
+
+pub fn make_singular_i64_accessor<M: Message + 'static>(
+ name: &'static str,
+ has: fn(&M) -> bool,
+ get: fn(&M) -> i64,
+) -> FieldAccessor {
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::SingularHasGetSet {
+ has,
+ get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
+ get,
+ _set: set_panic,
+ })),
+ },
+ )
+}
+
+pub fn make_singular_f32_accessor<M: Message + 'static>(
+ name: &'static str,
+ has: fn(&M) -> bool,
+ get: fn(&M) -> f32,
+) -> FieldAccessor {
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::SingularHasGetSet {
+ has,
+ get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
+ get,
+ _set: set_panic,
+ })),
+ },
+ )
+}
+
+pub fn make_singular_f64_accessor<M: Message + 'static>(
+ name: &'static str,
+ has: fn(&M) -> bool,
+ get: fn(&M) -> f64,
+) -> FieldAccessor {
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::SingularHasGetSet {
+ has,
+ get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
+ get,
+ _set: set_panic,
+ })),
+ },
+ )
+}
+
+pub fn make_singular_bool_accessor<M: Message + 'static>(
+ name: &'static str,
+ has: fn(&M) -> bool,
+ get: fn(&M) -> bool,
+) -> FieldAccessor {
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::SingularHasGetSet {
+ has,
+ get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
+ 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,
+) -> FieldAccessor {
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::SingularHasGetSet {
+ has,
+ get_set: SingularGetSet::Enum(Box::new(GetSingularEnumImpl { 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,
+) -> FieldAccessor {
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::SingularHasGetSet {
+ 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],
+) -> FieldAccessor {
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::SingularHasGetSet {
+ 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,
+) -> FieldAccessor {
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::SingularHasGetSet {
+ has,
+ get_set: SingularGetSet::Message(Box::new(GetSingularMessageImpl { get })),
+ },
+ )
+}
+
+// repeated
+
+impl<M, V> FieldAccessor2<M, dyn ReflectRepeated> for MessageGetMut<M, Vec<V>>
+where
+ M: Message + 'static,
+ V: ProtobufValue + 'static,
+{
+ fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectRepeated {
+ (self.get_field)(m) as &dyn ReflectRepeated
+ }
+
+ fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectRepeated {
+ (self.mut_field)(m) as &mut dyn 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>,
+) -> FieldAccessor
+where
+ M: Message + 'static,
+ V: ProtobufType + 'static,
+{
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::Repeated(Box::new(MessageGetMut::<M, Vec<V::Value>> {
+ get_field: get_vec,
+ mut_field: mut_vec,
+ })),
+ )
+}
+
+impl<M, V> FieldAccessor2<M, dyn ReflectRepeated> for MessageGetMut<M, RepeatedField<V>>
+where
+ M: Message + 'static,
+ V: ProtobufValue + 'static,
+{
+ fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectRepeated {
+ (self.get_field)(m) as &dyn ReflectRepeated
+ }
+
+ fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectRepeated {
+ (self.mut_field)(m) as &mut dyn 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>,
+) -> FieldAccessor
+where
+ M: Message + 'static,
+ V: ProtobufType + 'static,
+{
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::Repeated(Box::new(MessageGetMut::<M, RepeatedField<V::Value>> {
+ get_field: get_vec,
+ mut_field: mut_vec,
+ })),
+ )
+}
+
+impl<M, V> FieldAccessor2<M, dyn ReflectOptional> for MessageGetMut<M, Option<V>>
+where
+ M: Message + 'static,
+ V: ProtobufValue + Clone + 'static,
+{
+ fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectOptional {
+ (self.get_field)(m) as &dyn ReflectOptional
+ }
+
+ fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectOptional {
+ (self.mut_field)(m) as &mut dyn 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>,
+) -> FieldAccessor
+where
+ M: Message + 'static,
+ V: ProtobufType + 'static,
+{
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::Optional(Box::new(MessageGetMut::<M, Option<V::Value>> {
+ get_field,
+ mut_field,
+ })),
+ )
+}
+
+impl<M, V> FieldAccessor2<M, dyn ReflectOptional> for MessageGetMut<M, SingularField<V>>
+where
+ M: Message + 'static,
+ V: ProtobufValue + Clone + 'static,
+{
+ fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectOptional {
+ (self.get_field)(m) as &dyn ReflectOptional
+ }
+
+ fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectOptional {
+ (self.mut_field)(m) as &mut dyn 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>,
+) -> FieldAccessor
+where
+ M: Message + 'static,
+ V: ProtobufType + 'static,
+{
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::Optional(Box::new(MessageGetMut::<M, SingularField<V::Value>> {
+ get_field,
+ mut_field,
+ })),
+ )
+}
+
+impl<M, V> FieldAccessor2<M, dyn ReflectOptional> for MessageGetMut<M, SingularPtrField<V>>
+where
+ M: Message + 'static,
+ V: ProtobufValue + Clone + 'static,
+{
+ fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectOptional {
+ (self.get_field)(m) as &dyn ReflectOptional
+ }
+
+ fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectOptional {
+ (self.mut_field)(m) as &mut dyn 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>,
+) -> FieldAccessor
+where
+ M: Message + 'static,
+ V: ProtobufType + 'static,
+{
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::Optional(Box::new(
+ MessageGetMut::<M, SingularPtrField<V::Value>> {
+ get_field,
+ mut_field,
+ },
+ )),
+ )
+}
+
+impl<M, V> FieldAccessor2<M, dyn ProtobufValue> for MessageGetMut<M, V>
+where
+ M: Message + 'static,
+ V: ProtobufValue + Clone + 'static,
+{
+ fn get_field<'a>(&self, m: &'a M) -> &'a dyn ProtobufValue {
+ (self.get_field)(m) as &dyn ProtobufValue
+ }
+
+ fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ProtobufValue {
+ (self.mut_field)(m) as &mut dyn 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,
+) -> FieldAccessor
+where
+ M: Message + 'static,
+ V: ProtobufType + 'static,
+{
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::Simple(Box::new(MessageGetMut::<M, V::Value> {
+ get_field,
+ mut_field,
+ })),
+ )
+}
+
+impl<M, K, V> FieldAccessor2<M, dyn 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 dyn ReflectMap {
+ (self.get_field)(m) as &dyn ReflectMap
+ }
+
+ fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectMap {
+ (self.mut_field)(m) as &mut dyn 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>,
+) -> FieldAccessor
+where
+ M: Message + 'static,
+ K: ProtobufType + 'static,
+ V: ProtobufType + 'static,
+ <K as ProtobufType>::Value: Hash + Eq,
+{
+ FieldAccessor::new_v1(
+ name,
+ FieldAccessorFunctions::Map(Box::new(MessageGetMut::<M, HashMap<K::Value, V::Value>> {
+ get_field,
+ mut_field,
+ })),
+ )
+}
diff --git a/2.27.1/src/reflect/accessor/mod.rs b/2.27.1/src/reflect/accessor/mod.rs
new file mode 100644
index 0000000..9fa97de
--- /dev/null
+++ b/2.27.1/src/reflect/accessor/mod.rs
@@ -0,0 +1,21 @@
+#![doc(hidden)]
+
+pub use crate::reflect::acc::v1::make_map_accessor;
+pub use crate::reflect::acc::v1::make_option_accessor;
+pub use crate::reflect::acc::v1::make_repeated_field_accessor;
+pub use crate::reflect::acc::v1::make_simple_field_accessor;
+pub use crate::reflect::acc::v1::make_singular_bool_accessor;
+pub use crate::reflect::acc::v1::make_singular_bytes_accessor;
+pub use crate::reflect::acc::v1::make_singular_enum_accessor;
+pub use crate::reflect::acc::v1::make_singular_f32_accessor;
+pub use crate::reflect::acc::v1::make_singular_f64_accessor;
+pub use crate::reflect::acc::v1::make_singular_field_accessor;
+pub use crate::reflect::acc::v1::make_singular_i32_accessor;
+pub use crate::reflect::acc::v1::make_singular_i64_accessor;
+pub use crate::reflect::acc::v1::make_singular_message_accessor;
+pub use crate::reflect::acc::v1::make_singular_ptr_field_accessor;
+pub use crate::reflect::acc::v1::make_singular_string_accessor;
+pub use crate::reflect::acc::v1::make_singular_u32_accessor;
+pub use crate::reflect::acc::v1::make_singular_u64_accessor;
+pub use crate::reflect::acc::v1::make_vec_accessor;
+pub use crate::reflect::acc::v1::FieldAccessorTrait;
diff --git a/2.27.1/src/reflect/enums.rs b/2.27.1/src/reflect/enums.rs
new file mode 100644
index 0000000..a25be6f
--- /dev/null
+++ b/2.27.1/src/reflect/enums.rs
@@ -0,0 +1,128 @@
+use std::collections::HashMap;
+
+use crate::descriptor::EnumDescriptorProto;
+use crate::descriptor::EnumValueDescriptorProto;
+use crate::descriptor::FileDescriptorProto;
+use crate::descriptorx::find_enum_by_rust_name;
+use crate::reflect::find_message_or_enum::find_message_or_enum;
+use crate::reflect::find_message_or_enum::MessageOrEnum;
+use crate::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/2.27.1/src/reflect/field.rs b/2.27.1/src/reflect/field.rs
new file mode 100644
index 0000000..09ee222
--- /dev/null
+++ b/2.27.1/src/reflect/field.rs
@@ -0,0 +1,245 @@
+use crate::descriptor::FieldDescriptorProto;
+use crate::descriptor::FieldDescriptorProto_Label;
+use crate::json::json_name;
+use crate::message::Message;
+use crate::reflect::acc::Accessor;
+use crate::reflect::acc::FieldAccessor;
+use crate::reflect::map::ReflectMap;
+use crate::reflect::repeated::ReflectRepeated;
+use crate::reflect::EnumValueDescriptor;
+use crate::reflect::ReflectValueRef;
+
+/// 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 dyn ReflectRepeated),
+ /// Map field
+ Map(&'a dyn ReflectMap),
+}
+
+/// Field descriptor.
+///
+/// Can be used for runtime reflection.
+pub struct FieldDescriptor {
+ proto: &'static FieldDescriptorProto,
+ accessor: FieldAccessor,
+ json_name: String,
+}
+
+impl FieldDescriptor {
+ pub(crate) fn new(
+ accessor: FieldAccessor,
+ proto: &'static FieldDescriptorProto,
+ ) -> FieldDescriptor {
+ assert_eq!(proto.get_name(), accessor.name);
+ let json_name = if !proto.get_json_name().is_empty() {
+ proto.get_json_name().to_string()
+ } else {
+ json_name(proto.get_name())
+ };
+ FieldDescriptor {
+ proto,
+ accessor,
+ // probably could be lazy-init
+ json_name,
+ }
+ }
+
+ /// 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()
+ }
+
+ /// JSON field name.
+ ///
+ /// Can be different from `.proto` field name.
+ ///
+ /// See [JSON mapping][json] for details.
+ ///
+ /// [json]: https://developers.google.com/protocol-buffers/docs/proto3#json
+ pub fn json_name(&self) -> &str {
+ &self.json_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: &dyn Message) -> bool {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.has_field_generic(m),
+ }
+ }
+
+ /// Return length of repeated field.
+ ///
+ /// For singular 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 {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.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 {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.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 {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.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 {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.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] {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.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 {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.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 {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.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 {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.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 {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.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 {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.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 {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.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 {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.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> {
+ match &self.accessor.accessor {
+ Accessor::V1(a) => a.get_reflect(m),
+ }
+ }
+}
diff --git a/2.27.1/src/reflect/find_message_or_enum.rs b/2.27.1/src/reflect/find_message_or_enum.rs
new file mode 100644
index 0000000..7ee3915
--- /dev/null
+++ b/2.27.1/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/2.27.1/src/reflect/map.rs b/2.27.1/src/reflect/map.rs
new file mode 100644
index 0000000..c6aff60
--- /dev/null
+++ b/2.27.1/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 dyn ProtobufValue, &'a dyn 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 dyn ProtobufValue, &'a dyn ProtobufValue)> {
+ match self.iter.next() {
+ Some((k, v)) => Some((k as &dyn ProtobufValue, v as &dyn ProtobufValue)),
+ None => None,
+ }
+ }
+}
+
+pub struct ReflectMapIter<'a> {
+ imp: Box<dyn ReflectMapIterTrait<'a> + 'a>,
+}
+
+impl<'a> Iterator for ReflectMapIter<'a> {
+ type Item = (&'a dyn ProtobufValue, &'a dyn ProtobufValue);
+
+ fn next(&mut self) -> Option<(&'a dyn ProtobufValue, &'a dyn ProtobufValue)> {
+ self.imp.next()
+ }
+}
+
+impl<'a> IntoIterator for &'a dyn ReflectMap {
+ type IntoIter = ReflectMapIter<'a>;
+ type Item = (&'a dyn ProtobufValue, &'a dyn ProtobufValue);
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.reflect_iter()
+ }
+}
diff --git a/2.27.1/src/reflect/message.rs b/2.27.1/src/reflect/message.rs
new file mode 100644
index 0000000..0db9821
--- /dev/null
+++ b/2.27.1/src/reflect/message.rs
@@ -0,0 +1,282 @@
+use std::collections::HashMap;
+use std::marker;
+
+use crate::descriptor::DescriptorProto;
+use crate::descriptor::FileDescriptorProto;
+use crate::descriptorx::find_message_by_rust_name;
+use crate::reflect::acc::FieldAccessor;
+use crate::reflect::find_message_or_enum::find_message_or_enum;
+use crate::reflect::find_message_or_enum::MessageOrEnum;
+use crate::reflect::FieldDescriptor;
+use crate::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_name_or_json_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<FieldAccessor>,
+ 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_name_or_json_name = HashMap::new();
+ let mut index_by_number = HashMap::new();
+
+ 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());
+
+ let fields: Vec<_> = fields
+ .into_iter()
+ .map(|f| {
+ let proto = *field_proto_by_name.get(&f.name).unwrap();
+ FieldDescriptor::new(f, proto)
+ })
+ .collect();
+ for (i, f) in fields.iter().enumerate() {
+ assert!(index_by_number
+ .insert(f.proto().get_number() as u32, i)
+ .is_none());
+ assert!(index_by_name
+ .insert(f.proto().get_name().to_owned(), i)
+ .is_none());
+ assert!(index_by_name_or_json_name
+ .insert(f.proto().get_name().to_owned(), i)
+ .is_none());
+
+ let json_name = f.json_name().to_owned();
+
+ if json_name != f.proto().get_name() {
+ assert!(index_by_name_or_json_name.insert(json_name, i).is_none());
+ }
+ }
+ MessageDescriptor {
+ full_name,
+ proto: proto.message,
+ factory,
+ fields,
+ index_by_name,
+ index_by_name_or_json_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<FieldAccessor>,
+ 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_name_or_json_name = HashMap::new();
+ let mut index_by_number = HashMap::new();
+
+ let full_name = MessageDescriptor::compute_full_name(
+ file_descriptor_proto.get_package(),
+ &path_to_package,
+ &proto,
+ );
+ let fields: Vec<_> = fields
+ .into_iter()
+ .map(|f| {
+ let proto = *field_proto_by_name.get(&f.name).unwrap();
+ FieldDescriptor::new(f, proto)
+ })
+ .collect();
+
+ for (i, f) in fields.iter().enumerate() {
+ assert!(index_by_number
+ .insert(f.proto().get_number() as u32, i)
+ .is_none());
+ assert!(index_by_name
+ .insert(f.proto().get_name().to_owned(), i)
+ .is_none());
+ assert!(index_by_name_or_json_name
+ .insert(f.proto().get_name().to_owned(), i)
+ .is_none());
+
+ let json_name = f.json_name().to_owned();
+
+ if json_name != f.proto().get_name() {
+ assert!(index_by_name_or_json_name.insert(json_name, i).is_none());
+ }
+ }
+ MessageDescriptor {
+ full_name,
+ proto,
+ factory,
+ fields,
+ index_by_name,
+ index_by_name_or_json_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<FieldAccessor>,
+ 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<FieldAccessor>,
+ 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()
+ }
+
+ /// Message name as given in `.proto` file
+ 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 message field by protobuf field name
+ ///
+ /// Note: protobuf field name might be different for Rust field name.
+ pub fn get_field_by_name<'a>(&'a self, name: &str) -> Option<&'a FieldDescriptor> {
+ let &index = self.index_by_name.get(name)?;
+ Some(&self.fields[index])
+ }
+
+ /// Find message field by field name or field JSON name
+ pub fn get_field_by_name_or_json_name<'a>(&'a self, name: &str) -> Option<&'a FieldDescriptor> {
+ let &index = self.index_by_name_or_json_name.get(name)?;
+ Some(&self.fields[index])
+ }
+
+ /// Find message field by field name
+ pub fn get_field_by_number(&self, number: u32) -> Option<&FieldDescriptor> {
+ let &index = self.index_by_number.get(&number)?;
+ Some(&self.fields[index])
+ }
+
+ /// Find field by name
+ // TODO: deprecate
+ 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
+ // TODO: deprecate
+ 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/2.27.1/src/reflect/mod.rs b/2.27.1/src/reflect/mod.rs
new file mode 100644
index 0000000..e120e16
--- /dev/null
+++ b/2.27.1/src/reflect/mod.rs
@@ -0,0 +1,28 @@
+//! Reflection implementation for protobuf types.
+
+use crate::message::Message;
+
+mod acc;
+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 mod rt;
+
+pub use self::enums::EnumDescriptor;
+pub use self::enums::EnumValueDescriptor;
+pub use self::field::FieldDescriptor;
+pub use self::field::ReflectFieldRef;
+pub use self::message::MessageDescriptor;
diff --git a/2.27.1/src/reflect/optional.rs b/2.27.1/src/reflect/optional.rs
new file mode 100644
index 0000000..f719a2c
--- /dev/null
+++ b/2.27.1/src/reflect/optional.rs
@@ -0,0 +1,49 @@
+use std::mem;
+
+use super::value::ProtobufValue;
+use crate::singular::*;
+
+pub trait ReflectOptional: 'static {
+ fn to_option(&self) -> Option<&dyn ProtobufValue>;
+
+ fn set_value(&mut self, value: &dyn ProtobufValue);
+}
+
+impl<V: ProtobufValue + Clone + 'static> ReflectOptional for Option<V> {
+ fn to_option(&self) -> Option<&dyn ProtobufValue> {
+ self.as_ref().map(|v| v as &dyn ProtobufValue)
+ }
+
+ fn set_value(&mut self, value: &dyn 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<&dyn ProtobufValue> {
+ self.as_ref().map(|v| v as &dyn ProtobufValue)
+ }
+
+ fn set_value(&mut self, value: &dyn 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<&dyn ProtobufValue> {
+ self.as_ref().map(|v| v as &dyn ProtobufValue)
+ }
+
+ fn set_value(&mut self, value: &dyn ProtobufValue) {
+ match value.as_any().downcast_ref::<V>() {
+ Some(v) => mem::replace(self, SingularPtrField::some(v.clone())),
+ None => panic!(),
+ };
+ }
+}
diff --git a/2.27.1/src/reflect/repeated.rs b/2.27.1/src/reflect/repeated.rs
new file mode 100644
index 0000000..710de3e
--- /dev/null
+++ b/2.27.1/src/reflect/repeated.rs
@@ -0,0 +1,191 @@
+use std::slice;
+
+use super::value::ProtobufValue;
+use super::value::ReflectValueRef;
+use crate::repeated::RepeatedField;
+
+pub trait ReflectRepeated: 'static {
+ fn reflect_iter(&self) -> ReflectRepeatedIter;
+ fn len(&self) -> usize;
+ fn get(&self, index: usize) -> &dyn 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) -> &dyn 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) -> &dyn 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) -> &dyn ProtobufValue {
+ &self[index]
+ }
+}
+
+trait ReflectRepeatedIterTrait<'a> {
+ fn next(&mut self) -> Option<&'a dyn 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 dyn ProtobufValue> {
+ self.iter.next().map(|v| v as &dyn ProtobufValue)
+ }
+}
+
+pub struct ReflectRepeatedIter<'a> {
+ imp: Box<dyn ReflectRepeatedIterTrait<'a> + 'a>,
+}
+
+impl<'a> Iterator for ReflectRepeatedIter<'a> {
+ type Item = &'a dyn ProtobufValue;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.imp.next()
+ }
+}
+
+impl<'a> IntoIterator for &'a dyn ReflectRepeated {
+ type IntoIter = ReflectRepeatedIter<'a>;
+ type Item = &'a dyn 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 dyn 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<dyn ReflectRepeatedEnum<'a> + 'a>),
+ Message(Box<dyn 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/2.27.1/src/reflect/rt/mod.rs b/2.27.1/src/reflect/rt/mod.rs
new file mode 100644
index 0000000..d715d92
--- /dev/null
+++ b/2.27.1/src/reflect/rt/mod.rs
@@ -0,0 +1,5 @@
+//! This module contains functions references for reflection in generated code.
+
+#![doc(hidden)]
+
+pub use crate::reflect::acc::FieldAccessor;
diff --git a/2.27.1/src/reflect/value.rs b/2.27.1/src/reflect/value.rs
new file mode 100644
index 0000000..9598b9f
--- /dev/null
+++ b/2.27.1/src/reflect/value.rs
@@ -0,0 +1,185 @@
+use std::any::Any;
+
+#[cfg(feature = "bytes")]
+use bytes::Bytes;
+
+use super::*;
+#[cfg(feature = "bytes")]
+use crate::chars::Chars;
+
+/// Type implemented by all protobuf elementary types
+/// (ints, floats, bool, string, bytes, enums, messages).
+pub trait ProtobufValue: Any + 'static {
+ /// As ref
+ fn as_ref(&self) -> ReflectValueRef;
+
+ /// Convert to `Any`
+ fn as_any(&self) -> &dyn 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/2.27.1/src/repeated.rs b/2.27.1/src/repeated.rs
new file mode 100644
index 0000000..0b749d9
--- /dev/null
+++ b/2.27.1/src/repeated.rs
@@ -0,0 +1,563 @@
+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;
+
+#[cfg(feature = "with-serde")]
+use serde;
+
+use crate::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)
+ }
+
+ /// Retains only the elements specified by the predicate.
+ ///
+ /// In other words, remove all elements `e` such that `f(&e)` returns `false`.
+ /// This method operates in place, visiting each element exactly once in the
+ /// original order, and preserves the order of the retained elements.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # use protobuf::RepeatedField;
+ ///
+ /// let mut vec = RepeatedField::from(vec![1, 2, 3, 4]);
+ /// vec.retain(|&x| x % 2 == 0);
+ /// assert_eq!(vec, RepeatedField::from(vec![2, 4]));
+ /// ```
+ pub fn retain<F>(&mut self, f: F)
+ where
+ F: FnMut(&T) -> bool,
+ {
+ // suboptimal
+ self.vec.truncate(self.len);
+ self.vec.retain(f);
+ self.len = self.vec.len();
+ }
+
+ /// 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<'a, T> IntoIterator for &'a mut RepeatedField<T> {
+ type Item = &'a mut T;
+ type IntoIter = slice::IterMut<'a, T>;
+
+ fn into_iter(self) -> slice::IterMut<'a, T> {
+ self.iter_mut()
+ }
+}
+
+impl<'a, T> IntoIterator for RepeatedField<T> {
+ type Item = T;
+ type IntoIter = vec::IntoIter<T>;
+
+ fn into_iter(self) -> vec::IntoIter<T> {
+ self.into_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> PartialEq<[T]> for RepeatedField<T> {
+ fn eq(&self, other: &[T]) -> bool {
+ self.as_slice() == other
+ }
+}
+
+impl<T: PartialEq> PartialEq<RepeatedField<T>> for [T] {
+ fn eq(&self, other: &RepeatedField<T>) -> bool {
+ self == other.as_slice()
+ }
+}
+
+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> Extend<T> for RepeatedField<T> {
+ fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
+ self.vec.truncate(self.len);
+ self.vec.extend(iter);
+ self.len = self.vec.len();
+ }
+}
+
+impl<'a, T: Copy + 'a> Extend<&'a T> for RepeatedField<T> {
+ fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
+ self.vec.truncate(self.len);
+ self.vec.extend(iter);
+ self.len = self.vec.len();
+ }
+}
+
+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());
+ }
+
+ #[test]
+ fn extend_values() {
+ let mut r = RepeatedField::new();
+ r.push(10);
+ r.push(20);
+ r.clear();
+ // self-check
+ assert_eq!(2, r.vec.len());
+ r.extend(vec![30, 40]);
+ assert_eq!(&[30, 40][..], &r);
+ }
+
+ #[test]
+ fn extend_copy() {
+ let mut r = RepeatedField::new();
+ r.push(10);
+ r.push(20);
+ r.clear();
+ // self-check
+ assert_eq!(2, r.vec.len());
+ r.extend(&[30, 40]);
+ assert_eq!(&[30, 40][..], &r);
+ }
+}
diff --git a/2.27.1/src/rt.rs b/2.27.1/src/rt.rs
new file mode 100644
index 0000000..fca1254
--- /dev/null
+++ b/2.27.1/src/rt.rs
@@ -0,0 +1,929 @@
+//! 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 crate::chars::Chars;
+use crate::coded_input_stream::CodedInputStream;
+use crate::coded_output_stream::CodedOutputStream;
+use crate::enums::ProtobufEnum;
+use crate::error::ProtobufError;
+use crate::error::ProtobufResult;
+use crate::error::WireError;
+pub use crate::lazy_v2::LazyV2;
+use crate::message::*;
+use crate::repeated::RepeatedField;
+use crate::singular::SingularField;
+use crate::singular::SingularPtrField;
+use crate::types::*;
+use crate::unknown::UnknownFields;
+use crate::wire_format;
+use crate::wire_format::WireType;
+use crate::zigzag::*;
+
+/// Given `u64` value compute varint encoded length.
+pub fn compute_raw_varint64_size(value: u64) -> u32 {
+ 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, WireType::WireTypeFixed64)
+ .value()
+ .len_varint()
+}
+
+fn value_size_no_tag<T: ProtobufVarint>(value: T, wt: WireType) -> u32 {
+ match wt {
+ WireType::WireTypeFixed64 => 8,
+ WireType::WireTypeFixed32 => 4,
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_int32_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_int64_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_uint32_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_uint64_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_sint32_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_sint64_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_fixed32_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_fixed64_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_sfixed32_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_sfixed64_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_double_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_float_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_bool_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => is.read_repeated_packed_enum_into(target),
+ WireType::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 {
+ WireType::WireTypeLengthDelimited => read_repeated_packed_enum_with_unknown_fields_into(
+ is,
+ target,
+ field_number,
+ unknown_fields,
+ ),
+ WireType::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 {
+ WireType::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 {
+ WireType::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 {
+ WireType::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 {
+ WireType::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 {
+ WireType::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 {
+ WireType::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 {
+ WireType::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 {
+ WireType::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 {
+ WireType::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 {
+ WireType::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 {
+ WireType::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 {
+ WireType::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 {
+ WireType::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 {
+ WireType::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/2.27.1/src/rust.rs b/2.27.1/src/rust.rs
new file mode 100644
index 0000000..9d4995b
--- /dev/null
+++ b/2.27.1/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/2.27.1/src/rustproto.rs b/2.27.1/src/rustproto.rs
new file mode 100644
index 0000000..75df067
--- /dev/null
+++ b/2.27.1/src/rustproto.rs
@@ -0,0 +1,203 @@
+// This file is generated by rust-protobuf 2.26.0. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(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(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `rustproto.proto`
+
+/// Extension fields
+pub mod exts {
+
+ pub const expose_oneof_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17001, phantom: ::std::marker::PhantomData };
+
+ pub const expose_fields_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17003, phantom: ::std::marker::PhantomData };
+
+ pub const generate_accessors_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17004, phantom: ::std::marker::PhantomData };
+
+ pub const carllerche_bytes_for_bytes_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17011, phantom: ::std::marker::PhantomData };
+
+ pub const carllerche_bytes_for_string_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17012, phantom: ::std::marker::PhantomData };
+
+ pub const serde_derive_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17030, phantom: ::std::marker::PhantomData };
+
+ pub const serde_derive_cfg_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeString> = crate::ext::ExtFieldOptional { field_number: 17031, phantom: ::std::marker::PhantomData };
+
+ pub const lite_runtime_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17035, phantom: ::std::marker::PhantomData };
+
+ pub const expose_oneof: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17001, phantom: ::std::marker::PhantomData };
+
+ pub const expose_fields: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17003, phantom: ::std::marker::PhantomData };
+
+ pub const generate_accessors: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17004, phantom: ::std::marker::PhantomData };
+
+ pub const carllerche_bytes_for_bytes: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17011, phantom: ::std::marker::PhantomData };
+
+ pub const carllerche_bytes_for_string: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17012, phantom: ::std::marker::PhantomData };
+
+ pub const serde_derive: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17030, phantom: ::std::marker::PhantomData };
+
+ pub const serde_derive_cfg: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeString> = crate::ext::ExtFieldOptional { field_number: 17031, phantom: ::std::marker::PhantomData };
+
+ pub const expose_fields_field: crate::ext::ExtFieldOptional<crate::descriptor::FieldOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17003, phantom: ::std::marker::PhantomData };
+
+ pub const generate_accessors_field: crate::ext::ExtFieldOptional<crate::descriptor::FieldOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17004, phantom: ::std::marker::PhantomData };
+
+ pub const carllerche_bytes_for_bytes_field: crate::ext::ExtFieldOptional<crate::descriptor::FieldOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17011, phantom: ::std::marker::PhantomData };
+
+ pub const carllerche_bytes_for_string_field: crate::ext::ExtFieldOptional<crate::descriptor::FieldOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17012, phantom: ::std::marker::PhantomData };
+
+ pub const serde_rename_all: crate::ext::ExtFieldOptional<crate::descriptor::EnumOptions, crate::types::ProtobufTypeString> = crate::ext::ExtFieldOptional { field_number: 17032, phantom: ::std::marker::PhantomData };
+}
+
+static file_descriptor_proto_data: &'static [u8] = b"\
+ \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\x1dcarllercheBytesForStringField:H\n\x10serde_rename_all\x18\x88\
+ \x85\x01\x20\x01(\t\x12\x1c.google.protobuf.EnumOptionsR\x0eserdeRenameA\
+ llJ\xea\x14\n\x06\x12\x04\0\0<\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\t\n\
+ \x02\x03\0\x12\x03\x02\0*\nh\n\x01\x02\x12\x03\x07\0\x122^\x20see\x20htt\
+ ps://github.com/gogo/protobuf/blob/master/gogoproto/gogo.proto\n\x20for\
+ \x20the\x20original\x20idea\n\n\t\n\x01\x07\x12\x04\t\0\x1b\x01\n7\n\x02\
+ \x07\0\x12\x03\x0b\x04+\x1a,\x20When\x20true,\x20oneof\x20field\x20is\
+ \x20generated\x20public\n\n\n\n\x03\x07\0\x02\x12\x03\t\x07\"\n\n\n\x03\
+ \x07\0\x04\x12\x03\x0b\x04\x0c\n\n\n\x03\x07\0\x05\x12\x03\x0b\r\x11\n\n\
+ \n\x03\x07\0\x01\x12\x03\x0b\x12\"\n\n\n\x03\x07\0\x03\x12\x03\x0b%*\nI\
+ \n\x02\x07\x01\x12\x03\r\x04,\x1a>\x20When\x20true\x20all\x20fields\x20a\
+ re\x20public,\x20and\x20not\x20accessors\x20generated\n\n\n\n\x03\x07\
+ \x01\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x01\x04\x12\x03\r\x04\x0c\n\n\n\
+ \x03\x07\x01\x05\x12\x03\r\r\x11\n\n\n\x03\x07\x01\x01\x12\x03\r\x12#\n\
+ \n\n\x03\x07\x01\x03\x12\x03\r&+\nP\n\x02\x07\x02\x12\x03\x0f\x041\x1aE\
+ \x20When\x20false,\x20`get_`,\x20`set_`,\x20`mut_`\x20etc.\x20accessors\
+ \x20are\x20not\x20generated\n\n\n\n\x03\x07\x02\x02\x12\x03\t\x07\"\n\n\
+ \n\x03\x07\x02\x04\x12\x03\x0f\x04\x0c\n\n\n\x03\x07\x02\x05\x12\x03\x0f\
+ \r\x11\n\n\n\x03\x07\x02\x01\x12\x03\x0f\x12(\n\n\n\x03\x07\x02\x03\x12\
+ \x03\x0f+0\n2\n\x02\x07\x03\x12\x03\x11\x049\x1a'\x20Use\x20`bytes::Byte\
+ s`\x20for\x20`bytes`\x20fields\n\n\n\n\x03\x07\x03\x02\x12\x03\t\x07\"\n\
+ \n\n\x03\x07\x03\x04\x12\x03\x11\x04\x0c\n\n\n\x03\x07\x03\x05\x12\x03\
+ \x11\r\x11\n\n\n\x03\x07\x03\x01\x12\x03\x11\x120\n\n\n\x03\x07\x03\x03\
+ \x12\x03\x1138\n3\n\x02\x07\x04\x12\x03\x13\x04:\x1a(\x20Use\x20`bytes::\
+ Bytes`\x20for\x20`string`\x20fields\n\n\n\n\x03\x07\x04\x02\x12\x03\t\
+ \x07\"\n\n\n\x03\x07\x04\x04\x12\x03\x13\x04\x0c\n\n\n\x03\x07\x04\x05\
+ \x12\x03\x13\r\x11\n\n\n\x03\x07\x04\x01\x12\x03\x13\x121\n\n\n\x03\x07\
+ \x04\x03\x12\x03\x1349\nJ\n\x02\x07\x05\x12\x03\x15\x04+\x1a?\x20Use\x20\
+ `serde_derive`\x20to\x20implement\x20`Serialize`\x20and\x20`Deserialize`\
+ \n\n\n\n\x03\x07\x05\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x05\x04\x12\x03\
+ \x15\x04\x0c\n\n\n\x03\x07\x05\x05\x12\x03\x15\r\x11\n\n\n\x03\x07\x05\
+ \x01\x12\x03\x15\x12\"\n\n\n\x03\x07\x05\x03\x12\x03\x15%*\n3\n\x02\x07\
+ \x06\x12\x03\x17\x041\x1a(\x20Guard\x20serde\x20annotations\x20with\x20c\
+ fg\x20attr.\n\n\n\n\x03\x07\x06\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x06\
+ \x04\x12\x03\x17\x04\x0c\n\n\n\x03\x07\x06\x05\x12\x03\x17\r\x13\n\n\n\
+ \x03\x07\x06\x01\x12\x03\x17\x14(\n\n\n\x03\x07\x06\x03\x12\x03\x17+0\nN\
+ \n\x02\x07\x07\x12\x03\x1a\x04+\x1aC\x20When\x20true,\x20will\x20only\
+ \x20generate\x20codes\x20that\x20works\x20with\x20lite\x20runtime.\n\n\n\
+ \n\x03\x07\x07\x02\x12\x03\t\x07\"\n\n\n\x03\x07\x07\x04\x12\x03\x1a\x04\
+ \x0c\n\n\n\x03\x07\x07\x05\x12\x03\x1a\r\x11\n\n\n\x03\x07\x07\x01\x12\
+ \x03\x1a\x12\"\n\n\n\x03\x07\x07\x03\x12\x03\x1a%*\n\t\n\x01\x07\x12\x04\
+ \x1d\0,\x01\n7\n\x02\x07\x08\x12\x03\x1f\x04'\x1a,\x20When\x20true,\x20o\
+ neof\x20field\x20is\x20generated\x20public\n\n\n\n\x03\x07\x08\x02\x12\
+ \x03\x1d\x07%\n\n\n\x03\x07\x08\x04\x12\x03\x1f\x04\x0c\n\n\n\x03\x07\
+ \x08\x05\x12\x03\x1f\r\x11\n\n\n\x03\x07\x08\x01\x12\x03\x1f\x12\x1e\n\n\
+ \n\x03\x07\x08\x03\x12\x03\x1f!&\nI\n\x02\x07\t\x12\x03!\x04(\x1a>\x20Wh\
+ en\x20true\x20all\x20fields\x20are\x20public,\x20and\x20not\x20accessors\
+ \x20generated\n\n\n\n\x03\x07\t\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\t\x04\
+ \x12\x03!\x04\x0c\n\n\n\x03\x07\t\x05\x12\x03!\r\x11\n\n\n\x03\x07\t\x01\
+ \x12\x03!\x12\x1f\n\n\n\x03\x07\t\x03\x12\x03!\"'\nP\n\x02\x07\n\x12\x03\
+ #\x04-\x1aE\x20When\x20false,\x20`get_`,\x20`set_`,\x20`mut_`\x20etc.\
+ \x20accessors\x20are\x20not\x20generated\n\n\n\n\x03\x07\n\x02\x12\x03\
+ \x1d\x07%\n\n\n\x03\x07\n\x04\x12\x03#\x04\x0c\n\n\n\x03\x07\n\x05\x12\
+ \x03#\r\x11\n\n\n\x03\x07\n\x01\x12\x03#\x12$\n\n\n\x03\x07\n\x03\x12\
+ \x03#',\n2\n\x02\x07\x0b\x12\x03%\x045\x1a'\x20Use\x20`bytes::Bytes`\x20\
+ for\x20`bytes`\x20fields\n\n\n\n\x03\x07\x0b\x02\x12\x03\x1d\x07%\n\n\n\
+ \x03\x07\x0b\x04\x12\x03%\x04\x0c\n\n\n\x03\x07\x0b\x05\x12\x03%\r\x11\n\
+ \n\n\x03\x07\x0b\x01\x12\x03%\x12,\n\n\n\x03\x07\x0b\x03\x12\x03%/4\n3\n\
+ \x02\x07\x0c\x12\x03'\x046\x1a(\x20Use\x20`bytes::Bytes`\x20for\x20`stri\
+ ng`\x20fields\n\n\n\n\x03\x07\x0c\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\x0c\
+ \x04\x12\x03'\x04\x0c\n\n\n\x03\x07\x0c\x05\x12\x03'\r\x11\n\n\n\x03\x07\
+ \x0c\x01\x12\x03'\x12-\n\n\n\x03\x07\x0c\x03\x12\x03'05\nJ\n\x02\x07\r\
+ \x12\x03)\x04'\x1a?\x20Use\x20`serde_derive`\x20to\x20implement\x20`Seri\
+ alize`\x20and\x20`Deserialize`\n\n\n\n\x03\x07\r\x02\x12\x03\x1d\x07%\n\
+ \n\n\x03\x07\r\x04\x12\x03)\x04\x0c\n\n\n\x03\x07\r\x05\x12\x03)\r\x11\n\
+ \n\n\x03\x07\r\x01\x12\x03)\x12\x1e\n\n\n\x03\x07\r\x03\x12\x03)!&\n3\n\
+ \x02\x07\x0e\x12\x03+\x04-\x1a(\x20Guard\x20serde\x20annotations\x20with\
+ \x20cfg\x20attr.\n\n\n\n\x03\x07\x0e\x02\x12\x03\x1d\x07%\n\n\n\x03\x07\
+ \x0e\x04\x12\x03+\x04\x0c\n\n\n\x03\x07\x0e\x05\x12\x03+\r\x13\n\n\n\x03\
+ \x07\x0e\x01\x12\x03+\x14$\n\n\n\x03\x07\x0e\x03\x12\x03+',\n\t\n\x01\
+ \x07\x12\x04.\07\x01\nI\n\x02\x07\x0f\x12\x030\x04.\x1a>\x20When\x20true\
+ \x20all\x20fields\x20are\x20public,\x20and\x20not\x20accessors\x20genera\
+ ted\n\n\n\n\x03\x07\x0f\x02\x12\x03.\x07#\n\n\n\x03\x07\x0f\x04\x12\x030\
+ \x04\x0c\n\n\n\x03\x07\x0f\x05\x12\x030\r\x11\n\n\n\x03\x07\x0f\x01\x12\
+ \x030\x12%\n\n\n\x03\x07\x0f\x03\x12\x030(-\nP\n\x02\x07\x10\x12\x032\
+ \x043\x1aE\x20When\x20false,\x20`get_`,\x20`set_`,\x20`mut_`\x20etc.\x20\
+ accessors\x20are\x20not\x20generated\n\n\n\n\x03\x07\x10\x02\x12\x03.\
+ \x07#\n\n\n\x03\x07\x10\x04\x12\x032\x04\x0c\n\n\n\x03\x07\x10\x05\x12\
+ \x032\r\x11\n\n\n\x03\x07\x10\x01\x12\x032\x12*\n\n\n\x03\x07\x10\x03\
+ \x12\x032-2\n2\n\x02\x07\x11\x12\x034\x04;\x1a'\x20Use\x20`bytes::Bytes`\
+ \x20for\x20`bytes`\x20fields\n\n\n\n\x03\x07\x11\x02\x12\x03.\x07#\n\n\n\
+ \x03\x07\x11\x04\x12\x034\x04\x0c\n\n\n\x03\x07\x11\x05\x12\x034\r\x11\n\
+ \n\n\x03\x07\x11\x01\x12\x034\x122\n\n\n\x03\x07\x11\x03\x12\x0345:\n3\n\
+ \x02\x07\x12\x12\x036\x04<\x1a(\x20Use\x20`bytes::Bytes`\x20for\x20`stri\
+ ng`\x20fields\n\n\n\n\x03\x07\x12\x02\x12\x03.\x07#\n\n\n\x03\x07\x12\
+ \x04\x12\x036\x04\x0c\n\n\n\x03\x07\x12\x05\x12\x036\r\x11\n\n\n\x03\x07\
+ \x12\x01\x12\x036\x123\n\n\n\x03\x07\x12\x03\x12\x0366;\n\t\n\x01\x07\
+ \x12\x049\0<\x01\n/\n\x02\x07\x13\x12\x03;\x04-\x1a$\x20use\x20rename_al\
+ l\x20attribute\x20for\x20serde\n\n\n\n\x03\x07\x13\x02\x12\x039\x07\"\n\
+ \n\n\x03\x07\x13\x04\x12\x03;\x04\x0c\n\n\n\x03\x07\x13\x05\x12\x03;\r\
+ \x13\n\n\n\x03\x07\x13\x01\x12\x03;\x14$\n\n\n\x03\x07\x13\x03\x12\x03;'\
+ ,\
+";
+
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+ crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
+ file_descriptor_proto_lazy.get(|| {
+ parse_descriptor_proto()
+ })
+}
diff --git a/2.27.1/src/singular.rs b/2.27.1/src/singular.rs
new file mode 100644
index 0000000..1b7e28d
--- /dev/null
+++ b/2.27.1/src/singular.rs
@@ -0,0 +1,594 @@
+use std::default::Default;
+use std::fmt;
+use std::hash::Hash;
+use std::hash::Hasher;
+use std::mem;
+use std::option;
+
+#[cfg(feature = "with-serde")]
+use serde;
+
+use crate::clear::Clear;
+
+/// Like `Option<T>`, but keeps the actual element on `clear`.
+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 {
+ if !self.set {
+ 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 crate::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);
+ }
+
+ #[test]
+ fn unwrap_or_default() {
+ assert_eq!(
+ "abc",
+ SingularField::some("abc".to_owned()).unwrap_or_default()
+ );
+ assert_eq!("", SingularField::<String>::none().unwrap_or_default());
+ let mut some = SingularField::some("abc".to_owned());
+ some.clear();
+ assert_eq!("", some.unwrap_or_default());
+ }
+}
diff --git a/2.27.1/src/strx.rs b/2.27.1/src/strx.rs
new file mode 100644
index 0000000..af09de2
--- /dev/null
+++ b/2.27.1/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/2.27.1/src/text_format/lexer/float.rs b/2.27.1/src/text_format/lexer/float.rs
new file mode 100644
index 0000000..0d69c09
--- /dev/null
+++ b/2.27.1/src/text_format/lexer/float.rs
@@ -0,0 +1,58 @@
+use std::f64;
+
+#[derive(Debug)]
+pub enum ProtobufFloatParseError {
+ EmptyString,
+ CannotParseFloat,
+}
+
+pub type ProtobufFloatParseResult<T> = Result<T, ProtobufFloatParseError>;
+
+pub const PROTOBUF_NAN: &str = "nan";
+pub const PROTOBUF_INF: &str = "inf";
+
+/// Format float as in protobuf `.proto` files
+pub fn format_protobuf_float(f: f64) -> String {
+ if f.is_nan() {
+ PROTOBUF_NAN.to_owned()
+ } else if f.is_infinite() {
+ if f > 0.0 {
+ format!("{}", PROTOBUF_INF)
+ } else {
+ format!("-{}", PROTOBUF_INF)
+ }
+ } else {
+ // TODO: make sure doesn't lose precision
+ format!("{}", f)
+ }
+}
+
+/// Parse float from `.proto` format
+pub fn parse_protobuf_float(s: &str) -> ProtobufFloatParseResult<f64> {
+ if s.is_empty() {
+ return Err(ProtobufFloatParseError::EmptyString);
+ }
+ if s == PROTOBUF_NAN {
+ return Ok(f64::NAN);
+ }
+ if s == PROTOBUF_INF || s == format!("+{}", PROTOBUF_INF) {
+ return Ok(f64::INFINITY);
+ }
+ if s == format!("-{}", PROTOBUF_INF) {
+ return Ok(f64::NEG_INFINITY);
+ }
+ match s.parse() {
+ Ok(f) => Ok(f),
+ Err(_) => Err(ProtobufFloatParseError::CannotParseFloat),
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn test_format_protobuf_float() {
+ assert_eq!("10", format_protobuf_float(10.0));
+ }
+}
diff --git a/2.27.1/src/text_format/lexer/json_number_lit.rs b/2.27.1/src/text_format/lexer/json_number_lit.rs
new file mode 100644
index 0000000..6394b0e
--- /dev/null
+++ b/2.27.1/src/text_format/lexer/json_number_lit.rs
@@ -0,0 +1,10 @@
+use std::fmt;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct JsonNumberLit(pub(crate) String);
+
+impl fmt::Display for JsonNumberLit {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::Display::fmt(&self.0, f)
+ }
+}
diff --git a/2.27.1/src/text_format/lexer/lexer_impl.rs b/2.27.1/src/text_format/lexer/lexer_impl.rs
new file mode 100644
index 0000000..ae9035a
--- /dev/null
+++ b/2.27.1/src/text_format/lexer/lexer_impl.rs
@@ -0,0 +1,726 @@
+use std::char;
+use std::convert::TryFrom;
+use std::f64;
+use std::fmt;
+use std::num::ParseFloatError;
+use std::num::ParseIntError;
+
+use super::float;
+use super::loc::Loc;
+use super::loc::FIRST_COL;
+use super::str_lit::StrLit;
+use super::str_lit::StrLitDecodeError;
+use super::token::Token;
+use super::token::TokenWithLocation;
+use super::ParserLanguage;
+use crate::text_format::lexer::JsonNumberLit;
+
+#[derive(Debug)]
+pub enum LexerError {
+ IncorrectInput, // TODO: something better than this
+ UnexpectedEof,
+ ExpectChar(char),
+ ParseIntError,
+ ParseFloatError,
+ IncorrectFloatLit, // TODO: how it is different from ParseFloatError?
+ IncorrectJsonEscape,
+ IncorrectJsonNumber,
+ IncorrectUnicodeChar,
+ ExpectHexDigit,
+ ExpectOctDigit,
+ ExpectDecDigit,
+ StrLitDecodeError(StrLitDecodeError),
+ ExpectedIdent,
+}
+
+impl fmt::Display for LexerError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ LexerError::IncorrectInput => write!(f, "Incorrect input"),
+ LexerError::UnexpectedEof => write!(f, "Unexpected EOF"),
+ LexerError::ExpectChar(c) => write!(f, "Expecting char: {}", c),
+ LexerError::ParseIntError => write!(f, "Parse int error"),
+ LexerError::ParseFloatError => write!(f, "Parse float error"),
+ LexerError::IncorrectFloatLit => write!(f, "Incorrect float literal"),
+ LexerError::IncorrectJsonEscape => write!(f, "Incorrect JSON escape"),
+ LexerError::IncorrectJsonNumber => write!(f, "Incorrect JSON number"),
+ LexerError::IncorrectUnicodeChar => write!(f, "Incorrect Unicode char"),
+ LexerError::ExpectHexDigit => write!(f, "Expecting hex digit"),
+ LexerError::ExpectOctDigit => write!(f, "Expecting oct digit"),
+ LexerError::ExpectDecDigit => write!(f, "Expecting dec digit"),
+ LexerError::StrLitDecodeError(e) => write!(f, "{}", e),
+ LexerError::ExpectedIdent => write!(f, "Expecting identifier"),
+ }
+ }
+}
+
+impl std::error::Error for LexerError {}
+
+pub type LexerResult<T> = Result<T, LexerError>;
+
+impl From<StrLitDecodeError> for LexerError {
+ fn from(e: StrLitDecodeError) -> Self {
+ LexerError::StrLitDecodeError(e)
+ }
+}
+
+impl From<ParseIntError> for LexerError {
+ fn from(_: ParseIntError) -> Self {
+ LexerError::ParseIntError
+ }
+}
+
+impl From<ParseFloatError> for LexerError {
+ fn from(_: ParseFloatError) -> Self {
+ LexerError::ParseFloatError
+ }
+}
+
+impl From<float::ProtobufFloatParseError> for LexerError {
+ fn from(_: float::ProtobufFloatParseError) -> Self {
+ LexerError::IncorrectFloatLit
+ }
+}
+
+#[derive(Copy, Clone)]
+pub struct Lexer<'a> {
+ language: ParserLanguage,
+ input: &'a str,
+ pos: usize,
+ pub loc: Loc,
+}
+
+fn is_letter(c: char) -> bool {
+ c.is_alphabetic() || c == '_'
+}
+
+impl<'a> Lexer<'a> {
+ pub fn new(input: &'a str, language: ParserLanguage) -> Lexer<'a> {
+ Lexer {
+ language,
+ input,
+ pos: 0,
+ loc: Loc::start(),
+ }
+ }
+
+ /// No more chars
+ pub fn eof(&self) -> bool {
+ self.pos == self.input.len()
+ }
+
+ /// Remaining chars
+ fn rem_chars(&self) -> &'a str {
+ &self.input[self.pos..]
+ }
+
+ pub fn lookahead_char_is<P: FnOnce(char) -> bool>(&self, p: P) -> bool {
+ self.lookahead_char().map_or(false, p)
+ }
+
+ fn lookahead_char_is_in(&self, alphabet: &str) -> bool {
+ self.lookahead_char_is(|c| alphabet.contains(c))
+ }
+
+ fn next_char_opt(&mut self) -> Option<char> {
+ let rem = self.rem_chars();
+ if rem.is_empty() {
+ None
+ } else {
+ let mut char_indices = rem.char_indices();
+ let (_, c) = char_indices.next().unwrap();
+ let c_len = char_indices.next().map(|(len, _)| len).unwrap_or(rem.len());
+ self.pos += c_len;
+ if c == '\n' {
+ self.loc.line += 1;
+ self.loc.col = FIRST_COL;
+ } else {
+ self.loc.col += 1;
+ }
+ Some(c)
+ }
+ }
+
+ fn next_char(&mut self) -> LexerResult<char> {
+ self.next_char_opt().ok_or(LexerError::UnexpectedEof)
+ }
+
+ /// Skip whitespaces
+ fn skip_whitespaces(&mut self) {
+ self.take_while(|c| c.is_whitespace());
+ }
+
+ fn skip_c_comment(&mut self) -> LexerResult<()> {
+ if self.skip_if_lookahead_is_str("/*") {
+ let end = "*/";
+ match self.rem_chars().find(end) {
+ None => Err(LexerError::UnexpectedEof),
+ Some(len) => {
+ let new_pos = self.pos + len + end.len();
+ self.skip_to_pos(new_pos);
+ Ok(())
+ }
+ }
+ } else {
+ Ok(())
+ }
+ }
+
+ fn skip_cpp_comment(&mut self) {
+ if self.skip_if_lookahead_is_str("//") {
+ loop {
+ match self.next_char_opt() {
+ Some('\n') | None => break,
+ _ => {}
+ }
+ }
+ }
+ }
+
+ fn skip_sh_comment(&mut self) {
+ if self.skip_if_lookahead_is_str("#") {
+ loop {
+ match self.next_char_opt() {
+ Some('\n') | None => break,
+ _ => {}
+ }
+ }
+ }
+ }
+
+ fn skip_comment(&mut self) -> LexerResult<()> {
+ match self.language {
+ ParserLanguage::Proto => {
+ self.skip_c_comment()?;
+ self.skip_cpp_comment();
+ }
+ ParserLanguage::TextFormat => {
+ self.skip_sh_comment();
+ }
+ ParserLanguage::Json => {}
+ }
+ Ok(())
+ }
+
+ pub fn skip_ws(&mut self) -> LexerResult<()> {
+ loop {
+ let pos = self.pos;
+ self.skip_whitespaces();
+ self.skip_comment()?;
+ if pos == self.pos {
+ // Did not advance
+ return Ok(());
+ }
+ }
+ }
+
+ pub fn take_while<F>(&mut self, f: F) -> &'a str
+ where
+ F: Fn(char) -> bool,
+ {
+ let start = self.pos;
+ while self.lookahead_char().map(&f) == Some(true) {
+ self.next_char_opt().unwrap();
+ }
+ let end = self.pos;
+ &self.input[start..end]
+ }
+
+ fn lookahead_char(&self) -> Option<char> {
+ self.clone().next_char_opt()
+ }
+
+ fn lookahead_is_str(&self, s: &str) -> bool {
+ self.rem_chars().starts_with(s)
+ }
+
+ fn skip_if_lookahead_is_str(&mut self, s: &str) -> bool {
+ if self.lookahead_is_str(s) {
+ let new_pos = self.pos + s.len();
+ self.skip_to_pos(new_pos);
+ true
+ } else {
+ false
+ }
+ }
+
+ fn next_char_if<P>(&mut self, p: P) -> Option<char>
+ where
+ P: FnOnce(char) -> bool,
+ {
+ let mut clone = self.clone();
+ match clone.next_char_opt() {
+ Some(c) if p(c) => {
+ *self = clone;
+ Some(c)
+ }
+ _ => None,
+ }
+ }
+
+ pub fn next_char_if_eq(&mut self, expect: char) -> bool {
+ self.next_char_if(|c| c == expect) != None
+ }
+
+ fn next_char_if_in(&mut self, alphabet: &str) -> Option<char> {
+ for c in alphabet.chars() {
+ if self.next_char_if_eq(c) {
+ return Some(c);
+ }
+ }
+ None
+ }
+
+ fn next_char_expect_eq(&mut self, expect: char) -> LexerResult<()> {
+ if self.next_char_if_eq(expect) {
+ Ok(())
+ } else {
+ Err(LexerError::ExpectChar(expect))
+ }
+ }
+
+ fn next_char_expect<P>(&mut self, expect: P, err: LexerError) -> LexerResult<char>
+ where
+ P: FnOnce(char) -> bool,
+ {
+ self.next_char_if(expect).ok_or(err)
+ }
+
+ // str functions
+
+ /// properly update line and column
+ fn skip_to_pos(&mut self, new_pos: usize) -> &'a str {
+ assert!(new_pos >= self.pos);
+ assert!(new_pos <= self.input.len());
+ let pos = self.pos;
+ while self.pos != new_pos {
+ self.next_char_opt().unwrap();
+ }
+ &self.input[pos..new_pos]
+ }
+
+ // Protobuf grammar
+
+ // char functions
+
+ // letter = "A" … "Z" | "a" … "z"
+ // https://github.com/google/protobuf/issues/4565
+ fn next_letter_opt(&mut self) -> Option<char> {
+ self.next_char_if(is_letter)
+ }
+
+ // capitalLetter = "A" … "Z"
+ fn _next_capital_letter_opt(&mut self) -> Option<char> {
+ self.next_char_if(|c| c >= 'A' && c <= 'Z')
+ }
+
+ fn next_ident_part(&mut self) -> Option<char> {
+ self.next_char_if(|c| c.is_ascii_alphanumeric() || c == '_')
+ }
+
+ // Identifiers
+
+ // ident = letter { letter | decimalDigit | "_" }
+ fn next_ident_opt(&mut self) -> LexerResult<Option<String>> {
+ if let Some(c) = self.next_letter_opt() {
+ let mut ident = String::new();
+ ident.push(c);
+ while let Some(c) = self.next_ident_part() {
+ ident.push(c);
+ }
+ Ok(Some(ident))
+ } else {
+ Ok(None)
+ }
+ }
+
+ // Integer literals
+
+ // hexLit = "0" ( "x" | "X" ) hexDigit { hexDigit }
+ fn next_hex_lit_opt(&mut self) -> LexerResult<Option<u64>> {
+ Ok(
+ if self.skip_if_lookahead_is_str("0x") || self.skip_if_lookahead_is_str("0X") {
+ let s = self.take_while(|c| c.is_ascii_hexdigit());
+ Some(u64::from_str_radix(s, 16)? as u64)
+ } else {
+ None
+ },
+ )
+ }
+
+ // decimalLit = ( "1" … "9" ) { decimalDigit }
+ // octalLit = "0" { octalDigit }
+ fn next_decimal_octal_lit_opt(&mut self) -> LexerResult<Option<u64>> {
+ // do not advance on number parse error
+ let mut clone = self.clone();
+
+ let pos = clone.pos;
+
+ Ok(if clone.next_char_if(|c| c.is_ascii_digit()) != None {
+ clone.take_while(|c| c.is_ascii_digit());
+ let value = clone.input[pos..clone.pos].parse()?;
+ *self = clone;
+ Some(value)
+ } else {
+ None
+ })
+ }
+
+ // hexDigit = "0" … "9" | "A" … "F" | "a" … "f"
+ fn next_hex_digit(&mut self) -> LexerResult<u32> {
+ let mut clone = self.clone();
+ let r = match clone.next_char()? {
+ c if c >= '0' && c <= '9' => c as u32 - b'0' as u32,
+ c if c >= 'A' && c <= 'F' => c as u32 - b'A' as u32 + 10,
+ c if c >= 'a' && c <= 'f' => c as u32 - b'a' as u32 + 10,
+ _ => return Err(LexerError::ExpectHexDigit),
+ };
+ *self = clone;
+ Ok(r)
+ }
+
+ // octalDigit = "0" … "7"
+ fn next_octal_digit(&mut self) -> LexerResult<u32> {
+ self.next_char_expect(|c| c >= '0' && c <= '9', LexerError::ExpectOctDigit)
+ .map(|c| c as u32 - '0' as u32)
+ }
+
+ // decimalDigit = "0" … "9"
+ fn next_decimal_digit(&mut self) -> LexerResult<u32> {
+ self.next_char_expect(|c| c >= '0' && c <= '9', LexerError::ExpectDecDigit)
+ .map(|c| c as u32 - '0' as u32)
+ }
+
+ // decimals = decimalDigit { decimalDigit }
+ fn next_decimal_digits(&mut self) -> LexerResult<()> {
+ self.next_decimal_digit()?;
+ self.take_while(|c| c >= '0' && c <= '9');
+ Ok(())
+ }
+
+ // intLit = decimalLit | octalLit | hexLit
+ pub fn next_int_lit_opt(&mut self) -> LexerResult<Option<u64>> {
+ assert_ne!(ParserLanguage::Json, self.language);
+
+ self.skip_ws()?;
+ if let Some(i) = self.next_hex_lit_opt()? {
+ return Ok(Some(i));
+ }
+ if let Some(i) = self.next_decimal_octal_lit_opt()? {
+ return Ok(Some(i));
+ }
+ Ok(None)
+ }
+
+ // Floating-point literals
+
+ // exponent = ( "e" | "E" ) [ "+" | "-" ] decimals
+ fn next_exponent_opt(&mut self) -> LexerResult<Option<()>> {
+ if self.next_char_if_in("eE") != None {
+ self.next_char_if_in("+-");
+ self.next_decimal_digits()?;
+ Ok(Some(()))
+ } else {
+ Ok(None)
+ }
+ }
+
+ // floatLit = ( decimals "." [ decimals ] [ exponent ] | decimals exponent | "."decimals [ exponent ] ) | "inf" | "nan"
+ fn next_float_lit(&mut self) -> LexerResult<()> {
+ assert_ne!(ParserLanguage::Json, self.language);
+
+ // "inf" and "nan" are handled as part of ident
+ if self.next_char_if_eq('.') {
+ self.next_decimal_digits()?;
+ self.next_exponent_opt()?;
+ } else {
+ self.next_decimal_digits()?;
+ if self.next_char_if_eq('.') {
+ self.next_decimal_digits()?;
+ self.next_exponent_opt()?;
+ } else {
+ if self.next_exponent_opt()? == None {
+ return Err(LexerError::IncorrectFloatLit);
+ }
+ }
+ }
+ Ok(())
+ }
+
+ // String literals
+
+ // charValue = hexEscape | octEscape | charEscape | /[^\0\n\\]/
+ // hexEscape = '\' ( "x" | "X" ) hexDigit hexDigit
+ // https://github.com/google/protobuf/issues/4560
+ // octEscape = '\' octalDigit octalDigit octalDigit
+ // charEscape = '\' ( "a" | "b" | "f" | "n" | "r" | "t" | "v" | '\' | "'" | '"' )
+ // quote = "'" | '"'
+ pub fn next_byte_value(&mut self) -> LexerResult<u8> {
+ match self.next_char()? {
+ '\\' => {
+ match self.next_char()? {
+ '\'' => Ok(b'\''),
+ '"' => Ok(b'"'),
+ '\\' => Ok(b'\\'),
+ 'a' => Ok(b'\x07'),
+ 'b' => Ok(b'\x08'),
+ 'f' => Ok(b'\x0c'),
+ 'n' => Ok(b'\n'),
+ 'r' => Ok(b'\r'),
+ 't' => Ok(b'\t'),
+ 'v' => Ok(b'\x0b'),
+ 'x' => {
+ let d1 = self.next_hex_digit()? as u8;
+ let d2 = self.next_hex_digit()? as u8;
+ Ok(((d1 << 4) | d2) as u8)
+ }
+ d if d >= '0' && d <= '7' => {
+ let mut r = d as u8 - b'0';
+ for _ in 0..2 {
+ match self.next_octal_digit() {
+ Err(_) => break,
+ Ok(d) => r = (r << 3) + d as u8,
+ }
+ }
+ Ok(r)
+ }
+ // https://github.com/google/protobuf/issues/4562
+ // TODO: overflow
+ c => Ok(c as u8),
+ }
+ }
+ '\n' | '\0' => Err(LexerError::IncorrectInput),
+ // TODO: check overflow
+ c => Ok(c as u8),
+ }
+ }
+
+ fn char_try_from(i: u32) -> LexerResult<char> {
+ char::try_from(i).map_err(|_| LexerError::IncorrectUnicodeChar)
+ }
+
+ pub fn next_json_char_value(&mut self) -> LexerResult<char> {
+ match self.next_char()? {
+ '\\' => match self.next_char()? {
+ '"' => Ok('"'),
+ '\'' => Ok('\''),
+ '\\' => Ok('\\'),
+ '/' => Ok('/'),
+ 'b' => Ok('\x08'),
+ 'f' => Ok('\x0c'),
+ 'n' => Ok('\n'),
+ 'r' => Ok('\r'),
+ 't' => Ok('\t'),
+ 'u' => {
+ let mut v = 0;
+ for _ in 0..4 {
+ let digit = self.next_hex_digit()?;
+ v = v * 16 + digit;
+ }
+ Self::char_try_from(v)
+ }
+ _ => Err(LexerError::IncorrectJsonEscape),
+ },
+ c => Ok(c),
+ }
+ }
+
+ // https://github.com/google/protobuf/issues/4564
+ // strLit = ( "'" { charValue } "'" ) | ( '"' { charValue } '"' )
+ fn next_str_lit_raw(&mut self) -> LexerResult<String> {
+ let mut raw = String::new();
+
+ let mut first = true;
+ loop {
+ if !first {
+ self.skip_ws()?;
+ }
+
+ let start = self.pos;
+
+ let q = match self.next_char_if_in("'\"") {
+ Some(q) => q,
+ None if !first => break,
+ None => return Err(LexerError::IncorrectInput),
+ };
+ first = false;
+ while self.lookahead_char() != Some(q) {
+ self.next_byte_value()?;
+ }
+ self.next_char_expect_eq(q)?;
+
+ raw.push_str(&self.input[start + 1..self.pos - 1]);
+ }
+ Ok(raw)
+ }
+
+ fn next_str_lit_raw_opt(&mut self) -> LexerResult<Option<String>> {
+ if self.lookahead_char_is_in("'\"") {
+ Ok(Some(self.next_str_lit_raw()?))
+ } else {
+ Ok(None)
+ }
+ }
+
+ /// Parse next token as JSON number
+ fn next_json_number_opt(&mut self) -> LexerResult<Option<JsonNumberLit>> {
+ assert_eq!(ParserLanguage::Json, self.language);
+
+ fn is_digit(c: char) -> bool {
+ c >= '0' && c <= '9'
+ }
+
+ fn is_digit_1_9(c: char) -> bool {
+ c >= '1' && c <= '9'
+ }
+
+ if !self.lookahead_char_is_in("-0123456789") {
+ return Ok(None);
+ }
+
+ let mut s = String::new();
+ if self.next_char_if_eq('-') {
+ s.push('-');
+ }
+
+ if self.next_char_if_eq('0') {
+ s.push('0');
+ } else {
+ s.push(self.next_char_expect(is_digit_1_9, LexerError::IncorrectJsonNumber)?);
+ while let Some(c) = self.next_char_if(is_digit) {
+ s.push(c);
+ }
+ }
+
+ if self.next_char_if_eq('.') {
+ s.push('.');
+ s.push(self.next_char_expect(is_digit, LexerError::IncorrectJsonNumber)?);
+ while let Some(c) = self.next_char_if(is_digit) {
+ s.push(c);
+ }
+ }
+
+ if let Some(c) = self.next_char_if_in("eE") {
+ s.push(c);
+ if let Some(c) = self.next_char_if_in("+-") {
+ s.push(c);
+ }
+ s.push(self.next_char_expect(is_digit, LexerError::IncorrectJsonNumber)?);
+ while let Some(c) = self.next_char_if(is_digit) {
+ s.push(c);
+ }
+ }
+
+ Ok(Some(JsonNumberLit(s)))
+ }
+
+ fn next_token_inner(&mut self) -> LexerResult<Token> {
+ if self.language == ParserLanguage::Json {
+ if let Some(v) = self.next_json_number_opt()? {
+ return Ok(Token::JsonNumber(v));
+ }
+ }
+
+ if let Some(ident) = self.next_ident_opt()? {
+ let token = if self.language != ParserLanguage::Json && ident == float::PROTOBUF_NAN {
+ Token::FloatLit(f64::NAN)
+ } else if self.language != ParserLanguage::Json && ident == float::PROTOBUF_INF {
+ Token::FloatLit(f64::INFINITY)
+ } else {
+ Token::Ident(ident.to_owned())
+ };
+ return Ok(token);
+ }
+
+ if self.language != ParserLanguage::Json {
+ let mut clone = self.clone();
+ let pos = clone.pos;
+ if let Ok(_) = clone.next_float_lit() {
+ let f = float::parse_protobuf_float(&self.input[pos..clone.pos])?;
+ *self = clone;
+ return Ok(Token::FloatLit(f));
+ }
+
+ if let Some(lit) = self.next_int_lit_opt()? {
+ return Ok(Token::IntLit(lit));
+ }
+ }
+
+ if let Some(escaped) = self.next_str_lit_raw_opt()? {
+ return Ok(Token::StrLit(StrLit { escaped }));
+ }
+
+ // This branch must be after str lit
+ if let Some(c) = self.next_char_if(|c| c.is_ascii_punctuation()) {
+ return Ok(Token::Symbol(c));
+ }
+
+ if let Some(ident) = self.next_ident_opt()? {
+ return Ok(Token::Ident(ident));
+ }
+
+ Err(LexerError::IncorrectInput)
+ }
+
+ pub fn next_token(&mut self) -> LexerResult<Option<TokenWithLocation>> {
+ self.skip_ws()?;
+ let loc = self.loc;
+
+ Ok(if self.eof() {
+ None
+ } else {
+ let token = self.next_token_inner()?;
+ // Skip whitespace here to update location
+ // to the beginning of the next token
+ self.skip_ws()?;
+ Some(TokenWithLocation { token, loc })
+ })
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ fn lex<P, R>(input: &str, parse_what: P) -> R
+ where
+ P: FnOnce(&mut Lexer) -> LexerResult<R>,
+ {
+ let mut lexer = Lexer::new(input, ParserLanguage::Proto);
+ let r = parse_what(&mut lexer).expect(&format!("lexer failed at {}", lexer.loc));
+ assert!(lexer.eof(), "check eof failed at {}", lexer.loc);
+ r
+ }
+
+ fn lex_opt<P, R>(input: &str, parse_what: P) -> R
+ where
+ P: FnOnce(&mut Lexer) -> LexerResult<Option<R>>,
+ {
+ let mut lexer = Lexer::new(input, ParserLanguage::Proto);
+ let o = parse_what(&mut lexer).expect(&format!("lexer failed at {}", lexer.loc));
+ let r = o.expect(&format!("lexer returned none at {}", lexer.loc));
+ assert!(lexer.eof(), "check eof failed at {}", lexer.loc);
+ r
+ }
+
+ #[test]
+ fn test_lexer_int_lit() {
+ let msg = r#"10"#;
+ let mess = lex_opt(msg, |p| p.next_int_lit_opt());
+ assert_eq!(10, mess);
+ }
+
+ #[test]
+ fn test_lexer_float_lit() {
+ let msg = r#"12.3"#;
+ let mess = lex(msg, |p| p.next_token_inner());
+ assert_eq!(Token::FloatLit(12.3), mess);
+ }
+
+ #[test]
+ fn test_lexer_float_lit_leading_zeros_in_exp() {
+ let msg = r#"1e00009"#;
+ let mess = lex(msg, |p| p.next_token_inner());
+ assert_eq!(Token::FloatLit(1_000_000_000.0), mess);
+ }
+}
diff --git a/2.27.1/src/text_format/lexer/loc.rs b/2.27.1/src/text_format/lexer/loc.rs
new file mode 100644
index 0000000..ea3fc1a
--- /dev/null
+++ b/2.27.1/src/text_format/lexer/loc.rs
@@ -0,0 +1,28 @@
+use std::fmt;
+
+pub const FIRST_LINE: u32 = 1;
+pub const FIRST_COL: u32 = 1;
+
+/// Location in file
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub struct Loc {
+ /// 1-based
+ pub line: u32,
+ /// 1-based
+ pub col: u32,
+}
+
+impl fmt::Display for Loc {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{}:{}", self.line, self.col)
+ }
+}
+
+impl Loc {
+ pub fn start() -> Loc {
+ Loc {
+ line: FIRST_LINE,
+ col: FIRST_COL,
+ }
+ }
+}
diff --git a/2.27.1/src/text_format/lexer/mod.rs b/2.27.1/src/text_format/lexer/mod.rs
new file mode 100644
index 0000000..a7ed884
--- /dev/null
+++ b/2.27.1/src/text_format/lexer/mod.rs
@@ -0,0 +1,21 @@
+//! Implementation of lexer for both protobuf parser and for text format parser.
+
+pub mod float;
+mod json_number_lit;
+mod lexer_impl;
+mod loc;
+mod num_lit;
+mod parser_language;
+mod str_lit;
+mod token;
+
+pub use self::json_number_lit::JsonNumberLit;
+pub use self::lexer_impl::Lexer;
+pub use self::lexer_impl::LexerError;
+pub use self::loc::Loc;
+pub use self::num_lit::NumLit;
+pub use self::parser_language::ParserLanguage;
+pub use self::str_lit::StrLit;
+pub use self::str_lit::StrLitDecodeError;
+pub use self::token::Token;
+pub use self::token::TokenWithLocation;
diff --git a/2.27.1/src/text_format/lexer/num_lit.rs b/2.27.1/src/text_format/lexer/num_lit.rs
new file mode 100644
index 0000000..cc64cc4
--- /dev/null
+++ b/2.27.1/src/text_format/lexer/num_lit.rs
@@ -0,0 +1,5 @@
+#[derive(Copy, Clone)]
+pub enum NumLit {
+ U64(u64),
+ F64(f64),
+}
diff --git a/2.27.1/src/text_format/lexer/parser_language.rs b/2.27.1/src/text_format/lexer/parser_language.rs
new file mode 100644
index 0000000..e356571
--- /dev/null
+++ b/2.27.1/src/text_format/lexer/parser_language.rs
@@ -0,0 +1,10 @@
+/// We use the same lexer/tokenizer for all parsers for simplicity
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum ParserLanguage {
+ // `.proto` files
+ Proto,
+ // Protobuf text format
+ TextFormat,
+ // JSON
+ Json,
+}
diff --git a/2.27.1/src/text_format/lexer/str_lit.rs b/2.27.1/src/text_format/lexer/str_lit.rs
new file mode 100644
index 0000000..15ffa5b
--- /dev/null
+++ b/2.27.1/src/text_format/lexer/str_lit.rs
@@ -0,0 +1,86 @@
+use std::fmt;
+use std::string::FromUtf8Error;
+
+use super::lexer_impl::Lexer;
+use super::lexer_impl::LexerError;
+use crate::text_format::lexer::ParserLanguage;
+
+#[derive(Debug)]
+pub enum StrLitDecodeError {
+ FromUtf8Error(FromUtf8Error),
+ // TODO: be more specific
+ OtherError,
+}
+
+impl fmt::Display for StrLitDecodeError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ StrLitDecodeError::FromUtf8Error(e) => write!(f, "{}", e),
+ StrLitDecodeError::OtherError => write!(f, "String literal decode error"),
+ }
+ }
+}
+
+impl std::error::Error for StrLitDecodeError {}
+
+impl From<LexerError> for StrLitDecodeError {
+ fn from(_: LexerError) -> Self {
+ StrLitDecodeError::OtherError
+ }
+}
+
+impl From<FromUtf8Error> for StrLitDecodeError {
+ fn from(e: FromUtf8Error) -> Self {
+ StrLitDecodeError::FromUtf8Error(e)
+ }
+}
+
+pub type StrLitDecodeResult<T> = Result<T, StrLitDecodeError>;
+
+/// String literal, both `string` and `bytes`.
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct StrLit {
+ pub escaped: String,
+}
+
+impl StrLit {
+ /// May fail if not valid UTF8
+ pub fn decode_utf8(&self) -> StrLitDecodeResult<String> {
+ let mut lexer = Lexer::new(&self.escaped, ParserLanguage::Json);
+ let mut r = Vec::new();
+ while !lexer.eof() {
+ r.push(lexer.next_byte_value()?);
+ }
+ Ok(String::from_utf8(r)?)
+ }
+
+ pub fn decode_bytes(&self) -> StrLitDecodeResult<Vec<u8>> {
+ let mut lexer = Lexer::new(&self.escaped, ParserLanguage::Json);
+ let mut r = Vec::new();
+ while !lexer.eof() {
+ r.push(lexer.next_byte_value()?);
+ }
+ Ok(r)
+ }
+
+ pub fn quoted(&self) -> String {
+ format!("\"{}\"", self.escaped)
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use crate::text_format::lexer::StrLit;
+
+ #[test]
+ fn decode_utf8() {
+ assert_eq!(
+ "\u{1234}".to_owned(),
+ StrLit {
+ escaped: "\\341\\210\\264".to_owned()
+ }
+ .decode_utf8()
+ .unwrap()
+ )
+ }
+}
diff --git a/2.27.1/src/text_format/lexer/token.rs b/2.27.1/src/text_format/lexer/token.rs
new file mode 100644
index 0000000..55d931a
--- /dev/null
+++ b/2.27.1/src/text_format/lexer/token.rs
@@ -0,0 +1,47 @@
+use super::lexer_impl::LexerError;
+use super::lexer_impl::LexerResult;
+use super::loc::Loc;
+use super::num_lit::NumLit;
+use super::str_lit::StrLit;
+use crate::text_format::lexer::JsonNumberLit;
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Token {
+ Ident(String),
+ Symbol(char),
+ // Protobuf tokenizer has separate tokens for int and float.
+ // Tokens do not include sign.
+ IntLit(u64),
+ FloatLit(f64),
+ JsonNumber(JsonNumberLit),
+ // including quotes
+ StrLit(StrLit),
+}
+
+impl Token {
+ /// Back to original
+ pub fn format(&self) -> String {
+ match self {
+ &Token::Ident(ref s) => s.clone(),
+ &Token::Symbol(c) => c.to_string(),
+ &Token::IntLit(ref i) => i.to_string(),
+ &Token::StrLit(ref s) => s.quoted(),
+ &Token::FloatLit(ref f) => f.to_string(),
+ &Token::JsonNumber(ref f) => f.to_string(),
+ }
+ }
+
+ pub fn to_num_lit(&self) -> LexerResult<NumLit> {
+ match self {
+ &Token::IntLit(i) => Ok(NumLit::U64(i)),
+ &Token::FloatLit(f) => Ok(NumLit::F64(f)),
+ _ => Err(LexerError::IncorrectInput),
+ }
+ }
+}
+
+#[derive(Clone)]
+pub struct TokenWithLocation {
+ pub token: Token,
+ pub loc: Loc,
+}
diff --git a/2.27.1/src/text_format/mod.rs b/2.27.1/src/text_format/mod.rs
new file mode 100644
index 0000000..2fa9a16
--- /dev/null
+++ b/2.27.1/src/text_format/mod.rs
@@ -0,0 +1,307 @@
+//! 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 std;
+use std::fmt;
+use std::fmt::Write;
+
+use crate::message::Message;
+use crate::reflect::ReflectFieldRef;
+use crate::reflect::ReflectValueRef;
+
+mod print;
+
+// Used by text format parser and by pure-rust codegen parsed
+// this it is public but hidden module.
+// https://github.com/rust-lang/rust/issues/44663
+#[doc(hidden)]
+pub mod lexer;
+
+use self::print::print_str_to;
+#[doc(hidden)]
+pub use self::print::quote_bytes_to;
+#[doc(hidden)]
+pub use self::print::quote_escape_bytes;
+use crate::text_format::print::quote_escape_bytes_to;
+
+#[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 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: &dyn 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: &dyn Message, buf: &mut String) {
+ print_to_internal(m, buf, false, 0)
+}
+
+fn print_to_string_internal(m: &dyn 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: &dyn Message) -> String {
+ print_to_string_internal(m, false)
+}
+
+/// Text-format to `fmt::Formatter`.
+pub fn fmt(m: &dyn 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/2.27.1/src/text_format/print.rs b/2.27.1/src/text_format/print.rs
new file mode 100644
index 0000000..397e8cd
--- /dev/null
+++ b/2.27.1/src/text_format/print.rs
@@ -0,0 +1,38 @@
+#[doc(hidden)]
+pub 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("\\\""),
+ 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);
+ }
+ }
+ }
+}
+
+pub(crate) 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
+}
+
+pub(crate) fn print_str_to(s: &str, buf: &mut String) {
+ // TODO: keep printable Unicode
+ quote_escape_bytes_to(s.as_bytes(), buf);
+}
diff --git a/2.27.1/src/types.rs b/2.27.1/src/types.rs
new file mode 100644
index 0000000..20244a1
--- /dev/null
+++ b/2.27.1/src/types.rs
@@ -0,0 +1,684 @@
+//! Implementations of `ProtobufType` for all types.
+
+use std::marker;
+use std::mem;
+
+#[cfg(feature = "bytes")]
+use bytes::Bytes;
+
+#[cfg(feature = "bytes")]
+use crate::chars::Chars;
+use crate::coded_input_stream::CodedInputStream;
+use crate::coded_output_stream::CodedOutputStream;
+use crate::enums::ProtobufEnum;
+use crate::error::ProtobufResult;
+use crate::message::Message;
+use crate::reflect::ProtobufValue;
+use crate::rt;
+use crate::unknown::UnknownValues;
+use crate::wire_format::WireType;
+use crate::zigzag::decode_zig_zag_32;
+use crate::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| M::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/2.27.1/src/unknown.rs b/2.27.1/src/unknown.rs
new file mode 100644
index 0000000..dd67033
--- /dev/null
+++ b/2.27.1/src/unknown.rs
@@ -0,0 +1,363 @@
+use std::collections::hash_map;
+use std::collections::hash_map::DefaultHasher;
+use std::collections::HashMap;
+use std::default::Default;
+use std::hash::BuildHasherDefault;
+use std::hash::Hash;
+use std::hash::Hasher;
+use std::slice;
+
+use crate::clear::Clear;
+use crate::wire_format;
+use crate::zigzag::encode_zig_zag_32;
+use crate::zigzag::encode_zig_zag_64;
+
+/// Unknown value.
+///
+/// See [`UnknownFields`](crate::UnknownFields) for the explanations.
+#[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.
+ //
+ // We use "default hasher" to make iteration order deterministic.
+ // Which is used to make codegen output deterministic in presence of unknown fields
+ // (e. g. file options are represented as unknown fields).
+ // Using default hasher is suboptimal, because it makes unknown fields less safe.
+ // Note, Google Protobuf C++ simply uses linear map (which can exploitable the same way),
+ // and Google Protobuf Java uses tree map to store unknown fields
+ // (which is more expensive than hashmap).
+ // TODO: hide
+ pub fields: Option<Box<HashMap<u32, UnknownValues, BuildHasherDefault<DefaultHasher>>>>,
+}
+
+/// 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);
+ }
+
+ /// Remove unknown field by number
+ pub fn remove(&mut self, field_number: u32) {
+ if let Some(fields) = &mut self.fields {
+ fields.remove(&field_number);
+ }
+ }
+
+ /// 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 std::collections::hash_map::DefaultHasher;
+ use std::hash::Hash;
+ use std::hash::Hasher;
+
+ use super::UnknownFields;
+
+ #[test]
+ fn unknown_fields_hash() {
+ let mut unknown_fields_1 = UnknownFields::new();
+ 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));
+ }
+
+ #[test]
+ fn unknown_fields_iteration_order_deterministic() {
+ let mut u_1 = UnknownFields::new();
+ let mut u_2 = UnknownFields::new();
+ for u in &mut [&mut u_1, &mut u_2] {
+ u.add_fixed32(10, 20);
+ u.add_varint(30, 40);
+ u.add_fixed64(50, 60);
+ u.add_length_delimited(70, Vec::new());
+ u.add_varint(80, 90);
+ u.add_fixed32(11, 22);
+ u.add_fixed64(33, 44);
+ }
+
+ let items_1: Vec<_> = u_1.iter().collect();
+ let items_2: Vec<_> = u_2.iter().collect();
+ assert_eq!(items_1, items_2);
+ }
+}
diff --git a/2.27.1/src/varint.rs b/2.27.1/src/varint.rs
new file mode 100644
index 0000000..8e542bc
--- /dev/null
+++ b/2.27.1/src/varint.rs
@@ -0,0 +1,39 @@
+use std::mem::MaybeUninit;
+
+use crate::misc::maybe_uninit_write;
+
+/// Encode u64 as varint.
+/// Panics if buffer length is less than 10.
+#[inline]
+pub fn encode_varint64(mut value: u64, buf: &mut [MaybeUninit<u8>]) -> usize {
+ assert!(buf.len() >= 10);
+
+ unsafe {
+ let mut i = 0;
+ while (value & !0x7F) > 0 {
+ maybe_uninit_write(buf.get_unchecked_mut(i), ((value & 0x7F) | 0x80) as u8);
+ value >>= 7;
+ i += 1;
+ }
+ maybe_uninit_write(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 [MaybeUninit<u8>]) -> usize {
+ assert!(buf.len() >= 5);
+
+ unsafe {
+ let mut i = 0;
+ while (value & !0x7F) > 0 {
+ maybe_uninit_write(buf.get_unchecked_mut(i), ((value & 0x7F) | 0x80) as u8);
+ value >>= 7;
+ i += 1;
+ }
+ maybe_uninit_write(buf.get_unchecked_mut(i), value as u8);
+ i + 1
+ }
+}
diff --git a/2.27.1/src/well_known_types/any.rs b/2.27.1/src/well_known_types/any.rs
new file mode 100644
index 0000000..e46065f
--- /dev/null
+++ b/2.27.1/src/well_known_types/any.rs
@@ -0,0 +1,374 @@
+// This file is generated by rust-protobuf 2.26.0. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(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(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `google/protobuf/any.proto`
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::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: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Any {
+ fn default() -> &'a Any {
+ <Any as crate::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 crate::Message for Any {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.type_url)?;
+ },
+ 2 => {
+ crate::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &self.type_url);
+ }
+ if !self.value.is_empty() {
+ my_size += crate::rt::bytes_size(2, &self.value);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Any {
+ Any::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "type_url",
+ |m: &Any| { &m.type_url },
+ |m: &mut Any| { &mut m.type_url },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeBytes>(
+ "value",
+ |m: &Any| { &m.value },
+ |m: &mut Any| { &mut m.value },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Any>(
+ "Any",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Any {
+ static instance: crate::rt::LazyV2<Any> = crate::rt::LazyV2::INIT;
+ instance.get(Any::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Any {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::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\x05valueBv\n\x13com.google.protobufB\x08AnyProtoP\x01\
+ Z,google.golang.org/protobuf/types/known/anypb\xa2\x02\x03GPB\xaa\x02\
+ \x1eGoogle.Protobuf.WellKnownTypesJ\xf9*\n\x07\x12\x05\x1e\0\x9d\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\x20200\
+ 8\x20Google\x20Inc.\x20\x20All\x20rights\x20reserved.\n\x20https://devel\
+ opers.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#\0C\n\t\n\x02\x08\x0b\x12\x03#\0C\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\xfd\x10\n\x02\x04\0\x12\x05|\0\x9d\x01\x01\x1a\xef\x10\
+ \x20`Any`\x20contains\x20an\x20arbitrary\x20serialized\x20protocol\x20bu\
+ ffer\x20message\x20along\x20with\x20a\n\x20URL\x20that\x20describes\x20t\
+ he\x20type\x20of\x20the\x20serialized\x20message.\n\n\x20Protobuf\x20lib\
+ rary\x20provides\x20support\x20to\x20pack/unpack\x20Any\x20values\x20in\
+ \x20the\x20form\n\x20of\x20utility\x20functions\x20or\x20additional\x20g\
+ enerated\x20methods\x20of\x20the\x20Any\x20type.\n\n\x20Example\x201:\
+ \x20Pack\x20and\x20unpack\x20a\x20message\x20in\x20C++.\n\n\x20\x20\x20\
+ \x20\x20Foo\x20foo\x20=\x20...;\n\x20\x20\x20\x20\x20Any\x20any;\n\x20\
+ \x20\x20\x20\x20any.PackFrom(foo);\n\x20\x20\x20\x20\x20...\n\x20\x20\
+ \x20\x20\x20if\x20(any.UnpackTo(&foo))\x20{\n\x20\x20\x20\x20\x20\x20\
+ \x20...\n\x20\x20\x20\x20\x20}\n\n\x20Example\x202:\x20Pack\x20and\x20un\
+ pack\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\x20Python.\n\n\x20\x20\x20\x20\x20foo\x20=\x20Foo\
+ (...)\n\x20\x20\x20\x20\x20any\x20=\x20Any()\n\x20\x20\x20\x20\x20any.Pa\
+ ck(foo)\n\x20\x20\x20\x20\x20...\n\x20\x20\x20\x20\x20if\x20any.Is(Foo.D\
+ ESCRIPTOR):\n\x20\x20\x20\x20\x20\x20\x20any.Unpack(foo)\n\x20\x20\x20\
+ \x20\x20\x20\x20...\n\n\x20\x20Example\x204:\x20Pack\x20and\x20unpack\
+ \x20a\x20message\x20in\x20Go\n\n\x20\x20\x20\x20\x20\x20foo\x20:=\x20&pb\
+ .Foo{...}\n\x20\x20\x20\x20\x20\x20any,\x20err\x20:=\x20anypb.New(foo)\n\
+ \x20\x20\x20\x20\x20\x20if\x20err\x20!=\x20nil\x20{\n\x20\x20\x20\x20\
+ \x20\x20\x20\x20...\n\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\
+ ...\n\x20\x20\x20\x20\x20\x20foo\x20:=\x20&pb.Foo{}\n\x20\x20\x20\x20\
+ \x20\x20if\x20err\x20:=\x20any.UnmarshalTo(foo);\x20err\x20!=\x20nil\x20\
+ {\n\x20\x20\x20\x20\x20\x20\x20\x20...\n\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\x03|\x08\x0b\n\xd7\n\n\x04\x04\0\x02\0\x12\x04\x99\
+ \x01\x02\x16\x1a\xc8\n\x20A\x20URL/resource\x20name\x20that\x20uniquely\
+ \x20identifies\x20the\x20type\x20of\x20the\x20serialized\n\x20protocol\
+ \x20buffer\x20message.\x20This\x20string\x20must\x20contain\x20at\x20lea\
+ st\n\x20one\x20\"/\"\x20character.\x20The\x20last\x20segment\x20of\x20th\
+ e\x20URL's\x20path\x20must\x20represent\n\x20the\x20fully\x20qualified\
+ \x20name\x20of\x20the\x20type\x20(as\x20in\n\x20`path/google.protobuf.Du\
+ ration`).\x20The\x20name\x20should\x20be\x20in\x20a\x20canonical\x20form\
+ \n\x20(e.g.,\x20leading\x20\".\"\x20is\x20not\x20accepted).\n\n\x20In\
+ \x20practice,\x20teams\x20usually\x20precompile\x20into\x20the\x20binary\
+ \x20all\x20types\x20that\x20they\n\x20expect\x20it\x20to\x20use\x20in\
+ \x20the\x20context\x20of\x20Any.\x20However,\x20for\x20URLs\x20which\x20\
+ use\x20the\n\x20scheme\x20`http`,\x20`https`,\x20or\x20no\x20scheme,\x20\
+ one\x20can\x20optionally\x20set\x20up\x20a\x20type\n\x20server\x20that\
+ \x20maps\x20type\x20URLs\x20to\x20message\x20definitions\x20as\x20follow\
+ s:\n\n\x20*\x20If\x20no\x20scheme\x20is\x20provided,\x20`https`\x20is\
+ \x20assumed.\n\x20*\x20An\x20HTTP\x20GET\x20on\x20the\x20URL\x20must\x20\
+ yield\x20a\x20[google.protobuf.Type][]\n\x20\x20\x20value\x20in\x20binar\
+ y\x20format,\x20or\x20produce\x20an\x20error.\n\x20*\x20Applications\x20\
+ are\x20allowed\x20to\x20cache\x20lookup\x20results\x20based\x20on\x20the\
+ \n\x20\x20\x20URL,\x20or\x20have\x20them\x20precompiled\x20into\x20a\x20\
+ binary\x20to\x20avoid\x20any\n\x20\x20\x20lookup.\x20Therefore,\x20binar\
+ y\x20compatibility\x20needs\x20to\x20be\x20preserved\n\x20\x20\x20on\x20\
+ changes\x20to\x20types.\x20(Use\x20versioned\x20type\x20names\x20to\x20m\
+ anage\n\x20\x20\x20breaking\x20changes.)\n\n\x20Note:\x20this\x20functio\
+ nality\x20is\x20not\x20currently\x20available\x20in\x20the\x20official\n\
+ \x20protobuf\x20release,\x20and\x20it\x20is\x20not\x20used\x20for\x20typ\
+ e\x20URLs\x20beginning\x20with\n\x20type.googleapis.com.\n\n\x20Schemes\
+ \x20other\x20than\x20`http`,\x20`https`\x20(or\x20the\x20empty\x20scheme\
+ )\x20might\x20be\n\x20used\x20with\x20implementation\x20specific\x20sema\
+ ntics.\n\n\n\r\n\x05\x04\0\x02\0\x05\x12\x04\x99\x01\x02\x08\n\r\n\x05\
+ \x04\0\x02\0\x01\x12\x04\x99\x01\t\x11\n\r\n\x05\x04\0\x02\0\x03\x12\x04\
+ \x99\x01\x14\x15\nW\n\x04\x04\0\x02\x01\x12\x04\x9c\x01\x02\x12\x1aI\x20\
+ Must\x20be\x20a\x20valid\x20serialized\x20protocol\x20buffer\x20of\x20th\
+ e\x20above\x20specified\x20type.\n\n\r\n\x05\x04\0\x02\x01\x05\x12\x04\
+ \x9c\x01\x02\x07\n\r\n\x05\x04\0\x02\x01\x01\x12\x04\x9c\x01\x08\r\n\r\n\
+ \x05\x04\0\x02\x01\x03\x12\x04\x9c\x01\x10\x11b\x06proto3\
+";
+
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+ crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
+ file_descriptor_proto_lazy.get(|| {
+ parse_descriptor_proto()
+ })
+}
diff --git a/2.27.1/src/well_known_types/api.rs b/2.27.1/src/well_known_types/api.rs
new file mode 100644
index 0000000..ef97015
--- /dev/null
+++ b/2.27.1/src/well_known_types/api.rs
@@ -0,0 +1,1292 @@
+// This file is generated by rust-protobuf 2.26.0. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(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(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `google/protobuf/api.proto`
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct Api {
+ // message fields
+ pub name: ::std::string::String,
+ pub methods: crate::RepeatedField<Method>,
+ pub options: crate::RepeatedField<crate::well_known_types::Option>,
+ pub version: ::std::string::String,
+ pub source_context: crate::SingularPtrField<crate::well_known_types::SourceContext>,
+ pub mixins: crate::RepeatedField<Mixin>,
+ pub syntax: crate::well_known_types::Syntax,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Api {
+ fn default() -> &'a Api {
+ <Api as crate::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: crate::RepeatedField<Method>) {
+ self.methods = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_methods(&mut self) -> &mut crate::RepeatedField<Method> {
+ &mut self.methods
+ }
+
+ // Take field
+ pub fn take_methods(&mut self) -> crate::RepeatedField<Method> {
+ ::std::mem::replace(&mut self.methods, crate::RepeatedField::new())
+ }
+
+ // repeated .google.protobuf.Option options = 3;
+
+
+ pub fn get_options(&self) -> &[crate::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: crate::RepeatedField<crate::well_known_types::Option>) {
+ self.options = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_options(&mut self) -> &mut crate::RepeatedField<crate::well_known_types::Option> {
+ &mut self.options
+ }
+
+ // Take field
+ pub fn take_options(&mut self) -> crate::RepeatedField<crate::well_known_types::Option> {
+ ::std::mem::replace(&mut self.options, crate::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) -> &crate::well_known_types::SourceContext {
+ self.source_context.as_ref().unwrap_or_else(|| <crate::well_known_types::SourceContext as crate::Message>::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: crate::well_known_types::SourceContext) {
+ self.source_context = crate::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 crate::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) -> crate::well_known_types::SourceContext {
+ self.source_context.take().unwrap_or_else(|| crate::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: crate::RepeatedField<Mixin>) {
+ self.mixins = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_mixins(&mut self) -> &mut crate::RepeatedField<Mixin> {
+ &mut self.mixins
+ }
+
+ // Take field
+ pub fn take_mixins(&mut self) -> crate::RepeatedField<Mixin> {
+ ::std::mem::replace(&mut self.mixins, crate::RepeatedField::new())
+ }
+
+ // .google.protobuf.Syntax syntax = 7;
+
+
+ pub fn get_syntax(&self) -> crate::well_known_types::Syntax {
+ self.syntax
+ }
+ pub fn clear_syntax(&mut self) {
+ self.syntax = crate::well_known_types::Syntax::SYNTAX_PROTO2;
+ }
+
+ // Param is passed by value, moved
+ pub fn set_syntax(&mut self, v: crate::well_known_types::Syntax) {
+ self.syntax = v;
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.methods)?;
+ },
+ 3 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
+ },
+ 4 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.version)?;
+ },
+ 5 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.source_context)?;
+ },
+ 6 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.mixins)?;
+ },
+ 7 => {
+ crate::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 7, &mut self.unknown_fields)?
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &self.name);
+ }
+ for value in &self.methods {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ for value in &self.options {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ if !self.version.is_empty() {
+ my_size += crate::rt::string_size(4, &self.version);
+ }
+ if let Some(ref v) = self.source_context.as_ref() {
+ let len = v.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ for value in &self.mixins {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ if self.syntax != crate::well_known_types::Syntax::SYNTAX_PROTO2 {
+ my_size += crate::rt::enum_size(7, self.syntax);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if !self.name.is_empty() {
+ os.write_string(1, &self.name)?;
+ }
+ for v in &self.methods {
+ os.write_tag(2, crate::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, crate::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, crate::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, crate::wire_format::WireTypeLengthDelimited)?;
+ os.write_raw_varint32(v.get_cached_size())?;
+ v.write_to_with_cached_sizes(os)?;
+ };
+ if self.syntax != crate::well_known_types::Syntax::SYNTAX_PROTO2 {
+ os.write_enum(7, crate::ProtobufEnum::value(&self.syntax))?;
+ }
+ 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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Api {
+ Api::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &Api| { &m.name },
+ |m: &mut Api| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Method>>(
+ "methods",
+ |m: &Api| { &m.methods },
+ |m: &mut Api| { &mut m.methods },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::well_known_types::Option>>(
+ "options",
+ |m: &Api| { &m.options },
+ |m: &mut Api| { &mut m.options },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "version",
+ |m: &Api| { &m.version },
+ |m: &mut Api| { &mut m.version },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::well_known_types::SourceContext>>(
+ "source_context",
+ |m: &Api| { &m.source_context },
+ |m: &mut Api| { &mut m.source_context },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Mixin>>(
+ "mixins",
+ |m: &Api| { &m.mixins },
+ |m: &mut Api| { &mut m.mixins },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeEnum<crate::well_known_types::Syntax>>(
+ "syntax",
+ |m: &Api| { &m.syntax },
+ |m: &mut Api| { &mut m.syntax },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Api>(
+ "Api",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Api {
+ static instance: crate::rt::LazyV2<Api> = crate::rt::LazyV2::INIT;
+ instance.get(Api::new)
+ }
+}
+
+impl crate::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 = crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Api {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::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: crate::RepeatedField<crate::well_known_types::Option>,
+ pub syntax: crate::well_known_types::Syntax,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Method {
+ fn default() -> &'a Method {
+ <Method as crate::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) -> &[crate::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: crate::RepeatedField<crate::well_known_types::Option>) {
+ self.options = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_options(&mut self) -> &mut crate::RepeatedField<crate::well_known_types::Option> {
+ &mut self.options
+ }
+
+ // Take field
+ pub fn take_options(&mut self) -> crate::RepeatedField<crate::well_known_types::Option> {
+ ::std::mem::replace(&mut self.options, crate::RepeatedField::new())
+ }
+
+ // .google.protobuf.Syntax syntax = 7;
+
+
+ pub fn get_syntax(&self) -> crate::well_known_types::Syntax {
+ self.syntax
+ }
+ pub fn clear_syntax(&mut self) {
+ self.syntax = crate::well_known_types::Syntax::SYNTAX_PROTO2;
+ }
+
+ // Param is passed by value, moved
+ pub fn set_syntax(&mut self, v: crate::well_known_types::Syntax) {
+ self.syntax = v;
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.request_type_url)?;
+ },
+ 3 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.request_streaming = tmp;
+ },
+ 4 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.response_type_url)?;
+ },
+ 5 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.response_streaming = tmp;
+ },
+ 6 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
+ },
+ 7 => {
+ crate::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 7, &mut self.unknown_fields)?
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &self.name);
+ }
+ if !self.request_type_url.is_empty() {
+ my_size += crate::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 += crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ if self.syntax != crate::well_known_types::Syntax::SYNTAX_PROTO2 {
+ my_size += crate::rt::enum_size(7, self.syntax);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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, crate::wire_format::WireTypeLengthDelimited)?;
+ os.write_raw_varint32(v.get_cached_size())?;
+ v.write_to_with_cached_sizes(os)?;
+ };
+ if self.syntax != crate::well_known_types::Syntax::SYNTAX_PROTO2 {
+ os.write_enum(7, crate::ProtobufEnum::value(&self.syntax))?;
+ }
+ 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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Method {
+ Method::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &Method| { &m.name },
+ |m: &mut Method| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "request_type_url",
+ |m: &Method| { &m.request_type_url },
+ |m: &mut Method| { &mut m.request_type_url },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeBool>(
+ "request_streaming",
+ |m: &Method| { &m.request_streaming },
+ |m: &mut Method| { &mut m.request_streaming },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "response_type_url",
+ |m: &Method| { &m.response_type_url },
+ |m: &mut Method| { &mut m.response_type_url },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeBool>(
+ "response_streaming",
+ |m: &Method| { &m.response_streaming },
+ |m: &mut Method| { &mut m.response_streaming },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::well_known_types::Option>>(
+ "options",
+ |m: &Method| { &m.options },
+ |m: &mut Method| { &mut m.options },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeEnum<crate::well_known_types::Syntax>>(
+ "syntax",
+ |m: &Method| { &m.syntax },
+ |m: &mut Method| { &mut m.syntax },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Method>(
+ "Method",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Method {
+ static instance: crate::rt::LazyV2<Method> = crate::rt::LazyV2::INIT;
+ instance.get(Method::new)
+ }
+}
+
+impl crate::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 = crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Method {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::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: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Mixin {
+ fn default() -> &'a Mixin {
+ <Mixin as crate::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 crate::Message for Mixin {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.root)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &self.name);
+ }
+ if !self.root.is_empty() {
+ my_size += crate::rt::string_size(2, &self.root);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Mixin {
+ Mixin::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &Mixin| { &m.name },
+ |m: &mut Mixin| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "root",
+ |m: &Mixin| { &m.root },
+ |m: &mut Mixin| { &mut m.root },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Mixin>(
+ "Mixin",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Mixin {
+ static instance: crate::rt::LazyV2<Mixin> = crate::rt::LazyV2::INIT;
+ instance.get(Mixin::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Mixin {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::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\x04rootBv\n\x13com.google.protobu\
+ fB\x08ApiProtoP\x01Z,google.golang.org/protobuf/types/known/apipb\xa2\
+ \x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesJ\x81<\n\x07\x12\
+ \x05\x1e\0\xcf\x01\x01\n\xcc\x0c\n\x01\x0c\x12\x03\x1e\0\x122\xc1\x0c\
+ \x20Protocol\x20Buffers\x20-\x20Google's\x20data\x20interchange\x20forma\
+ t\n\x20Copyright\x202008\x20Google\x20Inc.\x20\x20All\x20rights\x20reser\
+ ved.\n\x20https://developers.google.com/protocol-buffers/\n\n\x20Redistr\
+ ibution\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\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!\n\x08\n\x01\x08\x12\x03*\0C\n\t\n\x02\x08\
+ \x0b\x12\x03*\0C\n\xab\x04\n\x02\x04\0\x12\x045\0`\x01\x1a\x9e\x04\x20Ap\
+ i\x20is\x20a\x20light-weight\x20descriptor\x20for\x20an\x20API\x20Interf\
+ ace.\n\n\x20Interfaces\x20are\x20also\x20described\x20as\x20\"protocol\
+ \x20buffer\x20services\"\x20in\x20some\x20contexts,\n\x20such\x20as\x20b\
+ y\x20the\x20\"service\"\x20keyword\x20in\x20a\x20.proto\x20file,\x20but\
+ \x20they\x20are\x20different\n\x20from\x20API\x20Services,\x20which\x20r\
+ epresent\x20a\x20concrete\x20implementation\x20of\x20an\x20interface\n\
+ \x20as\x20opposed\x20to\x20simply\x20a\x20description\x20of\x20methods\
+ \x20and\x20bindings.\x20They\x20are\x20also\n\x20sometimes\x20simply\x20\
+ referred\x20to\x20as\x20\"APIs\"\x20in\x20other\x20contexts,\x20such\x20\
+ as\x20the\x20name\x20of\n\x20this\x20message\x20itself.\x20See\x20https:\
+ //cloud.google.com/apis/design/glossary\x20for\n\x20detailed\x20terminol\
+ ogy.\n\n\n\n\x03\x04\0\x01\x12\x035\x08\x0b\n{\n\x04\x04\0\x02\0\x12\x03\
+ 8\x02\x12\x1an\x20The\x20fully\x20qualified\x20name\x20of\x20this\x20int\
+ erface,\x20including\x20package\x20name\n\x20followed\x20by\x20the\x20in\
+ terface's\x20simple\x20name.\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x038\x02\
+ \x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x038\t\r\n\x0c\n\x05\x04\0\x02\0\
+ \x03\x12\x038\x10\x11\nC\n\x04\x04\0\x02\x01\x12\x03;\x02\x1e\x1a6\x20Th\
+ e\x20methods\x20of\x20this\x20interface,\x20in\x20unspecified\x20order.\
+ \n\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x03;\x02\n\n\x0c\n\x05\x04\0\x02\
+ \x01\x06\x12\x03;\x0b\x11\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03;\x12\x19\
+ \n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03;\x1c\x1d\n6\n\x04\x04\0\x02\x02\
+ \x12\x03>\x02\x1e\x1a)\x20Any\x20metadata\x20attached\x20to\x20the\x20in\
+ terface.\n\n\x0c\n\x05\x04\0\x02\x02\x04\x12\x03>\x02\n\n\x0c\n\x05\x04\
+ \0\x02\x02\x06\x12\x03>\x0b\x11\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03>\
+ \x12\x19\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03>\x1c\x1d\n\x82\x08\n\x04\
+ \x04\0\x02\x03\x12\x03U\x02\x15\x1a\xf4\x07\x20A\x20version\x20string\
+ \x20for\x20this\x20interface.\x20If\x20specified,\x20must\x20have\x20the\
+ \x20form\n\x20`major-version.minor-version`,\x20as\x20in\x20`1.10`.\x20I\
+ f\x20the\x20minor\x20version\x20is\n\x20omitted,\x20it\x20defaults\x20to\
+ \x20zero.\x20If\x20the\x20entire\x20version\x20field\x20is\x20empty,\x20\
+ the\n\x20major\x20version\x20is\x20derived\x20from\x20the\x20package\x20\
+ name,\x20as\x20outlined\x20below.\x20If\x20the\n\x20field\x20is\x20not\
+ \x20empty,\x20the\x20version\x20in\x20the\x20package\x20name\x20will\x20\
+ be\x20verified\x20to\x20be\n\x20consistent\x20with\x20what\x20is\x20prov\
+ ided\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\x20mi\
+ nor\x20version\x20an\x20additive,\n\x20non-breaking\x20change.\x20Both\
+ \x20version\x20numbers\x20are\x20signals\x20to\x20users\n\x20what\x20to\
+ \x20expect\x20from\x20different\x20versions,\x20and\x20should\x20be\x20c\
+ arefully\n\x20chosen\x20based\x20on\x20the\x20product\x20plan.\n\n\x20Th\
+ e\x20major\x20version\x20is\x20also\x20reflected\x20in\x20the\x20package\
+ \x20name\x20of\x20the\n\x20interface,\x20which\x20must\x20end\x20in\x20`\
+ v<major-version>`,\x20as\x20in\n\x20`google.feature.v1`.\x20For\x20major\
+ \x20versions\x200\x20and\x201,\x20the\x20suffix\x20can\n\x20be\x20omitte\
+ d.\x20Zero\x20major\x20versions\x20must\x20only\x20be\x20used\x20for\n\
+ \x20experimental,\x20non-GA\x20interfaces.\n\n\n\n\x0c\n\x05\x04\0\x02\
+ \x03\x05\x12\x03U\x02\x08\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x03U\t\x10\n\
+ \x0c\n\x05\x04\0\x02\x03\x03\x12\x03U\x13\x14\n[\n\x04\x04\0\x02\x04\x12\
+ \x03Y\x02#\x1aN\x20Source\x20context\x20for\x20the\x20protocol\x20buffer\
+ \x20service\x20represented\x20by\x20this\n\x20message.\n\n\x0c\n\x05\x04\
+ \0\x02\x04\x06\x12\x03Y\x02\x0f\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x03Y\
+ \x10\x1e\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03Y!\"\n2\n\x04\x04\0\x02\
+ \x05\x12\x03\\\x02\x1c\x1a%\x20Included\x20interfaces.\x20See\x20[Mixin]\
+ [].\n\n\x0c\n\x05\x04\0\x02\x05\x04\x12\x03\\\x02\n\n\x0c\n\x05\x04\0\
+ \x02\x05\x06\x12\x03\\\x0b\x10\n\x0c\n\x05\x04\0\x02\x05\x01\x12\x03\\\
+ \x11\x17\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x03\\\x1a\x1b\n0\n\x04\x04\0\
+ \x02\x06\x12\x03_\x02\x14\x1a#\x20The\x20source\x20syntax\x20of\x20the\
+ \x20service.\n\n\x0c\n\x05\x04\0\x02\x06\x06\x12\x03_\x02\x08\n\x0c\n\
+ \x05\x04\0\x02\x06\x01\x12\x03_\t\x0f\n\x0c\n\x05\x04\0\x02\x06\x03\x12\
+ \x03_\x12\x13\n=\n\x02\x04\x01\x12\x04c\0x\x01\x1a1\x20Method\x20represe\
+ nts\x20a\x20method\x20of\x20an\x20API\x20interface.\n\n\n\n\x03\x04\x01\
+ \x01\x12\x03c\x08\x0e\n.\n\x04\x04\x01\x02\0\x12\x03e\x02\x12\x1a!\x20Th\
+ e\x20simple\x20name\x20of\x20this\x20method.\n\n\x0c\n\x05\x04\x01\x02\0\
+ \x05\x12\x03e\x02\x08\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03e\t\r\n\x0c\n\
+ \x05\x04\x01\x02\0\x03\x12\x03e\x10\x11\n/\n\x04\x04\x01\x02\x01\x12\x03\
+ h\x02\x1e\x1a\"\x20A\x20URL\x20of\x20the\x20input\x20message\x20type.\n\
+ \n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03h\x02\x08\n\x0c\n\x05\x04\x01\
+ \x02\x01\x01\x12\x03h\t\x19\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03h\x1c\
+ \x1d\n0\n\x04\x04\x01\x02\x02\x12\x03k\x02\x1d\x1a#\x20If\x20true,\x20th\
+ e\x20request\x20is\x20streamed.\n\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\
+ \x03k\x02\x06\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03k\x07\x18\n\x0c\n\
+ \x05\x04\x01\x02\x02\x03\x12\x03k\x1b\x1c\n2\n\x04\x04\x01\x02\x03\x12\
+ \x03n\x02\x1f\x1a%\x20The\x20URL\x20of\x20the\x20output\x20message\x20ty\
+ pe.\n\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\x03n\x02\x08\n\x0c\n\x05\x04\
+ \x01\x02\x03\x01\x12\x03n\t\x1a\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03n\
+ \x1d\x1e\n1\n\x04\x04\x01\x02\x04\x12\x03q\x02\x1e\x1a$\x20If\x20true,\
+ \x20the\x20response\x20is\x20streamed.\n\n\x0c\n\x05\x04\x01\x02\x04\x05\
+ \x12\x03q\x02\x06\n\x0c\n\x05\x04\x01\x02\x04\x01\x12\x03q\x07\x19\n\x0c\
+ \n\x05\x04\x01\x02\x04\x03\x12\x03q\x1c\x1d\n3\n\x04\x04\x01\x02\x05\x12\
+ \x03t\x02\x1e\x1a&\x20Any\x20metadata\x20attached\x20to\x20the\x20method\
+ .\n\n\x0c\n\x05\x04\x01\x02\x05\x04\x12\x03t\x02\n\n\x0c\n\x05\x04\x01\
+ \x02\x05\x06\x12\x03t\x0b\x11\n\x0c\n\x05\x04\x01\x02\x05\x01\x12\x03t\
+ \x12\x19\n\x0c\n\x05\x04\x01\x02\x05\x03\x12\x03t\x1c\x1d\n0\n\x04\x04\
+ \x01\x02\x06\x12\x03w\x02\x14\x1a#\x20The\x20source\x20syntax\x20of\x20t\
+ his\x20method.\n\n\x0c\n\x05\x04\x01\x02\x06\x06\x12\x03w\x02\x08\n\x0c\
+ \n\x05\x04\x01\x02\x06\x01\x12\x03w\t\x0f\n\x0c\n\x05\x04\x01\x02\x06\
+ \x03\x12\x03w\x12\x13\n\xca\x13\n\x02\x04\x02\x12\x06\xc8\x01\0\xcf\x01\
+ \x01\x1a\xbb\x13\x20Declares\x20an\x20API\x20Interface\x20to\x20be\x20in\
+ cluded\x20in\x20this\x20interface.\x20The\x20including\n\x20interface\
+ \x20must\x20redeclare\x20all\x20the\x20methods\x20from\x20the\x20include\
+ d\x20interface,\x20but\n\x20documentation\x20and\x20options\x20are\x20in\
+ herited\x20as\x20follows:\n\n\x20-\x20If\x20after\x20comment\x20and\x20w\
+ hitespace\x20stripping,\x20the\x20documentation\n\x20\x20\x20string\x20o\
+ f\x20the\x20redeclared\x20method\x20is\x20empty,\x20it\x20will\x20be\x20\
+ inherited\n\x20\x20\x20from\x20the\x20original\x20method.\n\n\x20-\x20Ea\
+ ch\x20annotation\x20belonging\x20to\x20the\x20service\x20config\x20(http\
+ ,\n\x20\x20\x20visibility)\x20which\x20is\x20not\x20set\x20in\x20the\x20\
+ redeclared\x20method\x20will\x20be\n\x20\x20\x20inherited.\n\n\x20-\x20I\
+ f\x20an\x20http\x20annotation\x20is\x20inherited,\x20the\x20path\x20patt\
+ ern\x20will\x20be\n\x20\x20\x20modified\x20as\x20follows.\x20Any\x20vers\
+ ion\x20prefix\x20will\x20be\x20replaced\x20by\x20the\n\x20\x20\x20versio\
+ n\x20of\x20the\x20including\x20interface\x20plus\x20the\x20[root][]\x20p\
+ ath\x20if\n\x20\x20\x20specified.\n\n\x20Example\x20of\x20a\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\"/v\
+ 1/{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\x20\
+ GetAcl(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/{resou\
+ rce=**}\";\n\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20}\n\n\x20\
+ Example\x20of\x20a\x20mixin\x20configuration:\n\n\x20\x20\x20\x20\x20api\
+ s:\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\n\x20The\x20mixin\x20construct\x20impl\
+ ies\x20that\x20all\x20methods\x20in\x20`AccessControl`\x20are\n\x20also\
+ \x20declared\x20with\x20same\x20name\x20and\x20request/response\x20types\
+ \x20in\n\x20`Storage`.\x20A\x20documentation\x20generator\x20or\x20annot\
+ ation\x20processor\x20will\n\x20see\x20the\x20effective\x20`Storage.GetA\
+ cl`\x20method\x20after\x20inheriting\n\x20documentation\x20and\x20annota\
+ tions\x20as\x20follows:\n\n\x20\x20\x20\x20\x20service\x20Storage\x20{\n\
+ \x20\x20\x20\x20\x20\x20\x20//\x20Get\x20the\x20underlying\x20ACL\x20obj\
+ ect.\n\x20\x20\x20\x20\x20\x20\x20rpc\x20GetAcl(GetAclRequest)\x20return\
+ s\x20(Acl)\x20{\n\x20\x20\x20\x20\x20\x20\x20\x20\x20option\x20(google.a\
+ pi.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\x20cha\
+ nged\x20from\x20`v1`\x20to\x20`v2`.\n\n\x20If\x20the\x20`root`\x20field\
+ \x20in\x20the\x20mixin\x20is\x20specified,\x20it\x20should\x20be\x20a\n\
+ \x20relative\x20path\x20under\x20which\x20inherited\x20HTTP\x20paths\x20\
+ are\x20placed.\x20Example:\n\n\x20\x20\x20\x20\x20apis:\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\x20root:\x20acls\n\n\
+ \x20This\x20implies\x20the\x20following\x20inherited\x20HTTP\x20annotati\
+ on:\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.api.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\xc8\x01\x08\r\nL\n\x04\x04\x02\x02\0\x12\x04\xca\x01\
+ \x02\x12\x1a>\x20The\x20fully\x20qualified\x20name\x20of\x20the\x20inter\
+ face\x20which\x20is\x20included.\n\n\r\n\x05\x04\x02\x02\0\x05\x12\x04\
+ \xca\x01\x02\x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\xca\x01\t\r\n\r\n\
+ \x05\x04\x02\x02\0\x03\x12\x04\xca\x01\x10\x11\n[\n\x04\x04\x02\x02\x01\
+ \x12\x04\xce\x01\x02\x12\x1aM\x20If\x20non-empty\x20specifies\x20a\x20pa\
+ th\x20under\x20which\x20inherited\x20HTTP\x20paths\n\x20are\x20rooted.\n\
+ \n\r\n\x05\x04\x02\x02\x01\x05\x12\x04\xce\x01\x02\x08\n\r\n\x05\x04\x02\
+ \x02\x01\x01\x12\x04\xce\x01\t\r\n\r\n\x05\x04\x02\x02\x01\x03\x12\x04\
+ \xce\x01\x10\x11b\x06proto3\
+";
+
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+ crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
+ file_descriptor_proto_lazy.get(|| {
+ parse_descriptor_proto()
+ })
+}
diff --git a/2.27.1/src/well_known_types/duration.rs b/2.27.1/src/well_known_types/duration.rs
new file mode 100644
index 0000000..822061a
--- /dev/null
+++ b/2.27.1/src/well_known_types/duration.rs
@@ -0,0 +1,338 @@
+// This file is generated by rust-protobuf 2.26.0. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(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(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `google/protobuf/duration.proto`
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct Duration {
+ // message fields
+ pub seconds: i64,
+ pub nanos: i32,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Duration {
+ fn default() -> &'a Duration {
+ <Duration as crate::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 crate::Message for Duration {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int64()?;
+ self.seconds = tmp;
+ },
+ 2 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.nanos = tmp;
+ },
+ _ => {
+ crate::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 += crate::rt::value_size(1, self.seconds, crate::wire_format::WireTypeVarint);
+ }
+ if self.nanos != 0 {
+ my_size += crate::rt::value_size(2, self.nanos, crate::wire_format::WireTypeVarint);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Duration {
+ Duration::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt64>(
+ "seconds",
+ |m: &Duration| { &m.seconds },
+ |m: &mut Duration| { &mut m.seconds },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "nanos",
+ |m: &Duration| { &m.nanos },
+ |m: &mut Duration| { &mut m.nanos },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Duration>(
+ "Duration",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Duration {
+ static instance: crate::rt::LazyV2<Duration> = crate::rt::LazyV2::INIT;
+ instance.get(Duration::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Duration {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::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\x83\x01\n\x13com.google.protobufB\
+ \rDurationProtoP\x01Z1google.golang.org/protobuf/types/known/durationpb\
+ \xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesJ\
+ \xda#\n\x06\x12\x04\x1e\0s\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://developers.google.com/protocol-buffers/\n\n\
+ \x20Redistribution\x20and\x20use\x20in\x20source\x20and\x20binary\x20for\
+ ms,\x20with\x20or\x20without\n\x20modification,\x20are\x20permitted\x20p\
+ rovided\x20that\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\x20\
+ of\x20conditions\x20and\x20the\x20following\x20disclaimer.\n\x20\x20\x20\
+ \x20\x20*\x20Redistributions\x20in\x20binary\x20form\x20must\x20reproduc\
+ e\x20the\x20above\n\x20copyright\x20notice,\x20this\x20list\x20of\x20con\
+ ditions\x20and\x20the\x20following\x20disclaimer\n\x20in\x20the\x20docum\
+ entation\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\x20to\x20endorse\x20or\x20promote\x20products\x20d\
+ erived\x20from\n\x20this\x20software\x20without\x20specific\x20prior\x20\
+ written\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\
+ \x20MERCHANTABILITY\x20AND\x20FITNESS\x20FOR\n\x20A\x20PARTICULAR\x20PUR\
+ POSE\x20ARE\x20DISCLAIMED.\x20IN\x20NO\x20EVENT\x20SHALL\x20THE\x20COPYR\
+ IGHT\n\x20OWNER\x20OR\x20CONTRIBUTORS\x20BE\x20LIABLE\x20FOR\x20ANY\x20D\
+ IRECT,\x20INDIRECT,\x20INCIDENTAL,\n\x20SPECIAL,\x20EXEMPLARY,\x20OR\x20\
+ CONSEQUENTIAL\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$\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\x9e\x10\n\x02\x04\0\x12\x04f\0s\x01\x1a\x91\
+ \x10\x20A\x20Duration\x20represents\x20a\x20signed,\x20fixed-length\x20s\
+ pan\x20of\x20time\x20represented\n\x20as\x20a\x20count\x20of\x20seconds\
+ \x20and\x20fractions\x20of\x20seconds\x20at\x20nanosecond\n\x20resolutio\
+ n.\x20It\x20is\x20independent\x20of\x20any\x20calendar\x20and\x20concept\
+ s\x20like\x20\"day\"\n\x20or\x20\"month\".\x20It\x20is\x20related\x20to\
+ \x20Timestamp\x20in\x20that\x20the\x20difference\x20between\n\x20two\x20\
+ Timestamp\x20values\x20is\x20a\x20Duration\x20and\x20it\x20can\x20be\x20\
+ added\x20or\x20subtracted\n\x20from\x20a\x20Timestamp.\x20Range\x20is\
+ \x20approximately\x20+-10,000\x20years.\n\n\x20#\x20Examples\n\n\x20Exam\
+ ple\x201:\x20Compute\x20Duration\x20from\x20two\x20Timestamps\x20in\x20p\
+ seudo\x20code.\n\n\x20\x20\x20\x20\x20Timestamp\x20start\x20=\x20...;\n\
+ \x20\x20\x20\x20\x20Timestamp\x20end\x20=\x20...;\n\x20\x20\x20\x20\x20D\
+ uration\x20duration\x20=\x20...;\n\n\x20\x20\x20\x20\x20duration.seconds\
+ \x20=\x20end.seconds\x20-\x20start.seconds;\n\x20\x20\x20\x20\x20duratio\
+ n.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(duration.seconds\x20>\x200\x20&&\x20duration.nan\
+ os\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}\n\n\x20Example\x202:\x20Compute\x20Timestamp\x20\
+ from\x20Timestamp\x20+\x20Duration\x20in\x20pseudo\x20code.\n\n\x20\x20\
+ \x20\x20\x20Timestamp\x20start\x20=\x20...;\n\x20\x20\x20\x20\x20Duratio\
+ n\x20duration\x20=\x20...;\n\x20\x20\x20\x20\x20Timestamp\x20end\x20=\
+ \x20...;\n\n\x20\x20\x20\x20\x20end.seconds\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\x20datetime.timedelta\x20in\x20Pyt\
+ hon.\n\n\x20\x20\x20\x20\x20td\x20=\x20datetime.timedelta(days=3,\x20min\
+ utes=10)\n\x20\x20\x20\x20\x20duration\x20=\x20Duration()\n\x20\x20\x20\
+ \x20\x20duration.FromTimedelta(td)\n\n\x20#\x20JSON\x20Mapping\n\n\x20In\
+ \x20JSON\x20format,\x20the\x20Duration\x20type\x20is\x20encoded\x20as\
+ \x20a\x20string\x20rather\x20than\x20an\n\x20object,\x20where\x20the\x20\
+ string\x20ends\x20in\x20the\x20suffix\x20\"s\"\x20(indicating\x20seconds\
+ )\x20and\n\x20is\x20preceded\x20by\x20the\x20number\x20of\x20seconds,\
+ \x20with\x20nanoseconds\x20expressed\x20as\n\x20fractional\x20seconds.\
+ \x20For\x20example,\x203\x20seconds\x20with\x200\x20nanoseconds\x20shoul\
+ d\x20be\n\x20encoded\x20in\x20JSON\x20format\x20as\x20\"3s\",\x20while\
+ \x203\x20seconds\x20and\x201\x20nanosecond\x20should\n\x20be\x20expresse\
+ d\x20in\x20JSON\x20format\x20as\x20\"3.000000001s\",\x20and\x203\x20seco\
+ nds\x20and\x201\n\x20microsecond\x20should\x20be\x20expressed\x20in\x20J\
+ SON\x20format\x20as\x20\"3.000001s\".\n\n\n\n\n\n\x03\x04\0\x01\x12\x03f\
+ \x08\x10\n\xdc\x01\n\x04\x04\0\x02\0\x12\x03j\x02\x14\x1a\xce\x01\x20Sig\
+ ned\x20seconds\x20of\x20the\x20span\x20of\x20time.\x20Must\x20be\x20from\
+ \x20-315,576,000,000\n\x20to\x20+315,576,000,000\x20inclusive.\x20Note:\
+ \x20these\x20bounds\x20are\x20computed\x20from:\n\x2060\x20sec/min\x20*\
+ \x2060\x20min/hr\x20*\x2024\x20hr/day\x20*\x20365.25\x20days/year\x20*\
+ \x2010000\x20years\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03j\x02\x07\n\x0c\
+ \n\x05\x04\0\x02\0\x01\x12\x03j\x08\x0f\n\x0c\n\x05\x04\0\x02\0\x03\x12\
+ \x03j\x12\x13\n\x83\x03\n\x04\x04\0\x02\x01\x12\x03r\x02\x12\x1a\xf5\x02\
+ \x20Signed\x20fractions\x20of\x20a\x20second\x20at\x20nanosecond\x20reso\
+ lution\x20of\x20the\x20span\n\x20of\x20time.\x20Durations\x20less\x20tha\
+ n\x20one\x20second\x20are\x20represented\x20with\x20a\x200\n\x20`seconds\
+ `\x20field\x20and\x20a\x20positive\x20or\x20negative\x20`nanos`\x20field\
+ .\x20For\x20durations\n\x20of\x20one\x20second\x20or\x20more,\x20a\x20no\
+ n-zero\x20value\x20for\x20the\x20`nanos`\x20field\x20must\x20be\n\x20of\
+ \x20the\x20same\x20sign\x20as\x20the\x20`seconds`\x20field.\x20Must\x20b\
+ e\x20from\x20-999,999,999\n\x20to\x20+999,999,999\x20inclusive.\n\n\x0c\
+ \n\x05\x04\0\x02\x01\x05\x12\x03r\x02\x07\n\x0c\n\x05\x04\0\x02\x01\x01\
+ \x12\x03r\x08\r\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03r\x10\x11b\x06proto\
+ 3\
+";
+
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+ crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
+ file_descriptor_proto_lazy.get(|| {
+ parse_descriptor_proto()
+ })
+}
diff --git a/2.27.1/src/well_known_types/empty.rs b/2.27.1/src/well_known_types/empty.rs
new file mode 100644
index 0000000..d55e517
--- /dev/null
+++ b/2.27.1/src/well_known_types/empty.rs
@@ -0,0 +1,208 @@
+// This file is generated by rust-protobuf 2.26.0. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(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(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `google/protobuf/empty.proto`
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct Empty {
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Empty {
+ fn default() -> &'a Empty {
+ <Empty as crate::Message>::default_instance()
+ }
+}
+
+impl Empty {
+ pub fn new() -> Empty {
+ ::std::default::Default::default()
+ }
+}
+
+impl crate::Message for Empty {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ _ => {
+ crate::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 += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Empty {
+ Empty::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let fields = ::std::vec::Vec::new();
+ crate::reflect::MessageDescriptor::new_pb_name::<Empty>(
+ "Empty",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Empty {
+ static instance: crate::rt::LazyV2<Empty> = crate::rt::LazyV2::INIT;
+ instance.get(Empty::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Empty {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+static file_descriptor_proto_data: &'static [u8] = b"\
+ \n\x1bgoogle/protobuf/empty.proto\x12\x0fgoogle.protobuf\"\x07\n\x05Empt\
+ yB}\n\x13com.google.protobufB\nEmptyProtoP\x01Z.google.golang.org/protob\
+ uf/types/known/emptypb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Prot\
+ obuf.WellKnownTypesJ\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\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#\0E\n\t\n\x02\x08\x0b\x12\x03#\0E\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 file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+ crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
+ file_descriptor_proto_lazy.get(|| {
+ parse_descriptor_proto()
+ })
+}
diff --git a/2.27.1/src/well_known_types/field_mask.rs b/2.27.1/src/well_known_types/field_mask.rs
new file mode 100644
index 0000000..e98eb53
--- /dev/null
+++ b/2.27.1/src/well_known_types/field_mask.rs
@@ -0,0 +1,385 @@
+// This file is generated by rust-protobuf 2.26.0. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(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(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `google/protobuf/field_mask.proto`
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct FieldMask {
+ // message fields
+ pub paths: crate::RepeatedField<::std::string::String>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a FieldMask {
+ fn default() -> &'a FieldMask {
+ <FieldMask as crate::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: crate::RepeatedField<::std::string::String>) {
+ self.paths = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_paths(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
+ &mut self.paths
+ }
+
+ // Take field
+ pub fn take_paths(&mut self) -> crate::RepeatedField<::std::string::String> {
+ ::std::mem::replace(&mut self.paths, crate::RepeatedField::new())
+ }
+}
+
+impl crate::Message for FieldMask {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_repeated_string_into(wire_type, is, &mut self.paths)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &value);
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> FieldMask {
+ FieldMask::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "paths",
+ |m: &FieldMask| { &m.paths },
+ |m: &mut FieldMask| { &mut m.paths },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<FieldMask>(
+ "FieldMask",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static FieldMask {
+ static instance: crate::rt::LazyV2<FieldMask> = crate::rt::LazyV2::INIT;
+ instance.get(FieldMask::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for FieldMask {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::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\x05pathsB\x85\x01\n\x13com.\
+ google.protobufB\x0eFieldMaskProtoP\x01Z2google.golang.org/protobuf/type\
+ s/known/fieldmaskpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobu\
+ f.WellKnownTypesJ\xa1;\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\x08\n\x01\x08\x12\x03'\0I\n\t\n\x02\x08\x0b\x12\x03'\0I\n\
+ \x08\n\x01\x08\x12\x03(\0\x1f\n\t\n\x02\x08\x1f\x12\x03(\0\x1f\n\xb2,\n\
+ \x02\x04\0\x12\x06\xf1\x01\0\xf4\x01\x01\x1a\xa3,\x20`FieldMask`\x20repr\
+ esents\x20a\x20set\x20of\x20symbolic\x20field\x20paths,\x20for\x20exampl\
+ e:\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\x20a\x20field\x20in\x20so\
+ me\x20root\x20message,\x20`a`\x20and\x20`b`\n\x20fields\x20in\x20the\x20\
+ message\x20found\x20in\x20`f`,\x20and\x20`d`\x20a\x20field\x20found\x20i\
+ n\x20the\n\x20message\x20in\x20`f.b`.\n\n\x20Field\x20masks\x20are\x20us\
+ ed\x20to\x20specify\x20a\x20subset\x20of\x20fields\x20that\x20should\x20\
+ be\n\x20returned\x20by\x20a\x20get\x20operation\x20or\x20modified\x20by\
+ \x20an\x20update\x20operation.\n\x20Field\x20masks\x20also\x20have\x20a\
+ \x20custom\x20JSON\x20encoding\x20(see\x20below).\n\n\x20#\x20Field\x20M\
+ asks\x20in\x20Projections\n\n\x20When\x20used\x20in\x20the\x20context\
+ \x20of\x20a\x20projection,\x20a\x20response\x20message\x20or\n\x20sub-me\
+ ssage\x20is\x20filtered\x20by\x20the\x20API\x20to\x20only\x20contain\x20\
+ those\x20fields\x20as\n\x20specified\x20in\x20the\x20mask.\x20For\x20exa\
+ mple,\x20if\x20the\x20mask\x20in\x20the\x20previous\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\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\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\x20w\
+ ill\x20not\x20contain\x20specific\x20values\x20for\x20fields\x20x,y\x20a\
+ nd\x20z\n\x20(their\x20value\x20will\x20be\x20set\x20to\x20the\x20defaul\
+ t,\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\x20\
+ repeated\x20field\x20is\x20not\x20allowed\x20except\x20at\x20the\x20last\
+ \x20position\x20of\x20a\n\x20paths\x20string.\n\n\x20If\x20a\x20FieldMas\
+ k\x20object\x20is\x20not\x20present\x20in\x20a\x20get\x20operation,\x20t\
+ he\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\x20\
+ apply\x20to\x20the\n\x20top-level\x20response\x20message.\x20In\x20case\
+ \x20of\x20a\x20REST\x20get\x20operation,\x20the\n\x20field\x20mask\x20ap\
+ plies\x20directly\x20to\x20the\x20response,\x20but\x20in\x20case\x20of\
+ \x20a\x20REST\n\x20list\x20operation,\x20the\x20mask\x20instead\x20appli\
+ es\x20to\x20each\x20individual\x20message\n\x20in\x20the\x20returned\x20\
+ resource\x20list.\x20In\x20case\x20of\x20a\x20REST\x20custom\x20method,\
+ \n\x20other\x20definitions\x20may\x20be\x20used.\x20Where\x20the\x20mask\
+ \x20applies\x20will\x20be\n\x20clearly\x20documented\x20together\x20with\
+ \x20its\x20declaration\x20in\x20the\x20API.\x20\x20In\n\x20any\x20case,\
+ \x20the\x20effect\x20on\x20the\x20returned\x20resource/resources\x20is\
+ \x20required\n\x20behavior\x20for\x20APIs.\n\n\x20#\x20Field\x20Masks\
+ \x20in\x20Update\x20Operations\n\n\x20A\x20field\x20mask\x20in\x20update\
+ \x20operations\x20specifies\x20which\x20fields\x20of\x20the\n\x20targete\
+ d\x20resource\x20are\x20going\x20to\x20be\x20updated.\x20The\x20API\x20i\
+ s\x20required\n\x20to\x20only\x20change\x20the\x20values\x20of\x20the\
+ \x20fields\x20as\x20specified\x20in\x20the\x20mask\n\x20and\x20leave\x20\
+ the\x20others\x20untouched.\x20If\x20a\x20resource\x20is\x20passed\x20in\
+ \x20to\n\x20describe\x20the\x20updated\x20values,\x20the\x20API\x20ignor\
+ es\x20the\x20values\x20of\x20all\n\x20fields\x20not\x20covered\x20by\x20\
+ the\x20mask.\n\n\x20If\x20a\x20repeated\x20field\x20is\x20specified\x20f\
+ or\x20an\x20update\x20operation,\x20new\x20values\x20will\n\x20be\x20app\
+ ended\x20to\x20the\x20existing\x20repeated\x20field\x20in\x20the\x20targ\
+ et\x20resource.\x20Note\x20that\n\x20a\x20repeated\x20field\x20is\x20onl\
+ y\x20allowed\x20in\x20the\x20last\x20position\x20of\x20a\x20`paths`\x20s\
+ tring.\n\n\x20If\x20a\x20sub-message\x20is\x20specified\x20in\x20the\x20\
+ last\x20position\x20of\x20the\x20field\x20mask\x20for\x20an\n\x20update\
+ \x20operation,\x20then\x20new\x20value\x20will\x20be\x20merged\x20into\
+ \x20the\x20existing\x20sub-message\n\x20in\x20the\x20target\x20resource.\
+ \n\n\x20For\x20example,\x20given\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:\x201\n\x20\x20\x20\x20\x20\x20\x20\x20\x20x:\
+ \x202\n\x20\x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20c:\x20\
+ [1]\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:\x2010\n\x20\x20\x20\x20\x20\x20\x20}\n\
+ \x20\x20\x20\x20\x20\x20\x20c:\x20[2]\n\x20\x20\x20\x20\x20}\n\n\x20then\
+ \x20if\x20the\x20field\x20mask\x20is:\n\n\x20\x20paths:\x20[\"f.b\",\x20\
+ \"f.c\"]\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:\x2010\n\x20\x20\x20\x20\x20\x20\x20\x20\x20x:\x202\n\x20\
+ \x20\x20\x20\x20\x20\x20}\n\x20\x20\x20\x20\x20\x20\x20c:\x20[1,\x202]\n\
+ \x20\x20\x20\x20\x20}\n\n\x20An\x20implementation\x20may\x20provide\x20o\
+ ptions\x20to\x20override\x20this\x20default\x20behavior\x20for\n\x20repe\
+ ated\x20and\x20message\x20fields.\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\x20val\
+ ue\x20in\x20the\x20provided\x20resource.\n\x20Hence,\x20in\x20order\x20t\
+ o\x20reset\x20all\x20fields\x20of\x20a\x20resource,\x20provide\x20a\x20d\
+ efault\n\x20instance\x20of\x20the\x20resource\x20and\x20set\x20all\x20fi\
+ elds\x20in\x20the\x20mask,\x20or\x20do\n\x20not\x20provide\x20a\x20mask\
+ \x20as\x20described\x20below.\n\n\x20If\x20a\x20field\x20mask\x20is\x20n\
+ ot\x20present\x20on\x20update,\x20the\x20operation\x20applies\x20to\n\
+ \x20all\x20fields\x20(as\x20if\x20a\x20field\x20mask\x20of\x20all\x20fie\
+ lds\x20has\x20been\x20specified).\n\x20Note\x20that\x20in\x20the\x20pres\
+ ence\x20of\x20schema\x20evolution,\x20this\x20may\x20mean\x20that\n\x20f\
+ ields\x20the\x20client\x20does\x20not\x20know\x20and\x20has\x20therefore\
+ \x20not\x20filled\x20into\n\x20the\x20request\x20will\x20be\x20reset\x20\
+ to\x20their\x20default.\x20If\x20this\x20is\x20unwanted\n\x20behavior,\
+ \x20a\x20specific\x20service\x20may\x20require\x20a\x20client\x20to\x20a\
+ lways\x20specify\n\x20a\x20field\x20mask,\x20producing\x20an\x20error\
+ \x20if\x20not.\n\n\x20As\x20with\x20get\x20operations,\x20the\x20locatio\
+ n\x20of\x20the\x20resource\x20which\n\x20describes\x20the\x20updated\x20\
+ values\x20in\x20the\x20request\x20message\x20depends\x20on\x20the\n\x20o\
+ peration\x20kind.\x20In\x20any\x20case,\x20the\x20effect\x20of\x20the\
+ \x20field\x20mask\x20is\n\x20required\x20to\x20be\x20honored\x20by\x20th\
+ e\x20API.\n\n\x20##\x20Considerations\x20for\x20HTTP\x20REST\n\n\x20The\
+ \x20HTTP\x20kind\x20of\x20an\x20update\x20operation\x20which\x20uses\x20\
+ a\x20field\x20mask\x20must\n\x20be\x20set\x20to\x20PATCH\x20instead\x20o\
+ f\x20PUT\x20in\x20order\x20to\x20satisfy\x20HTTP\x20semantics\n\x20(PUT\
+ \x20must\x20only\x20be\x20used\x20for\x20full\x20updates).\n\n\x20#\x20J\
+ SON\x20Encoding\x20of\x20Field\x20Masks\n\n\x20In\x20JSON,\x20a\x20field\
+ \x20mask\x20is\x20encoded\x20as\x20a\x20single\x20string\x20where\x20pat\
+ hs\x20are\n\x20separated\x20by\x20a\x20comma.\x20Fields\x20name\x20in\
+ \x20each\x20path\x20are\x20converted\n\x20to/from\x20lower-camel\x20nami\
+ ng\x20conventions.\n\n\x20As\x20an\x20example,\x20consider\x20the\x20fol\
+ lowing\x20message\x20declarations:\n\n\x20\x20\x20\x20\x20message\x20Pro\
+ file\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\x20st\
+ ring\x20display_name\x20=\x201;\n\x20\x20\x20\x20\x20\x20\x20string\x20a\
+ ddress\x20=\x202;\n\x20\x20\x20\x20\x20}\n\n\x20In\x20proto\x20a\x20fiel\
+ d\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\x20##\x20Field\x20Mask\x20Verification\n\n\x20\
+ The\x20implementation\x20of\x20any\x20API\x20method\x20which\x20has\x20a\
+ \x20FieldMask\x20type\x20field\x20in\x20the\n\x20request\x20should\x20ve\
+ rify\x20the\x20included\x20field\x20paths,\x20and\x20return\x20an\n\x20`\
+ INVALID_ARGUMENT`\x20error\x20if\x20any\x20path\x20is\x20unmappable.\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\x20pat\
+ hs.\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\x06proto\
+ 3\
+";
+
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+ crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
+ file_descriptor_proto_lazy.get(|| {
+ parse_descriptor_proto()
+ })
+}
diff --git a/2.27.1/src/well_known_types/mod.rs b/2.27.1/src/well_known_types/mod.rs
new file mode 100644
index 0000000..9ecf8fb
--- /dev/null
+++ b/2.27.1/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/2.27.1/src/well_known_types/source_context.rs b/2.27.1/src/well_known_types/source_context.rs
new file mode 100644
index 0000000..646e87d
--- /dev/null
+++ b/2.27.1/src/well_known_types/source_context.rs
@@ -0,0 +1,251 @@
+// This file is generated by rust-protobuf 2.26.0. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(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(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `google/protobuf/source_context.proto`
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct SourceContext {
+ // message fields
+ pub file_name: ::std::string::String,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a SourceContext {
+ fn default() -> &'a SourceContext {
+ <SourceContext as crate::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 crate::Message for SourceContext {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.file_name)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &self.file_name);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> SourceContext {
+ SourceContext::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "file_name",
+ |m: &SourceContext| { &m.file_name },
+ |m: &mut SourceContext| { &mut m.file_name },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<SourceContext>(
+ "SourceContext",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static SourceContext {
+ static instance: crate::rt::LazyV2<SourceContext> = crate::rt::LazyV2::INIT;
+ instance.get(SourceContext::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for SourceContext {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::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\x08fileNameB\x8a\x01\
+ \n\x13com.google.protobufB\x12SourceContextProtoP\x01Z6google.golang.org\
+ /protobuf/types/known/sourcecontextpb\xa2\x02\x03GPB\xaa\x02\x1eGoogle.P\
+ rotobuf.WellKnownTypesJ\xc1\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\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$\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\x08\n\x01\x08\x12\x03'\0M\n\t\n\x02\x08\x0b\x12\x03'\0M\n\
+ \x83\x01\n\x02\x04\0\x12\x04+\0/\x01\x1aw\x20`SourceContext`\x20represen\
+ ts\x20information\x20about\x20the\x20source\x20of\x20a\n\x20protobuf\x20\
+ element,\x20like\x20the\x20file\x20in\x20which\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-qualified\x20name\x20of\x20the\
+ \x20.proto\x20file\x20that\x20contained\x20the\x20associated\n\x20protob\
+ uf\x20element.\x20\x20For\x20example:\x20`\"google/protobuf/source_conte\
+ xt.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 file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+ crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
+ file_descriptor_proto_lazy.get(|| {
+ parse_descriptor_proto()
+ })
+}
diff --git a/2.27.1/src/well_known_types/struct_pb.rs b/2.27.1/src/well_known_types/struct_pb.rs
new file mode 100644
index 0000000..5f18a42
--- /dev/null
+++ b/2.27.1/src/well_known_types/struct_pb.rs
@@ -0,0 +1,1009 @@
+// This file is generated by rust-protobuf 2.26.0. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(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(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `google/protobuf/struct.proto`
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::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: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Struct {
+ fn default() -> &'a Struct {
+ <Struct as crate::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 crate::Message for Struct {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_map_into::<crate::types::ProtobufTypeString, crate::types::ProtobufTypeMessage<Value>>(wire_type, is, &mut self.fields)?;
+ },
+ _ => {
+ crate::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 += crate::rt::compute_map_size::<crate::types::ProtobufTypeString, crate::types::ProtobufTypeMessage<Value>>(1, &self.fields);
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ crate::rt::write_map_with_cached_sizes::<crate::types::ProtobufTypeString, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Struct {
+ Struct::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_map_accessor::<_, crate::types::ProtobufTypeString, crate::types::ProtobufTypeMessage<Value>>(
+ "fields",
+ |m: &Struct| { &m.fields },
+ |m: &mut Struct| { &mut m.fields },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Struct>(
+ "Struct",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Struct {
+ static instance: crate::rt::LazyV2<Struct> = crate::rt::LazyV2::INIT;
+ instance.get(Struct::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Struct {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::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: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Value {
+ fn default() -> &'a Value {
+ <Value as crate::Message>::default_instance()
+ }
+}
+
+#[derive(Clone,PartialEq,Debug)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::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 as crate::Message>::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 as crate::Message>::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 crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ self.kind = ::std::option::Option::Some(Value_oneof_kind::null_value(is.read_enum()?));
+ },
+ 2 => {
+ if wire_type != crate::wire_format::WireTypeFixed64 {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ self.kind = ::std::option::Option::Some(Value_oneof_kind::number_value(is.read_double()?));
+ },
+ 3 => {
+ if wire_type != crate::wire_format::WireTypeLengthDelimited {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ self.kind = ::std::option::Option::Some(Value_oneof_kind::string_value(is.read_string()?));
+ },
+ 4 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ self.kind = ::std::option::Option::Some(Value_oneof_kind::bool_value(is.read_bool()?));
+ },
+ 5 => {
+ if wire_type != crate::wire_format::WireTypeLengthDelimited {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ self.kind = ::std::option::Option::Some(Value_oneof_kind::struct_value(is.read_message()?));
+ },
+ 6 => {
+ if wire_type != crate::wire_format::WireTypeLengthDelimited {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ self.kind = ::std::option::Option::Some(Value_oneof_kind::list_value(is.read_message()?));
+ },
+ _ => {
+ crate::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 += crate::rt::enum_size(1, v);
+ },
+ &Value_oneof_kind::number_value(v) => {
+ my_size += 9;
+ },
+ &Value_oneof_kind::string_value(ref v) => {
+ my_size += crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ },
+ &Value_oneof_kind::list_value(ref v) => {
+ let len = v.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ },
+ };
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if let ::std::option::Option::Some(ref v) = self.kind {
+ match v {
+ &Value_oneof_kind::null_value(v) => {
+ os.write_enum(1, crate::ProtobufEnum::value(&v))?;
+ },
+ &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, crate::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, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Value {
+ Value::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_singular_enum_accessor::<_, NullValue>(
+ "null_value",
+ Value::has_null_value,
+ Value::get_null_value,
+ ));
+ fields.push(crate::reflect::accessor::make_singular_f64_accessor::<_>(
+ "number_value",
+ Value::has_number_value,
+ Value::get_number_value,
+ ));
+ fields.push(crate::reflect::accessor::make_singular_string_accessor::<_>(
+ "string_value",
+ Value::has_string_value,
+ Value::get_string_value,
+ ));
+ fields.push(crate::reflect::accessor::make_singular_bool_accessor::<_>(
+ "bool_value",
+ Value::has_bool_value,
+ Value::get_bool_value,
+ ));
+ fields.push(crate::reflect::accessor::make_singular_message_accessor::<_, Struct>(
+ "struct_value",
+ Value::has_struct_value,
+ Value::get_struct_value,
+ ));
+ fields.push(crate::reflect::accessor::make_singular_message_accessor::<_, ListValue>(
+ "list_value",
+ Value::has_list_value,
+ Value::get_list_value,
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Value>(
+ "Value",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Value {
+ static instance: crate::rt::LazyV2<Value> = crate::rt::LazyV2::INIT;
+ instance.get(Value::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Value {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct ListValue {
+ // message fields
+ pub values: crate::RepeatedField<Value>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a ListValue {
+ fn default() -> &'a ListValue {
+ <ListValue as crate::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: crate::RepeatedField<Value>) {
+ self.values = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_values(&mut self) -> &mut crate::RepeatedField<Value> {
+ &mut self.values
+ }
+
+ // Take field
+ pub fn take_values(&mut self) -> crate::RepeatedField<Value> {
+ ::std::mem::replace(&mut self.values, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.values)?;
+ },
+ _ => {
+ crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ for v in &self.values {
+ os.write_tag(1, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> ListValue {
+ ListValue::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Value>>(
+ "values",
+ |m: &ListValue| { &m.values },
+ |m: &mut ListValue| { &mut m.values },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<ListValue>(
+ "ListValue",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static ListValue {
+ static instance: crate::rt::LazyV2<ListValue> = crate::rt::LazyV2::INIT;
+ instance.get(ListValue::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for ListValue {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub enum NullValue {
+ NULL_VALUE = 0,
+}
+
+impl crate::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 crate::reflect::EnumDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ crate::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 crate::reflect::ProtobufValue for NullValue {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
+ }
+}
+
+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\x7f\n\x13com.google.protobufB\x0bStructProtoP\x01Z/google.g\
+ olang.org/protobuf/types/known/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\x20Buffers\
+ \x20-\x20Google's\x20data\x20interchange\x20format\n\x20Copyright\x20200\
+ 8\x20Google\x20Inc.\x20\x20All\x20rights\x20reserved.\n\x20https://devel\
+ opers.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$\0F\n\t\n\x02\x08\x0b\x12\x03$\0F\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\x042\05\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\x032\x08\
+ \x0e\n9\n\x04\x04\0\x02\0\x12\x034\x02\x20\x1a,\x20Unordered\x20map\x20o\
+ f\x20dynamically\x20typed\x20values.\n\n\x0c\n\x05\x04\0\x02\0\x06\x12\
+ \x034\x02\x14\n\x0c\n\x05\x04\0\x02\0\x01\x12\x034\x15\x1b\n\x0c\n\x05\
+ \x04\0\x02\0\x03\x12\x034\x1e\x1f\n\xc3\x02\n\x02\x04\x01\x12\x04=\0M\
+ \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?\x02L\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\x03A\x04\x1d\x1a\x1a\x20Rep\
+ resents\x20a\x20null\x20value.\n\n\x0c\n\x05\x04\x01\x02\0\x06\x12\x03A\
+ \x04\r\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03A\x0e\x18\n\x0c\n\x05\x04\
+ \x01\x02\0\x03\x12\x03A\x1b\x1c\n)\n\x04\x04\x01\x02\x01\x12\x03C\x04\
+ \x1c\x1a\x1c\x20Represents\x20a\x20double\x20value.\n\n\x0c\n\x05\x04\
+ \x01\x02\x01\x05\x12\x03C\x04\n\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03C\
+ \x0b\x17\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03C\x1a\x1b\n)\n\x04\x04\
+ \x01\x02\x02\x12\x03E\x04\x1c\x1a\x1c\x20Represents\x20a\x20string\x20va\
+ lue.\n\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03E\x04\n\n\x0c\n\x05\x04\
+ \x01\x02\x02\x01\x12\x03E\x0b\x17\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\
+ \x03E\x1a\x1b\n*\n\x04\x04\x01\x02\x03\x12\x03G\x04\x18\x1a\x1d\x20Repre\
+ sents\x20a\x20boolean\x20value.\n\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\
+ \x03G\x04\x08\n\x0c\n\x05\x04\x01\x02\x03\x01\x12\x03G\t\x13\n\x0c\n\x05\
+ \x04\x01\x02\x03\x03\x12\x03G\x16\x17\n-\n\x04\x04\x01\x02\x04\x12\x03I\
+ \x04\x1c\x1a\x20\x20Represents\x20a\x20structured\x20value.\n\n\x0c\n\
+ \x05\x04\x01\x02\x04\x06\x12\x03I\x04\n\n\x0c\n\x05\x04\x01\x02\x04\x01\
+ \x12\x03I\x0b\x17\n\x0c\n\x05\x04\x01\x02\x04\x03\x12\x03I\x1a\x1b\n-\n\
+ \x04\x04\x01\x02\x05\x12\x03K\x04\x1d\x1a\x20\x20Represents\x20a\x20repe\
+ ated\x20`Value`.\n\n\x0c\n\x05\x04\x01\x02\x05\x06\x12\x03K\x04\r\n\x0c\
+ \n\x05\x04\x01\x02\x05\x01\x12\x03K\x0e\x18\n\x0c\n\x05\x04\x01\x02\x05\
+ \x03\x12\x03K\x1b\x1c\n\xa9\x01\n\x02\x05\0\x12\x04S\0V\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\x03S\x05\x0e\n\x1a\n\x04\x05\0\
+ \x02\0\x12\x03U\x02\x11\x1a\r\x20Null\x20value.\n\n\x0c\n\x05\x05\0\x02\
+ \0\x01\x12\x03U\x02\x0c\n\x0c\n\x05\x05\0\x02\0\x02\x12\x03U\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 file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+ crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
+ file_descriptor_proto_lazy.get(|| {
+ parse_descriptor_proto()
+ })
+}
diff --git a/2.27.1/src/well_known_types/timestamp.rs b/2.27.1/src/well_known_types/timestamp.rs
new file mode 100644
index 0000000..25e7acf
--- /dev/null
+++ b/2.27.1/src/well_known_types/timestamp.rs
@@ -0,0 +1,363 @@
+// This file is generated by rust-protobuf 2.26.0. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(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(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `google/protobuf/timestamp.proto`
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct Timestamp {
+ // message fields
+ pub seconds: i64,
+ pub nanos: i32,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Timestamp {
+ fn default() -> &'a Timestamp {
+ <Timestamp as crate::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 crate::Message for Timestamp {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int64()?;
+ self.seconds = tmp;
+ },
+ 2 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.nanos = tmp;
+ },
+ _ => {
+ crate::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 += crate::rt::value_size(1, self.seconds, crate::wire_format::WireTypeVarint);
+ }
+ if self.nanos != 0 {
+ my_size += crate::rt::value_size(2, self.nanos, crate::wire_format::WireTypeVarint);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Timestamp {
+ Timestamp::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt64>(
+ "seconds",
+ |m: &Timestamp| { &m.seconds },
+ |m: &mut Timestamp| { &mut m.seconds },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "nanos",
+ |m: &Timestamp| { &m.nanos },
+ |m: &mut Timestamp| { &mut m.nanos },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Timestamp>(
+ "Timestamp",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Timestamp {
+ static instance: crate::rt::LazyV2<Timestamp> = crate::rt::LazyV2::INIT;
+ instance.get(Timestamp::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Timestamp {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::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\x85\x01\n\x13com.google.protobufB\
+ \x0eTimestampProtoP\x01Z2google.golang.org/protobuf/types/known/timestam\
+ ppb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypes\
+ J\xc5/\n\x07\x12\x05\x1e\0\x92\x01\x01\n\xcc\x0c\n\x01\x0c\x12\x03\x1e\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.\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$\0I\n\t\n\x02\x08\
+ \x0b\x12\x03$\0I\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\xde\x1d\n\x02\x04\0\x12\x06\x87\
+ \x01\0\x92\x01\x01\x1a\xcf\x1d\x20A\x20Timestamp\x20represents\x20a\x20p\
+ oint\x20in\x20time\x20independent\x20of\x20any\x20time\x20zone\x20or\x20\
+ local\n\x20calendar,\x20encoded\x20as\x20a\x20count\x20of\x20seconds\x20\
+ and\x20fractions\x20of\x20seconds\x20at\n\x20nanosecond\x20resolution.\
+ \x20The\x20count\x20is\x20relative\x20to\x20an\x20epoch\x20at\x20UTC\x20\
+ midnight\x20on\n\x20January\x201,\x201970,\x20in\x20the\x20proleptic\x20\
+ Gregorian\x20calendar\x20which\x20extends\x20the\n\x20Gregorian\x20calen\
+ dar\x20backwards\x20to\x20year\x20one.\n\n\x20All\x20minutes\x20are\x206\
+ 0\x20seconds\x20long.\x20Leap\x20seconds\x20are\x20\"smeared\"\x20so\x20\
+ that\x20no\x20leap\n\x20second\x20table\x20is\x20needed\x20for\x20interp\
+ retation,\x20using\x20a\x20[24-hour\x20linear\n\x20smear](https://develo\
+ pers.google.com/time/smear).\n\n\x20The\x20range\x20is\x20from\x200001-0\
+ 1-01T00:00:00Z\x20to\x209999-12-31T23:59:59.999999999Z.\x20By\n\x20restr\
+ icting\x20to\x20that\x20range,\x20we\x20ensure\x20that\x20we\x20can\x20c\
+ onvert\x20to\x20and\x20from\x20[RFC\n\x203339](https://www.ietf.org/rfc/\
+ rfc3339.txt)\x20date\x20strings.\n\n\x20#\x20Examples\n\n\x20Example\x20\
+ 1:\x20Compute\x20Timestamp\x20from\x20POSIX\x20`time()`.\n\n\x20\x20\x20\
+ \x20\x20Timestamp\x20timestamp;\n\x20\x20\x20\x20\x20timestamp.set_secon\
+ ds(time(NULL));\n\x20\x20\x20\x20\x20timestamp.set_nanos(0);\n\n\x20Exam\
+ ple\x202:\x20Compute\x20Timestamp\x20from\x20POSIX\x20`gettimeofday()`.\
+ \n\n\x20\x20\x20\x20\x20struct\x20timeval\x20tv;\n\x20\x20\x20\x20\x20ge\
+ ttimeofday(&tv,\x20NULL);\n\n\x20\x20\x20\x20\x20Timestamp\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\x20\
+ 3:\x20Compute\x20Timestamp\x20from\x20Win32\x20`GetSystemTimeAsFileTime(\
+ )`.\n\n\x20\x20\x20\x20\x20FILETIME\x20ft;\n\x20\x20\x20\x20\x20GetSyste\
+ mTimeAsFileTime(&ft);\n\x20\x20\x20\x20\x20UINT64\x20ticks\x20=\x20(((UI\
+ NT64)ft.dwHighDateTime)\x20<<\x2032)\x20|\x20ft.dwLowDateTime;\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//\x20\
+ is\x2011644473600\x20seconds\x20before\x20Unix\x20epoch\x201970-01-01T00\
+ :00:00Z.\n\x20\x20\x20\x20\x20Timestamp\x20timestamp;\n\x20\x20\x20\x20\
+ \x20timestamp.set_seconds((INT64)\x20((ticks\x20/\x2010000000)\x20-\x201\
+ 1644473600LL));\n\x20\x20\x20\x20\x20timestamp.set_nanos((INT32)\x20((ti\
+ cks\x20%\x2010000000)\x20*\x20100));\n\n\x20Example\x204:\x20Compute\x20\
+ Timestamp\x20from\x20Java\x20`System.currentTimeMillis()`.\n\n\x20\x20\
+ \x20\x20\x20long\x20millis\x20=\x20System.currentTimeMillis();\n\n\x20\
+ \x20\x20\x20\x20Timestamp\x20timestamp\x20=\x20Timestamp.newBuilder().se\
+ tSeconds(millis\x20/\x201000)\n\x20\x20\x20\x20\x20\x20\x20\x20\x20.setN\
+ anos((int)\x20((millis\x20%\x201000)\x20*\x201000000)).build();\n\n\n\
+ \x20Example\x205:\x20Compute\x20Timestamp\x20from\x20Java\x20`Instant.no\
+ w()`.\n\n\x20\x20\x20\x20\x20Instant\x20now\x20=\x20Instant.now();\n\n\
+ \x20\x20\x20\x20\x20Timestamp\x20timestamp\x20=\n\x20\x20\x20\x20\x20\
+ \x20\x20\x20\x20Timestamp.newBuilder().setSeconds(now.getEpochSecond())\
+ \n\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20.setNanos(now.getN\
+ ano()).build();\n\n\n\x20Example\x206:\x20Compute\x20Timestamp\x20from\
+ \x20current\x20time\x20in\x20Python.\n\n\x20\x20\x20\x20\x20timestamp\
+ \x20=\x20Timestamp()\n\x20\x20\x20\x20\x20timestamp.GetCurrentTime()\n\n\
+ \x20#\x20JSON\x20Mapping\n\n\x20In\x20JSON\x20format,\x20the\x20Timestam\
+ p\x20type\x20is\x20encoded\x20as\x20a\x20string\x20in\x20the\n\x20[RFC\
+ \x203339](https://www.ietf.org/rfc/rfc3339.txt)\x20format.\x20That\x20is\
+ ,\x20the\n\x20format\x20is\x20\"{year}-{month}-{day}T{hour}:{min}:{sec}[\
+ .{frac_sec}]Z\"\n\x20where\x20{year}\x20is\x20always\x20expressed\x20usi\
+ ng\x20four\x20digits\x20while\x20{month},\x20{day},\n\x20{hour},\x20{min\
+ },\x20and\x20{sec}\x20are\x20zero-padded\x20to\x20two\x20digits\x20each.\
+ \x20The\x20fractional\n\x20seconds,\x20which\x20can\x20go\x20up\x20to\
+ \x209\x20digits\x20(i.e.\x20up\x20to\x201\x20nanosecond\x20resolution),\
+ \n\x20are\x20optional.\x20The\x20\"Z\"\x20suffix\x20indicates\x20the\x20\
+ timezone\x20(\"UTC\");\x20the\x20timezone\n\x20is\x20required.\x20A\x20p\
+ roto3\x20JSON\x20serializer\x20should\x20always\x20use\x20UTC\x20(as\x20\
+ indicated\x20by\n\x20\"Z\")\x20when\x20printing\x20the\x20Timestamp\x20t\
+ ype\x20and\x20a\x20proto3\x20JSON\x20parser\x20should\x20be\n\x20able\
+ \x20to\x20accept\x20both\x20UTC\x20and\x20other\x20timezones\x20(as\x20i\
+ ndicated\x20by\x20an\x20offset).\n\n\x20For\x20example,\x20\"2017-01-15T\
+ 01:30:15.01Z\"\x20encodes\x2015.01\x20seconds\x20past\n\x2001:30\x20UTC\
+ \x20on\x20January\x2015,\x202017.\n\n\x20In\x20JavaScript,\x20one\x20can\
+ \x20convert\x20a\x20Date\x20object\x20to\x20this\x20format\x20using\x20t\
+ he\n\x20standard\n\x20[toISOString()](https://developer.mozilla.org/en-U\
+ S/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)\n\x20me\
+ thod.\x20In\x20Python,\x20a\x20standard\x20`datetime.datetime`\x20object\
+ \x20can\x20be\x20converted\n\x20to\x20this\x20format\x20using\n\x20[`str\
+ ftime`](https://docs.python.org/2/library/time.html#time.strftime)\x20wi\
+ th\n\x20the\x20time\x20format\x20spec\x20'%Y-%m-%dT%H:%M:%S.%fZ'.\x20Lik\
+ ewise,\x20in\x20Java,\x20one\x20can\x20use\n\x20the\x20Joda\x20Time's\
+ \x20[`ISODateTimeFormat.dateTime()`](\n\x20http://www.joda.org/joda-time\
+ /apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D\n\
+ \x20)\x20to\x20obtain\x20a\x20formatter\x20capable\x20of\x20generating\
+ \x20timestamps\x20in\x20this\x20format.\n\n\n\n\x0b\n\x03\x04\0\x01\x12\
+ \x04\x87\x01\x08\x11\n\x9d\x01\n\x04\x04\0\x02\0\x12\x04\x8b\x01\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\r\n\x05\
+ \x04\0\x02\0\x05\x12\x04\x8b\x01\x02\x07\n\r\n\x05\x04\0\x02\0\x01\x12\
+ \x04\x8b\x01\x08\x0f\n\r\n\x05\x04\0\x02\0\x03\x12\x04\x8b\x01\x12\x13\n\
+ \xe5\x01\n\x04\x04\0\x02\x01\x12\x04\x91\x01\x02\x12\x1a\xd6\x01\x20Non-\
+ negative\x20fractions\x20of\x20a\x20second\x20at\x20nanosecond\x20resolu\
+ tion.\x20Negative\n\x20second\x20values\x20with\x20fractions\x20must\x20\
+ still\x20have\x20non-negative\x20nanos\x20values\n\x20that\x20count\x20f\
+ orward\x20in\x20time.\x20Must\x20be\x20from\x200\x20to\x20999,999,999\n\
+ \x20inclusive.\n\n\r\n\x05\x04\0\x02\x01\x05\x12\x04\x91\x01\x02\x07\n\r\
+ \n\x05\x04\0\x02\x01\x01\x12\x04\x91\x01\x08\r\n\r\n\x05\x04\0\x02\x01\
+ \x03\x12\x04\x91\x01\x10\x11b\x06proto3\
+";
+
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+ crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
+ file_descriptor_proto_lazy.get(|| {
+ parse_descriptor_proto()
+ })
+}
diff --git a/2.27.1/src/well_known_types/type_pb.rs b/2.27.1/src/well_known_types/type_pb.rs
new file mode 100644
index 0000000..14bfdb2
--- /dev/null
+++ b/2.27.1/src/well_known_types/type_pb.rs
@@ -0,0 +1,2233 @@
+// This file is generated by rust-protobuf 2.26.0. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(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(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `google/protobuf/type.proto`
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct Type {
+ // message fields
+ pub name: ::std::string::String,
+ pub fields: crate::RepeatedField<Field>,
+ pub oneofs: crate::RepeatedField<::std::string::String>,
+ pub options: crate::RepeatedField<Option>,
+ pub source_context: crate::SingularPtrField<crate::well_known_types::SourceContext>,
+ pub syntax: Syntax,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Type {
+ fn default() -> &'a Type {
+ <Type as crate::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: crate::RepeatedField<Field>) {
+ self.fields = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_fields(&mut self) -> &mut crate::RepeatedField<Field> {
+ &mut self.fields
+ }
+
+ // Take field
+ pub fn take_fields(&mut self) -> crate::RepeatedField<Field> {
+ ::std::mem::replace(&mut self.fields, crate::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: crate::RepeatedField<::std::string::String>) {
+ self.oneofs = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_oneofs(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
+ &mut self.oneofs
+ }
+
+ // Take field
+ pub fn take_oneofs(&mut self) -> crate::RepeatedField<::std::string::String> {
+ ::std::mem::replace(&mut self.oneofs, crate::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: crate::RepeatedField<Option>) {
+ self.options = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_options(&mut self) -> &mut crate::RepeatedField<Option> {
+ &mut self.options
+ }
+
+ // Take field
+ pub fn take_options(&mut self) -> crate::RepeatedField<Option> {
+ ::std::mem::replace(&mut self.options, crate::RepeatedField::new())
+ }
+
+ // .google.protobuf.SourceContext source_context = 5;
+
+
+ pub fn get_source_context(&self) -> &crate::well_known_types::SourceContext {
+ self.source_context.as_ref().unwrap_or_else(|| <crate::well_known_types::SourceContext as crate::Message>::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: crate::well_known_types::SourceContext) {
+ self.source_context = crate::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 crate::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) -> crate::well_known_types::SourceContext {
+ self.source_context.take().unwrap_or_else(|| crate::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 crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.fields)?;
+ },
+ 3 => {
+ crate::rt::read_repeated_string_into(wire_type, is, &mut self.oneofs)?;
+ },
+ 4 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
+ },
+ 5 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.source_context)?;
+ },
+ 6 => {
+ crate::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 6, &mut self.unknown_fields)?
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &self.name);
+ }
+ for value in &self.fields {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ for value in &self.oneofs {
+ my_size += crate::rt::string_size(3, &value);
+ };
+ for value in &self.options {
+ let len = value.compute_size();
+ my_size += 1 + crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ if self.syntax != Syntax::SYNTAX_PROTO2 {
+ my_size += crate::rt::enum_size(6, self.syntax);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if !self.name.is_empty() {
+ os.write_string(1, &self.name)?;
+ }
+ for v in &self.fields {
+ os.write_tag(2, crate::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, crate::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, crate::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, crate::ProtobufEnum::value(&self.syntax))?;
+ }
+ 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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Type {
+ Type::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &Type| { &m.name },
+ |m: &mut Type| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Field>>(
+ "fields",
+ |m: &Type| { &m.fields },
+ |m: &mut Type| { &mut m.fields },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "oneofs",
+ |m: &Type| { &m.oneofs },
+ |m: &mut Type| { &mut m.oneofs },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Option>>(
+ "options",
+ |m: &Type| { &m.options },
+ |m: &mut Type| { &mut m.options },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::well_known_types::SourceContext>>(
+ "source_context",
+ |m: &Type| { &m.source_context },
+ |m: &mut Type| { &mut m.source_context },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeEnum<Syntax>>(
+ "syntax",
+ |m: &Type| { &m.syntax },
+ |m: &mut Type| { &mut m.syntax },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Type>(
+ "Type",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Type {
+ static instance: crate::rt::LazyV2<Type> = crate::rt::LazyV2::INIT;
+ instance.get(Type::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Type {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::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: crate::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: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Field {
+ fn default() -> &'a Field {
+ <Field as crate::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: crate::RepeatedField<Option>) {
+ self.options = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_options(&mut self) -> &mut crate::RepeatedField<Option> {
+ &mut self.options
+ }
+
+ // Take field
+ pub fn take_options(&mut self) -> crate::RepeatedField<Option> {
+ ::std::mem::replace(&mut self.options, crate::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 crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.kind, 1, &mut self.unknown_fields)?
+ },
+ 2 => {
+ crate::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.cardinality, 2, &mut self.unknown_fields)?
+ },
+ 3 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.number = tmp;
+ },
+ 4 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
+ },
+ 6 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.type_url)?;
+ },
+ 7 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.oneof_index = tmp;
+ },
+ 8 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.packed = tmp;
+ },
+ 9 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
+ },
+ 10 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.json_name)?;
+ },
+ 11 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.default_value)?;
+ },
+ _ => {
+ crate::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 += crate::rt::enum_size(1, self.kind);
+ }
+ if self.cardinality != Field_Cardinality::CARDINALITY_UNKNOWN {
+ my_size += crate::rt::enum_size(2, self.cardinality);
+ }
+ if self.number != 0 {
+ my_size += crate::rt::value_size(3, self.number, crate::wire_format::WireTypeVarint);
+ }
+ if !self.name.is_empty() {
+ my_size += crate::rt::string_size(4, &self.name);
+ }
+ if !self.type_url.is_empty() {
+ my_size += crate::rt::string_size(6, &self.type_url);
+ }
+ if self.oneof_index != 0 {
+ my_size += crate::rt::value_size(7, self.oneof_index, crate::wire_format::WireTypeVarint);
+ }
+ if self.packed != false {
+ my_size += 2;
+ }
+ for value in &self.options {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ if !self.json_name.is_empty() {
+ my_size += crate::rt::string_size(10, &self.json_name);
+ }
+ if !self.default_value.is_empty() {
+ my_size += crate::rt::string_size(11, &self.default_value);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if self.kind != Field_Kind::TYPE_UNKNOWN {
+ os.write_enum(1, crate::ProtobufEnum::value(&self.kind))?;
+ }
+ if self.cardinality != Field_Cardinality::CARDINALITY_UNKNOWN {
+ os.write_enum(2, crate::ProtobufEnum::value(&self.cardinality))?;
+ }
+ 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, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Field {
+ Field::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeEnum<Field_Kind>>(
+ "kind",
+ |m: &Field| { &m.kind },
+ |m: &mut Field| { &mut m.kind },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeEnum<Field_Cardinality>>(
+ "cardinality",
+ |m: &Field| { &m.cardinality },
+ |m: &mut Field| { &mut m.cardinality },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "number",
+ |m: &Field| { &m.number },
+ |m: &mut Field| { &mut m.number },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &Field| { &m.name },
+ |m: &mut Field| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "type_url",
+ |m: &Field| { &m.type_url },
+ |m: &mut Field| { &mut m.type_url },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "oneof_index",
+ |m: &Field| { &m.oneof_index },
+ |m: &mut Field| { &mut m.oneof_index },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeBool>(
+ "packed",
+ |m: &Field| { &m.packed },
+ |m: &mut Field| { &mut m.packed },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Option>>(
+ "options",
+ |m: &Field| { &m.options },
+ |m: &mut Field| { &mut m.options },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "json_name",
+ |m: &Field| { &m.json_name },
+ |m: &mut Field| { &mut m.json_name },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "default_value",
+ |m: &Field| { &m.default_value },
+ |m: &mut Field| { &mut m.default_value },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Field>(
+ "Field",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Field {
+ static instance: crate::rt::LazyV2<Field> = crate::rt::LazyV2::INIT;
+ instance.get(Field::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Field {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::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 crate::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 crate::reflect::EnumDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ crate::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 crate::reflect::ProtobufValue for Field_Kind {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
+ }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub enum Field_Cardinality {
+ CARDINALITY_UNKNOWN = 0,
+ CARDINALITY_OPTIONAL = 1,
+ CARDINALITY_REQUIRED = 2,
+ CARDINALITY_REPEATED = 3,
+}
+
+impl crate::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 crate::reflect::EnumDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ crate::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 crate::reflect::ProtobufValue for Field_Cardinality {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct Enum {
+ // message fields
+ pub name: ::std::string::String,
+ pub enumvalue: crate::RepeatedField<EnumValue>,
+ pub options: crate::RepeatedField<Option>,
+ pub source_context: crate::SingularPtrField<crate::well_known_types::SourceContext>,
+ pub syntax: Syntax,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Enum {
+ fn default() -> &'a Enum {
+ <Enum as crate::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: crate::RepeatedField<EnumValue>) {
+ self.enumvalue = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_enumvalue(&mut self) -> &mut crate::RepeatedField<EnumValue> {
+ &mut self.enumvalue
+ }
+
+ // Take field
+ pub fn take_enumvalue(&mut self) -> crate::RepeatedField<EnumValue> {
+ ::std::mem::replace(&mut self.enumvalue, crate::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: crate::RepeatedField<Option>) {
+ self.options = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_options(&mut self) -> &mut crate::RepeatedField<Option> {
+ &mut self.options
+ }
+
+ // Take field
+ pub fn take_options(&mut self) -> crate::RepeatedField<Option> {
+ ::std::mem::replace(&mut self.options, crate::RepeatedField::new())
+ }
+
+ // .google.protobuf.SourceContext source_context = 4;
+
+
+ pub fn get_source_context(&self) -> &crate::well_known_types::SourceContext {
+ self.source_context.as_ref().unwrap_or_else(|| <crate::well_known_types::SourceContext as crate::Message>::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: crate::well_known_types::SourceContext) {
+ self.source_context = crate::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 crate::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) -> crate::well_known_types::SourceContext {
+ self.source_context.take().unwrap_or_else(|| crate::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 crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.enumvalue)?;
+ },
+ 3 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
+ },
+ 4 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.source_context)?;
+ },
+ 5 => {
+ crate::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 5, &mut self.unknown_fields)?
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &self.name);
+ }
+ for value in &self.enumvalue {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ for value in &self.options {
+ let len = value.compute_size();
+ my_size += 1 + crate::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 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ if self.syntax != Syntax::SYNTAX_PROTO2 {
+ my_size += crate::rt::enum_size(5, self.syntax);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+ if !self.name.is_empty() {
+ os.write_string(1, &self.name)?;
+ }
+ for v in &self.enumvalue {
+ os.write_tag(2, crate::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, crate::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, crate::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, crate::ProtobufEnum::value(&self.syntax))?;
+ }
+ 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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Enum {
+ Enum::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &Enum| { &m.name },
+ |m: &mut Enum| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<EnumValue>>(
+ "enumvalue",
+ |m: &Enum| { &m.enumvalue },
+ |m: &mut Enum| { &mut m.enumvalue },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Option>>(
+ "options",
+ |m: &Enum| { &m.options },
+ |m: &mut Enum| { &mut m.options },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::well_known_types::SourceContext>>(
+ "source_context",
+ |m: &Enum| { &m.source_context },
+ |m: &mut Enum| { &mut m.source_context },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeEnum<Syntax>>(
+ "syntax",
+ |m: &Enum| { &m.syntax },
+ |m: &mut Enum| { &mut m.syntax },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Enum>(
+ "Enum",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Enum {
+ static instance: crate::rt::LazyV2<Enum> = crate::rt::LazyV2::INIT;
+ instance.get(Enum::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Enum {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct EnumValue {
+ // message fields
+ pub name: ::std::string::String,
+ pub number: i32,
+ pub options: crate::RepeatedField<Option>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a EnumValue {
+ fn default() -> &'a EnumValue {
+ <EnumValue as crate::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: crate::RepeatedField<Option>) {
+ self.options = v;
+ }
+
+ // Mutable pointer to the field.
+ pub fn mut_options(&mut self) -> &mut crate::RepeatedField<Option> {
+ &mut self.options
+ }
+
+ // Take field
+ pub fn take_options(&mut self) -> crate::RepeatedField<Option> {
+ ::std::mem::replace(&mut self.options, crate::RepeatedField::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.number = tmp;
+ },
+ 3 => {
+ crate::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &self.name);
+ }
+ if self.number != 0 {
+ my_size += crate::rt::value_size(2, self.number, crate::wire_format::WireTypeVarint);
+ }
+ for value in &self.options {
+ let len = value.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ };
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> EnumValue {
+ EnumValue::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &EnumValue| { &m.name },
+ |m: &mut EnumValue| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "number",
+ |m: &EnumValue| { &m.number },
+ |m: &mut EnumValue| { &mut m.number },
+ ));
+ fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Option>>(
+ "options",
+ |m: &EnumValue| { &m.options },
+ |m: &mut EnumValue| { &mut m.options },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<EnumValue>(
+ "EnumValue",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static EnumValue {
+ static instance: crate::rt::LazyV2<EnumValue> = crate::rt::LazyV2::INIT;
+ instance.get(EnumValue::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for EnumValue {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct Option {
+ // message fields
+ pub name: ::std::string::String,
+ pub value: crate::SingularPtrField<crate::well_known_types::Any>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Option {
+ fn default() -> &'a Option {
+ <Option as crate::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) -> &crate::well_known_types::Any {
+ self.value.as_ref().unwrap_or_else(|| <crate::well_known_types::Any as crate::Message>::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: crate::well_known_types::Any) {
+ self.value = crate::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 crate::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) -> crate::well_known_types::Any {
+ self.value.take().unwrap_or_else(|| crate::well_known_types::Any::new())
+ }
+}
+
+impl crate::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 crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
+ },
+ 2 => {
+ crate::rt::read_singular_message_into(wire_type, is, &mut self.value)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &self.name);
+ }
+ if let Some(ref v) = self.value.as_ref() {
+ let len = v.compute_size();
+ my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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, crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Option {
+ Option::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "name",
+ |m: &Option| { &m.name },
+ |m: &mut Option| { &mut m.name },
+ ));
+ fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::well_known_types::Any>>(
+ "value",
+ |m: &Option| { &m.value },
+ |m: &mut Option| { &mut m.value },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Option>(
+ "Option",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Option {
+ static instance: crate::rt::LazyV2<Option> = crate::rt::LazyV2::INIT;
+ instance.get(Option::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Option {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(Clone,PartialEq,Eq,Debug,Hash)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub enum Syntax {
+ SYNTAX_PROTO2 = 0,
+ SYNTAX_PROTO3 = 1,
+}
+
+impl crate::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 crate::reflect::EnumDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ crate::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 crate::reflect::ProtobufValue for Syntax {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
+ }
+}
+
+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\x01B{\n\x13com.google.protobuf\
+ B\tTypeProtoP\x01Z-google.golang.org/protobuf/types/known/typepb\xf8\x01\
+ \x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesJ\xc38\n\
+ \x07\x12\x05\x1e\0\xba\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\x20Inc.\x20\x20All\x20rights\
+ \x20reserved.\n\x20https://developers.google.com/protocol-buffers/\n\n\
+ \x20Redistribution\x20and\x20use\x20in\x20source\x20and\x20binary\x20for\
+ ms,\x20with\x20or\x20without\n\x20modification,\x20are\x20permitted\x20p\
+ rovided\x20that\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\x20\
+ of\x20conditions\x20and\x20the\x20following\x20disclaimer.\n\x20\x20\x20\
+ \x20\x20*\x20Redistributions\x20in\x20binary\x20form\x20must\x20reproduc\
+ e\x20the\x20above\n\x20copyright\x20notice,\x20this\x20list\x20of\x20con\
+ ditions\x20and\x20the\x20following\x20disclaimer\n\x20in\x20the\x20docum\
+ entation\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\x20to\x20endorse\x20or\x20promote\x20products\x20d\
+ erived\x20from\n\x20this\x20software\x20without\x20specific\x20prior\x20\
+ written\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\
+ \x20MERCHANTABILITY\x20AND\x20FITNESS\x20FOR\n\x20A\x20PARTICULAR\x20PUR\
+ POSE\x20ARE\x20DISCLAIMED.\x20IN\x20NO\x20EVENT\x20SHALL\x20THE\x20COPYR\
+ IGHT\n\x20OWNER\x20OR\x20CONTRIBUTORS\x20BE\x20LIABLE\x20FOR\x20ANY\x20D\
+ IRECT,\x20INDIRECT,\x20INCIDENTAL,\n\x20SPECIAL,\x20EXEMPLARY,\x20OR\x20\
+ CONSEQUENTIAL\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\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\x08\n\x01\x08\x12\x03+\0D\n\t\n\x02\x08\x0b\x12\
+ \x03+\0D\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\x030\x02\x12\x1a#\x20The\x20fully\x20qualified\x20message\
+ \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\x032\x02\x1c\x1a\x15\x20The\x20list\x20of\x20\
+ fields.\n\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x032\x02\n\n\x0c\n\x05\x04\0\
+ \x02\x01\x06\x12\x032\x0b\x10\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x032\x11\
+ \x17\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x032\x1a\x1b\nO\n\x04\x04\0\x02\
+ \x02\x12\x034\x02\x1d\x1aB\x20The\x20list\x20of\x20types\x20appearing\
+ \x20in\x20`oneof`\x20definitions\x20in\x20this\x20type.\n\n\x0c\n\x05\
+ \x04\0\x02\x02\x04\x12\x034\x02\n\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x034\
+ \x0b\x11\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x034\x12\x18\n\x0c\n\x05\x04\
+ \0\x02\x02\x03\x12\x034\x1b\x1c\n+\n\x04\x04\0\x02\x03\x12\x036\x02\x1e\
+ \x1a\x1e\x20The\x20protocol\x20buffer\x20options.\n\n\x0c\n\x05\x04\0\
+ \x02\x03\x04\x12\x036\x02\n\n\x0c\n\x05\x04\0\x02\x03\x06\x12\x036\x0b\
+ \x11\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x036\x12\x19\n\x0c\n\x05\x04\0\
+ \x02\x03\x03\x12\x036\x1c\x1d\n\"\n\x04\x04\0\x02\x04\x12\x038\x02#\x1a\
+ \x15\x20The\x20source\x20context.\n\n\x0c\n\x05\x04\0\x02\x04\x06\x12\
+ \x038\x02\x0f\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x038\x10\x1e\n\x0c\n\x05\
+ \x04\0\x02\x04\x03\x12\x038!\"\n!\n\x04\x04\0\x02\x05\x12\x03:\x02\x14\
+ \x1a\x14\x20The\x20source\x20syntax.\n\n\x0c\n\x05\x04\0\x02\x05\x06\x12\
+ \x03:\x02\x08\n\x0c\n\x05\x04\0\x02\x05\x01\x12\x03:\t\x0f\n\x0c\n\x05\
+ \x04\0\x02\x05\x03\x12\x03:\x12\x13\n0\n\x02\x04\x01\x12\x05>\0\x8b\x01\
+ \x01\x1a#\x20A\x20single\x20field\x20of\x20a\x20message\x20type.\n\n\n\n\
+ \x03\x04\x01\x01\x12\x03>\x08\r\n\"\n\x04\x04\x01\x04\0\x12\x04@\x02g\
+ \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\x03B\x04\x15\x1a\x15\
+ \x20Field\x20type\x20unknown.\n\n\x0e\n\x07\x04\x01\x04\0\x02\0\x01\x12\
+ \x03B\x04\x10\n\x0e\n\x07\x04\x01\x04\0\x02\0\x02\x12\x03B\x13\x14\n#\n\
+ \x06\x04\x01\x04\0\x02\x01\x12\x03D\x04\x14\x1a\x14\x20Field\x20type\x20\
+ double.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x01\x01\x12\x03D\x04\x0f\n\x0e\n\
+ \x07\x04\x01\x04\0\x02\x01\x02\x12\x03D\x12\x13\n\"\n\x06\x04\x01\x04\0\
+ \x02\x02\x12\x03F\x04\x13\x1a\x13\x20Field\x20type\x20float.\n\n\x0e\n\
+ \x07\x04\x01\x04\0\x02\x02\x01\x12\x03F\x04\x0e\n\x0e\n\x07\x04\x01\x04\
+ \0\x02\x02\x02\x12\x03F\x11\x12\n\"\n\x06\x04\x01\x04\0\x02\x03\x12\x03H\
+ \x04\x13\x1a\x13\x20Field\x20type\x20int64.\n\n\x0e\n\x07\x04\x01\x04\0\
+ \x02\x03\x01\x12\x03H\x04\x0e\n\x0e\n\x07\x04\x01\x04\0\x02\x03\x02\x12\
+ \x03H\x11\x12\n#\n\x06\x04\x01\x04\0\x02\x04\x12\x03J\x04\x14\x1a\x14\
+ \x20Field\x20type\x20uint64.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x04\x01\x12\
+ \x03J\x04\x0f\n\x0e\n\x07\x04\x01\x04\0\x02\x04\x02\x12\x03J\x12\x13\n\"\
+ \n\x06\x04\x01\x04\0\x02\x05\x12\x03L\x04\x13\x1a\x13\x20Field\x20type\
+ \x20int32.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x05\x01\x12\x03L\x04\x0e\n\
+ \x0e\n\x07\x04\x01\x04\0\x02\x05\x02\x12\x03L\x11\x12\n$\n\x06\x04\x01\
+ \x04\0\x02\x06\x12\x03N\x04\x15\x1a\x15\x20Field\x20type\x20fixed64.\n\n\
+ \x0e\n\x07\x04\x01\x04\0\x02\x06\x01\x12\x03N\x04\x10\n\x0e\n\x07\x04\
+ \x01\x04\0\x02\x06\x02\x12\x03N\x13\x14\n$\n\x06\x04\x01\x04\0\x02\x07\
+ \x12\x03P\x04\x15\x1a\x15\x20Field\x20type\x20fixed32.\n\n\x0e\n\x07\x04\
+ \x01\x04\0\x02\x07\x01\x12\x03P\x04\x10\n\x0e\n\x07\x04\x01\x04\0\x02\
+ \x07\x02\x12\x03P\x13\x14\n!\n\x06\x04\x01\x04\0\x02\x08\x12\x03R\x04\
+ \x12\x1a\x12\x20Field\x20type\x20bool.\n\n\x0e\n\x07\x04\x01\x04\0\x02\
+ \x08\x01\x12\x03R\x04\r\n\x0e\n\x07\x04\x01\x04\0\x02\x08\x02\x12\x03R\
+ \x10\x11\n#\n\x06\x04\x01\x04\0\x02\t\x12\x03T\x04\x14\x1a\x14\x20Field\
+ \x20type\x20string.\n\n\x0e\n\x07\x04\x01\x04\0\x02\t\x01\x12\x03T\x04\
+ \x0f\n\x0e\n\x07\x04\x01\x04\0\x02\t\x02\x12\x03T\x12\x13\nF\n\x06\x04\
+ \x01\x04\0\x02\n\x12\x03V\x04\x14\x1a7\x20Field\x20type\x20group.\x20Pro\
+ to2\x20syntax\x20only,\x20and\x20deprecated.\n\n\x0e\n\x07\x04\x01\x04\0\
+ \x02\n\x01\x12\x03V\x04\x0e\n\x0e\n\x07\x04\x01\x04\0\x02\n\x02\x12\x03V\
+ \x11\x13\n$\n\x06\x04\x01\x04\0\x02\x0b\x12\x03X\x04\x16\x1a\x15\x20Fiel\
+ d\x20type\x20message.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x0b\x01\x12\x03X\
+ \x04\x10\n\x0e\n\x07\x04\x01\x04\0\x02\x0b\x02\x12\x03X\x13\x15\n\"\n\
+ \x06\x04\x01\x04\0\x02\x0c\x12\x03Z\x04\x14\x1a\x13\x20Field\x20type\x20\
+ bytes.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x0c\x01\x12\x03Z\x04\x0e\n\x0e\n\
+ \x07\x04\x01\x04\0\x02\x0c\x02\x12\x03Z\x11\x13\n#\n\x06\x04\x01\x04\0\
+ \x02\r\x12\x03\\\x04\x15\x1a\x14\x20Field\x20type\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\\\x12\x14\n!\n\x06\x04\x01\x04\0\x02\x0e\x12\x03^\x04\
+ \x13\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^\
+ \x10\x12\n%\n\x06\x04\x01\x04\0\x02\x0f\x12\x03`\x04\x17\x1a\x16\x20Fiel\
+ d\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`\x14\x16\n%\n\x06\
+ \x04\x01\x04\0\x02\x10\x12\x03b\x04\x17\x1a\x16\x20Field\x20type\x20sfix\
+ ed64.\n\n\x0e\n\x07\x04\x01\x04\0\x02\x10\x01\x12\x03b\x04\x11\n\x0e\n\
+ \x07\x04\x01\x04\0\x02\x10\x02\x12\x03b\x14\x16\n#\n\x06\x04\x01\x04\0\
+ \x02\x11\x12\x03d\x04\x15\x1a\x14\x20Field\x20type\x20sint32.\n\n\x0e\n\
+ \x07\x04\x01\x04\0\x02\x11\x01\x12\x03d\x04\x0f\n\x0e\n\x07\x04\x01\x04\
+ \0\x02\x11\x02\x12\x03d\x12\x14\n#\n\x06\x04\x01\x04\0\x02\x12\x12\x03f\
+ \x04\x15\x1a\x14\x20Field\x20type\x20sint64.\n\n\x0e\n\x07\x04\x01\x04\0\
+ \x02\x12\x01\x12\x03f\x04\x0f\n\x0e\n\x07\x04\x01\x04\0\x02\x12\x02\x12\
+ \x03f\x12\x14\nC\n\x04\x04\x01\x04\x01\x12\x04j\x02s\x03\x1a5\x20Whether\
+ \x20a\x20field\x20is\x20optional,\x20required,\x20or\x20repeated.\n\n\
+ \x0c\n\x05\x04\x01\x04\x01\x01\x12\x03j\x07\x12\n5\n\x06\x04\x01\x04\x01\
+ \x02\0\x12\x03l\x04\x1c\x1a&\x20For\x20fields\x20with\x20unknown\x20card\
+ inality.\n\n\x0e\n\x07\x04\x01\x04\x01\x02\0\x01\x12\x03l\x04\x17\n\x0e\
+ \n\x07\x04\x01\x04\x01\x02\0\x02\x12\x03l\x1a\x1b\n%\n\x06\x04\x01\x04\
+ \x01\x02\x01\x12\x03n\x04\x1d\x1a\x16\x20For\x20optional\x20fields.\n\n\
+ \x0e\n\x07\x04\x01\x04\x01\x02\x01\x01\x12\x03n\x04\x18\n\x0e\n\x07\x04\
+ \x01\x04\x01\x02\x01\x02\x12\x03n\x1b\x1c\n9\n\x06\x04\x01\x04\x01\x02\
+ \x02\x12\x03p\x04\x1d\x1a*\x20For\x20required\x20fields.\x20Proto2\x20sy\
+ ntax\x20only.\n\n\x0e\n\x07\x04\x01\x04\x01\x02\x02\x01\x12\x03p\x04\x18\
+ \n\x0e\n\x07\x04\x01\x04\x01\x02\x02\x02\x12\x03p\x1b\x1c\n%\n\x06\x04\
+ \x01\x04\x01\x02\x03\x12\x03r\x04\x1d\x1a\x16\x20For\x20repeated\x20fiel\
+ ds.\n\n\x0e\n\x07\x04\x01\x04\x01\x02\x03\x01\x12\x03r\x04\x18\n\x0e\n\
+ \x07\x04\x01\x04\x01\x02\x03\x02\x12\x03r\x1b\x1c\n\x1e\n\x04\x04\x01\
+ \x02\0\x12\x03v\x02\x10\x1a\x11\x20The\x20field\x20type.\n\n\x0c\n\x05\
+ \x04\x01\x02\0\x06\x12\x03v\x02\x06\n\x0c\n\x05\x04\x01\x02\0\x01\x12\
+ \x03v\x07\x0b\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03v\x0e\x0f\n%\n\x04\
+ \x04\x01\x02\x01\x12\x03x\x02\x1e\x1a\x18\x20The\x20field\x20cardinality\
+ .\n\n\x0c\n\x05\x04\x01\x02\x01\x06\x12\x03x\x02\r\n\x0c\n\x05\x04\x01\
+ \x02\x01\x01\x12\x03x\x0e\x19\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03x\
+ \x1c\x1d\n\x20\n\x04\x04\x01\x02\x02\x12\x03z\x02\x13\x1a\x13\x20The\x20\
+ field\x20number.\n\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03z\x02\x07\n\
+ \x0c\n\x05\x04\x01\x02\x02\x01\x12\x03z\x08\x0e\n\x0c\n\x05\x04\x01\x02\
+ \x02\x03\x12\x03z\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\x7f\x02\x16\x1a\x88\x01\x20The\x20field\x20type\x20URL,\x20with\
+ out\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\x7f\x02\x08\n\x0c\n\x05\x04\x01\
+ \x02\x04\x01\x12\x03\x7f\t\x11\n\x0c\n\x05\x04\x01\x02\x04\x03\x12\x03\
+ \x7f\x14\x15\n\xa5\x01\n\x04\x04\x01\x02\x05\x12\x04\x82\x01\x02\x18\x1a\
+ \x96\x01\x20The\x20index\x20of\x20the\x20field\x20type\x20in\x20`Type.on\
+ eofs`,\x20for\x20message\x20or\x20enumeration\n\x20types.\x20The\x20firs\
+ t\x20type\x20has\x20index\x201;\x20zero\x20means\x20the\x20type\x20is\
+ \x20not\x20in\x20the\x20list.\n\n\r\n\x05\x04\x01\x02\x05\x05\x12\x04\
+ \x82\x01\x02\x07\n\r\n\x05\x04\x01\x02\x05\x01\x12\x04\x82\x01\x08\x13\n\
+ \r\n\x05\x04\x01\x02\x05\x03\x12\x04\x82\x01\x16\x17\nF\n\x04\x04\x01\
+ \x02\x06\x12\x04\x84\x01\x02\x12\x1a8\x20Whether\x20to\x20use\x20alterna\
+ tive\x20packed\x20wire\x20representation.\n\n\r\n\x05\x04\x01\x02\x06\
+ \x05\x12\x04\x84\x01\x02\x06\n\r\n\x05\x04\x01\x02\x06\x01\x12\x04\x84\
+ \x01\x07\r\n\r\n\x05\x04\x01\x02\x06\x03\x12\x04\x84\x01\x10\x11\n,\n\
+ \x04\x04\x01\x02\x07\x12\x04\x86\x01\x02\x1e\x1a\x1e\x20The\x20protocol\
+ \x20buffer\x20options.\n\n\r\n\x05\x04\x01\x02\x07\x04\x12\x04\x86\x01\
+ \x02\n\n\r\n\x05\x04\x01\x02\x07\x06\x12\x04\x86\x01\x0b\x11\n\r\n\x05\
+ \x04\x01\x02\x07\x01\x12\x04\x86\x01\x12\x19\n\r\n\x05\x04\x01\x02\x07\
+ \x03\x12\x04\x86\x01\x1c\x1d\n$\n\x04\x04\x01\x02\x08\x12\x04\x88\x01\
+ \x02\x18\x1a\x16\x20The\x20field\x20JSON\x20name.\n\n\r\n\x05\x04\x01\
+ \x02\x08\x05\x12\x04\x88\x01\x02\x08\n\r\n\x05\x04\x01\x02\x08\x01\x12\
+ \x04\x88\x01\t\x12\n\r\n\x05\x04\x01\x02\x08\x03\x12\x04\x88\x01\x15\x17\
+ \nX\n\x04\x04\x01\x02\t\x12\x04\x8a\x01\x02\x1c\x1aJ\x20The\x20string\
+ \x20value\x20of\x20the\x20default\x20value\x20of\x20this\x20field.\x20Pr\
+ oto2\x20syntax\x20only.\n\n\r\n\x05\x04\x01\x02\t\x05\x12\x04\x8a\x01\
+ \x02\x08\n\r\n\x05\x04\x01\x02\t\x01\x12\x04\x8a\x01\t\x16\n\r\n\x05\x04\
+ \x01\x02\t\x03\x12\x04\x8a\x01\x19\x1b\n%\n\x02\x04\x02\x12\x06\x8e\x01\
+ \0\x99\x01\x01\x1a\x17\x20Enum\x20type\x20definition.\n\n\x0b\n\x03\x04\
+ \x02\x01\x12\x04\x8e\x01\x08\x0c\n\x1f\n\x04\x04\x02\x02\0\x12\x04\x90\
+ \x01\x02\x12\x1a\x11\x20Enum\x20type\x20name.\n\n\r\n\x05\x04\x02\x02\0\
+ \x05\x12\x04\x90\x01\x02\x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\x90\x01\
+ \t\r\n\r\n\x05\x04\x02\x02\0\x03\x12\x04\x90\x01\x10\x11\n'\n\x04\x04\
+ \x02\x02\x01\x12\x04\x92\x01\x02#\x1a\x19\x20Enum\x20value\x20definition\
+ s.\n\n\r\n\x05\x04\x02\x02\x01\x04\x12\x04\x92\x01\x02\n\n\r\n\x05\x04\
+ \x02\x02\x01\x06\x12\x04\x92\x01\x0b\x14\n\r\n\x05\x04\x02\x02\x01\x01\
+ \x12\x04\x92\x01\x15\x1e\n\r\n\x05\x04\x02\x02\x01\x03\x12\x04\x92\x01!\
+ \"\n(\n\x04\x04\x02\x02\x02\x12\x04\x94\x01\x02\x1e\x1a\x1a\x20Protocol\
+ \x20buffer\x20options.\n\n\r\n\x05\x04\x02\x02\x02\x04\x12\x04\x94\x01\
+ \x02\n\n\r\n\x05\x04\x02\x02\x02\x06\x12\x04\x94\x01\x0b\x11\n\r\n\x05\
+ \x04\x02\x02\x02\x01\x12\x04\x94\x01\x12\x19\n\r\n\x05\x04\x02\x02\x02\
+ \x03\x12\x04\x94\x01\x1c\x1d\n#\n\x04\x04\x02\x02\x03\x12\x04\x96\x01\
+ \x02#\x1a\x15\x20The\x20source\x20context.\n\n\r\n\x05\x04\x02\x02\x03\
+ \x06\x12\x04\x96\x01\x02\x0f\n\r\n\x05\x04\x02\x02\x03\x01\x12\x04\x96\
+ \x01\x10\x1e\n\r\n\x05\x04\x02\x02\x03\x03\x12\x04\x96\x01!\"\n\"\n\x04\
+ \x04\x02\x02\x04\x12\x04\x98\x01\x02\x14\x1a\x14\x20The\x20source\x20syn\
+ tax.\n\n\r\n\x05\x04\x02\x02\x04\x06\x12\x04\x98\x01\x02\x08\n\r\n\x05\
+ \x04\x02\x02\x04\x01\x12\x04\x98\x01\t\x0f\n\r\n\x05\x04\x02\x02\x04\x03\
+ \x12\x04\x98\x01\x12\x13\n&\n\x02\x04\x03\x12\x06\x9c\x01\0\xa3\x01\x01\
+ \x1a\x18\x20Enum\x20value\x20definition.\n\n\x0b\n\x03\x04\x03\x01\x12\
+ \x04\x9c\x01\x08\x11\n\x20\n\x04\x04\x03\x02\0\x12\x04\x9e\x01\x02\x12\
+ \x1a\x12\x20Enum\x20value\x20name.\n\n\r\n\x05\x04\x03\x02\0\x05\x12\x04\
+ \x9e\x01\x02\x08\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\x9e\x01\t\r\n\r\n\
+ \x05\x04\x03\x02\0\x03\x12\x04\x9e\x01\x10\x11\n\"\n\x04\x04\x03\x02\x01\
+ \x12\x04\xa0\x01\x02\x13\x1a\x14\x20Enum\x20value\x20number.\n\n\r\n\x05\
+ \x04\x03\x02\x01\x05\x12\x04\xa0\x01\x02\x07\n\r\n\x05\x04\x03\x02\x01\
+ \x01\x12\x04\xa0\x01\x08\x0e\n\r\n\x05\x04\x03\x02\x01\x03\x12\x04\xa0\
+ \x01\x11\x12\n(\n\x04\x04\x03\x02\x02\x12\x04\xa2\x01\x02\x1e\x1a\x1a\
+ \x20Protocol\x20buffer\x20options.\n\n\r\n\x05\x04\x03\x02\x02\x04\x12\
+ \x04\xa2\x01\x02\n\n\r\n\x05\x04\x03\x02\x02\x06\x12\x04\xa2\x01\x0b\x11\
+ \n\r\n\x05\x04\x03\x02\x02\x01\x12\x04\xa2\x01\x12\x19\n\r\n\x05\x04\x03\
+ \x02\x02\x03\x12\x04\xa2\x01\x1c\x1d\ng\n\x02\x04\x04\x12\x06\xa7\x01\0\
+ \xb2\x01\x01\x1aY\x20A\x20protocol\x20buffer\x20option,\x20which\x20can\
+ \x20be\x20attached\x20to\x20a\x20message,\x20field,\n\x20enumeration,\
+ \x20etc.\n\n\x0b\n\x03\x04\x04\x01\x12\x04\xa7\x01\x08\x0e\n\xfc\x01\n\
+ \x04\x04\x04\x02\0\x12\x04\xac\x01\x02\x12\x1a\xed\x01\x20The\x20option'\
+ s\x20name.\x20For\x20protobuf\x20built-in\x20options\x20(options\x20defi\
+ ned\x20in\n\x20descriptor.proto),\x20this\x20is\x20the\x20short\x20name.\
+ \x20For\x20example,\x20`\"map_entry\"`.\n\x20For\x20custom\x20options,\
+ \x20it\x20should\x20be\x20the\x20fully-qualified\x20name.\x20For\x20exam\
+ ple,\n\x20`\"google.api.http\"`.\n\n\r\n\x05\x04\x04\x02\0\x05\x12\x04\
+ \xac\x01\x02\x08\n\r\n\x05\x04\x04\x02\0\x01\x12\x04\xac\x01\t\r\n\r\n\
+ \x05\x04\x04\x02\0\x03\x12\x04\xac\x01\x10\x11\n\xa0\x02\n\x04\x04\x04\
+ \x02\x01\x12\x04\xb1\x01\x02\x10\x1a\x91\x02\x20The\x20option's\x20value\
+ \x20packed\x20in\x20an\x20Any\x20message.\x20If\x20the\x20value\x20is\
+ \x20a\x20primitive,\n\x20the\x20corresponding\x20wrapper\x20type\x20defi\
+ ned\x20in\x20google/protobuf/wrappers.proto\n\x20should\x20be\x20used.\
+ \x20If\x20the\x20value\x20is\x20an\x20enum,\x20it\x20should\x20be\x20sto\
+ red\x20as\x20an\x20int32\n\x20value\x20using\x20the\x20google.protobuf.I\
+ nt32Value\x20type.\n\n\r\n\x05\x04\x04\x02\x01\x06\x12\x04\xb1\x01\x02\
+ \x05\n\r\n\x05\x04\x04\x02\x01\x01\x12\x04\xb1\x01\x06\x0b\n\r\n\x05\x04\
+ \x04\x02\x01\x03\x12\x04\xb1\x01\x0e\x0f\nI\n\x02\x05\0\x12\x06\xb5\x01\
+ \0\xba\x01\x01\x1a;\x20The\x20syntax\x20in\x20which\x20a\x20protocol\x20\
+ buffer\x20element\x20is\x20defined.\n\n\x0b\n\x03\x05\0\x01\x12\x04\xb5\
+ \x01\x05\x0b\n\x20\n\x04\x05\0\x02\0\x12\x04\xb7\x01\x02\x14\x1a\x12\x20\
+ Syntax\x20`proto2`.\n\n\r\n\x05\x05\0\x02\0\x01\x12\x04\xb7\x01\x02\x0f\
+ \n\r\n\x05\x05\0\x02\0\x02\x12\x04\xb7\x01\x12\x13\n\x20\n\x04\x05\0\x02\
+ \x01\x12\x04\xb9\x01\x02\x14\x1a\x12\x20Syntax\x20`proto3`.\n\n\r\n\x05\
+ \x05\0\x02\x01\x01\x12\x04\xb9\x01\x02\x0f\n\r\n\x05\x05\0\x02\x01\x02\
+ \x12\x04\xb9\x01\x12\x13b\x06proto3\
+";
+
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+ crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
+ file_descriptor_proto_lazy.get(|| {
+ parse_descriptor_proto()
+ })
+}
diff --git a/2.27.1/src/well_known_types/wrappers.rs b/2.27.1/src/well_known_types/wrappers.rs
new file mode 100644
index 0000000..4e056c7
--- /dev/null
+++ b/2.27.1/src/well_known_types/wrappers.rs
@@ -0,0 +1,1562 @@
+// This file is generated by rust-protobuf 2.26.0. Do not edit
+// @generated
+
+// https://github.com/rust-lang/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy::all)]
+
+#![allow(unused_attributes)]
+#![cfg_attr(rustfmt, rustfmt::skip)]
+
+#![allow(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(unused_imports)]
+#![allow(unused_results)]
+//! Generated file from `google/protobuf/wrappers.proto`
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct DoubleValue {
+ // message fields
+ pub value: f64,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a DoubleValue {
+ fn default() -> &'a DoubleValue {
+ <DoubleValue as crate::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 crate::Message for DoubleValue {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeFixed64 {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_double()?;
+ self.value = tmp;
+ },
+ _ => {
+ crate::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 += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> DoubleValue {
+ DoubleValue::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeDouble>(
+ "value",
+ |m: &DoubleValue| { &m.value },
+ |m: &mut DoubleValue| { &mut m.value },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<DoubleValue>(
+ "DoubleValue",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static DoubleValue {
+ static instance: crate::rt::LazyV2<DoubleValue> = crate::rt::LazyV2::INIT;
+ instance.get(DoubleValue::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for DoubleValue {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct FloatValue {
+ // message fields
+ pub value: f32,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a FloatValue {
+ fn default() -> &'a FloatValue {
+ <FloatValue as crate::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 crate::Message for FloatValue {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeFixed32 {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_float()?;
+ self.value = tmp;
+ },
+ _ => {
+ crate::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 += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> FloatValue {
+ FloatValue::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeFloat>(
+ "value",
+ |m: &FloatValue| { &m.value },
+ |m: &mut FloatValue| { &mut m.value },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<FloatValue>(
+ "FloatValue",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static FloatValue {
+ static instance: crate::rt::LazyV2<FloatValue> = crate::rt::LazyV2::INIT;
+ instance.get(FloatValue::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for FloatValue {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct Int64Value {
+ // message fields
+ pub value: i64,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Int64Value {
+ fn default() -> &'a Int64Value {
+ <Int64Value as crate::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 crate::Message for Int64Value {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int64()?;
+ self.value = tmp;
+ },
+ _ => {
+ crate::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 += crate::rt::value_size(1, self.value, crate::wire_format::WireTypeVarint);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Int64Value {
+ Int64Value::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt64>(
+ "value",
+ |m: &Int64Value| { &m.value },
+ |m: &mut Int64Value| { &mut m.value },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Int64Value>(
+ "Int64Value",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Int64Value {
+ static instance: crate::rt::LazyV2<Int64Value> = crate::rt::LazyV2::INIT;
+ instance.get(Int64Value::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Int64Value {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct UInt64Value {
+ // message fields
+ pub value: u64,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a UInt64Value {
+ fn default() -> &'a UInt64Value {
+ <UInt64Value as crate::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 crate::Message for UInt64Value {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_uint64()?;
+ self.value = tmp;
+ },
+ _ => {
+ crate::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 += crate::rt::value_size(1, self.value, crate::wire_format::WireTypeVarint);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> UInt64Value {
+ UInt64Value::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeUint64>(
+ "value",
+ |m: &UInt64Value| { &m.value },
+ |m: &mut UInt64Value| { &mut m.value },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<UInt64Value>(
+ "UInt64Value",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static UInt64Value {
+ static instance: crate::rt::LazyV2<UInt64Value> = crate::rt::LazyV2::INIT;
+ instance.get(UInt64Value::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for UInt64Value {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct Int32Value {
+ // message fields
+ pub value: i32,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a Int32Value {
+ fn default() -> &'a Int32Value {
+ <Int32Value as crate::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 crate::Message for Int32Value {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_int32()?;
+ self.value = tmp;
+ },
+ _ => {
+ crate::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 += crate::rt::value_size(1, self.value, crate::wire_format::WireTypeVarint);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> Int32Value {
+ Int32Value::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt32>(
+ "value",
+ |m: &Int32Value| { &m.value },
+ |m: &mut Int32Value| { &mut m.value },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<Int32Value>(
+ "Int32Value",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static Int32Value {
+ static instance: crate::rt::LazyV2<Int32Value> = crate::rt::LazyV2::INIT;
+ instance.get(Int32Value::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for Int32Value {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct UInt32Value {
+ // message fields
+ pub value: u32,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a UInt32Value {
+ fn default() -> &'a UInt32Value {
+ <UInt32Value as crate::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 crate::Message for UInt32Value {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_uint32()?;
+ self.value = tmp;
+ },
+ _ => {
+ crate::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 += crate::rt::value_size(1, self.value, crate::wire_format::WireTypeVarint);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> UInt32Value {
+ UInt32Value::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeUint32>(
+ "value",
+ |m: &UInt32Value| { &m.value },
+ |m: &mut UInt32Value| { &mut m.value },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<UInt32Value>(
+ "UInt32Value",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static UInt32Value {
+ static instance: crate::rt::LazyV2<UInt32Value> = crate::rt::LazyV2::INIT;
+ instance.get(UInt32Value::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for UInt32Value {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct BoolValue {
+ // message fields
+ pub value: bool,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a BoolValue {
+ fn default() -> &'a BoolValue {
+ <BoolValue as crate::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 crate::Message for BoolValue {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ if wire_type != crate::wire_format::WireTypeVarint {
+ return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
+ }
+ let tmp = is.read_bool()?;
+ self.value = tmp;
+ },
+ _ => {
+ crate::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 += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> BoolValue {
+ BoolValue::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeBool>(
+ "value",
+ |m: &BoolValue| { &m.value },
+ |m: &mut BoolValue| { &mut m.value },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<BoolValue>(
+ "BoolValue",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static BoolValue {
+ static instance: crate::rt::LazyV2<BoolValue> = crate::rt::LazyV2::INIT;
+ instance.get(BoolValue::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for BoolValue {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct StringValue {
+ // message fields
+ pub value: ::std::string::String,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a StringValue {
+ fn default() -> &'a StringValue {
+ <StringValue as crate::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 crate::Message for StringValue {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.value)?;
+ },
+ _ => {
+ crate::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 += crate::rt::string_size(1, &self.value);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> StringValue {
+ StringValue::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
+ "value",
+ |m: &StringValue| { &m.value },
+ |m: &mut StringValue| { &mut m.value },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<StringValue>(
+ "StringValue",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static StringValue {
+ static instance: crate::rt::LazyV2<StringValue> = crate::rt::LazyV2::INIT;
+ instance.get(StringValue::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for StringValue {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::reflect::ReflectValueRef::Message(self)
+ }
+}
+
+#[derive(PartialEq,Clone,Default)]
+#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
+pub struct BytesValue {
+ // message fields
+ pub value: ::std::vec::Vec<u8>,
+ // special fields
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub unknown_fields: crate::UnknownFields,
+ #[cfg_attr(feature = "with-serde", serde(skip))]
+ pub cached_size: crate::CachedSize,
+}
+
+impl<'a> ::std::default::Default for &'a BytesValue {
+ fn default() -> &'a BytesValue {
+ <BytesValue as crate::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 crate::Message for BytesValue {
+ fn is_initialized(&self) -> bool {
+ true
+ }
+
+ fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
+ while !is.eof()? {
+ let (field_number, wire_type) = is.read_tag_unpack()?;
+ match field_number {
+ 1 => {
+ crate::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
+ },
+ _ => {
+ crate::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 += crate::rt::bytes_size(1, &self.value);
+ }
+ my_size += crate::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 crate::CodedOutputStream<'_>) -> crate::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) -> &crate::UnknownFields {
+ &self.unknown_fields
+ }
+
+ fn mut_unknown_fields(&mut self) -> &mut crate::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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+ self
+ }
+
+ fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
+ Self::descriptor_static()
+ }
+
+ fn new() -> BytesValue {
+ BytesValue::new()
+ }
+
+ fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+ static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
+ descriptor.get(|| {
+ let mut fields = ::std::vec::Vec::new();
+ fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeBytes>(
+ "value",
+ |m: &BytesValue| { &m.value },
+ |m: &mut BytesValue| { &mut m.value },
+ ));
+ crate::reflect::MessageDescriptor::new_pb_name::<BytesValue>(
+ "BytesValue",
+ fields,
+ file_descriptor_proto()
+ )
+ })
+ }
+
+ fn default_instance() -> &'static BytesValue {
+ static instance: crate::rt::LazyV2<BytesValue> = crate::rt::LazyV2::INIT;
+ instance.get(BytesValue::new)
+ }
+}
+
+impl crate::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 {
+ crate::text_format::fmt(self, f)
+ }
+}
+
+impl crate::reflect::ProtobufValue for BytesValue {
+ fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+ crate::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\x83\x01\n\x13com.google.protobufB\rW\
+ rappersProtoP\x01Z1google.golang.org/protobuf/types/known/wrapperspb\xf8\
+ \x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesJ\xc6\
+ \x1f\n\x06\x12\x04(\0z\x01\n\xdb\x10\n\x01\x0c\x12\x03(\0\x122\xc1\x0c\
+ \x20Protocol\x20Buffers\x20-\x20Google's\x20data\x20interchange\x20forma\
+ t\n\x20Copyright\x202008\x20Google\x20Inc.\x20\x20All\x20rights\x20reser\
+ ved.\n\x20https://developers.google.com/protocol-buffers/\n\n\x20Redistr\
+ ibution\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.\n2\x8c\x04\x20Wrappers\x20for\x20primitive\x20(non-message)\x20ty\
+ pes.\x20These\x20types\x20are\x20useful\n\x20for\x20embedding\x20primiti\
+ ves\x20in\x20the\x20`google.protobuf.Any`\x20type\x20and\x20for\x20place\
+ s\n\x20where\x20we\x20need\x20to\x20distinguish\x20between\x20the\x20abs\
+ ence\x20of\x20a\x20primitive\n\x20typed\x20field\x20and\x20its\x20defaul\
+ t\x20value.\n\n\x20These\x20wrappers\x20have\x20no\x20meaningful\x20use\
+ \x20within\x20repeated\x20fields\x20as\x20they\x20lack\n\x20the\x20abili\
+ ty\x20to\x20detect\x20presence\x20on\x20individual\x20elements.\n\x20The\
+ se\x20wrappers\x20have\x20no\x20meaningful\x20use\x20within\x20a\x20map\
+ \x20or\x20a\x20oneof\x20since\n\x20individual\x20entries\x20of\x20a\x20m\
+ ap\x20or\x20fields\x20of\x20a\x20oneof\x20can\x20already\x20detect\x20pr\
+ esence.\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.\0H\n\t\n\x02\x08\x0b\x12\x03.\0\
+ H\n\x08\n\x01\x08\x12\x03/\0,\n\t\n\x02\x08\x01\x12\x03/\0,\n\x08\n\x01\
+ \x08\x12\x030\0.\n\t\n\x02\x08\x08\x12\x030\0.\n\x08\n\x01\x08\x12\x031\
+ \0\"\n\t\n\x02\x08\n\x12\x031\0\"\n\x08\n\x01\x08\x12\x032\0!\n\t\n\x02\
+ \x08$\x12\x032\0!\ng\n\x02\x04\0\x12\x047\0:\x01\x1a[\x20Wrapper\x20mess\
+ age\x20for\x20`double`.\n\n\x20The\x20JSON\x20representation\x20for\x20`\
+ DoubleValue`\x20is\x20JSON\x20number.\n\n\n\n\x03\x04\0\x01\x12\x037\x08\
+ \x13\n\x20\n\x04\x04\0\x02\0\x12\x039\x02\x13\x1a\x13\x20The\x20double\
+ \x20value.\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x039\x02\x08\n\x0c\n\x05\
+ \x04\0\x02\0\x01\x12\x039\t\x0e\n\x0c\n\x05\x04\0\x02\0\x03\x12\x039\x11\
+ \x12\ne\n\x02\x04\x01\x12\x04?\0B\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\x03A\x02\x12\x1a\x12\x20The\x20float\x20value.\
+ \n\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03A\x02\x07\n\x0c\n\x05\x04\x01\
+ \x02\0\x01\x12\x03A\x08\r\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03A\x10\x11\
+ \ne\n\x02\x04\x02\x12\x04G\0J\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\x03G\x08\x12\n\x1f\n\
+ \x04\x04\x02\x02\0\x12\x03I\x02\x12\x1a\x12\x20The\x20int64\x20value.\n\
+ \n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03I\x02\x07\n\x0c\n\x05\x04\x02\x02\
+ \0\x01\x12\x03I\x08\r\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03I\x10\x11\ng\
+ \n\x02\x04\x03\x12\x04O\0R\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\x03O\x08\x13\n\x20\n\x04\
+ \x04\x03\x02\0\x12\x03Q\x02\x13\x1a\x13\x20The\x20uint64\x20value.\n\n\
+ \x0c\n\x05\x04\x03\x02\0\x05\x12\x03Q\x02\x08\n\x0c\n\x05\x04\x03\x02\0\
+ \x01\x12\x03Q\t\x0e\n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03Q\x11\x12\ne\n\
+ \x02\x04\x04\x12\x04W\0Z\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\x03W\x08\x12\n\x1f\n\x04\x04\
+ \x04\x02\0\x12\x03Y\x02\x12\x1a\x12\x20The\x20int32\x20value.\n\n\x0c\n\
+ \x05\x04\x04\x02\0\x05\x12\x03Y\x02\x07\n\x0c\n\x05\x04\x04\x02\0\x01\
+ \x12\x03Y\x08\r\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03Y\x10\x11\ng\n\x02\
+ \x04\x05\x12\x04_\0b\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\x03_\x08\x13\n\x20\n\x04\x04\
+ \x05\x02\0\x12\x03a\x02\x13\x1a\x13\x20The\x20uint32\x20value.\n\n\x0c\n\
+ \x05\x04\x05\x02\0\x05\x12\x03a\x02\x08\n\x0c\n\x05\x04\x05\x02\0\x01\
+ \x12\x03a\t\x0e\n\x0c\n\x05\x04\x05\x02\0\x03\x12\x03a\x11\x12\no\n\x02\
+ \x04\x06\x12\x04g\0j\x01\x1ac\x20Wrapper\x20message\x20for\x20`bool`.\n\
+ \n\x20The\x20JSON\x20representation\x20for\x20`BoolValue`\x20is\x20JSON\
+ \x20`true`\x20and\x20`false`.\n\n\n\n\x03\x04\x06\x01\x12\x03g\x08\x11\n\
+ \x1e\n\x04\x04\x06\x02\0\x12\x03i\x02\x11\x1a\x11\x20The\x20bool\x20valu\
+ e.\n\n\x0c\n\x05\x04\x06\x02\0\x05\x12\x03i\x02\x06\n\x0c\n\x05\x04\x06\
+ \x02\0\x01\x12\x03i\x07\x0c\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03i\x0f\
+ \x10\ng\n\x02\x04\x07\x12\x04o\0r\x01\x1a[\x20Wrapper\x20message\x20for\
+ \x20`string`.\n\n\x20The\x20JSON\x20representation\x20for\x20`StringValu\
+ e`\x20is\x20JSON\x20string.\n\n\n\n\x03\x04\x07\x01\x12\x03o\x08\x13\n\
+ \x20\n\x04\x04\x07\x02\0\x12\x03q\x02\x13\x1a\x13\x20The\x20string\x20va\
+ lue.\n\n\x0c\n\x05\x04\x07\x02\0\x05\x12\x03q\x02\x08\n\x0c\n\x05\x04\
+ \x07\x02\0\x01\x12\x03q\t\x0e\n\x0c\n\x05\x04\x07\x02\0\x03\x12\x03q\x11\
+ \x12\ne\n\x02\x04\x08\x12\x04w\0z\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\x03w\x08\x12\n\x1f\
+ \n\x04\x04\x08\x02\0\x12\x03y\x02\x12\x1a\x12\x20The\x20bytes\x20value.\
+ \n\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03y\x02\x07\n\x0c\n\x05\x04\x08\
+ \x02\0\x01\x12\x03y\x08\r\n\x0c\n\x05\x04\x08\x02\0\x03\x12\x03y\x10\x11\
+ b\x06proto3\
+";
+
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
+
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+ crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
+}
+
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
+ file_descriptor_proto_lazy.get(|| {
+ parse_descriptor_proto()
+ })
+}
diff --git a/2.27.1/src/well_known_types_util/any.rs b/2.27.1/src/well_known_types_util/any.rs
new file mode 100644
index 0000000..7441e17
--- /dev/null
+++ b/2.27.1/src/well_known_types_util/any.rs
@@ -0,0 +1,113 @@
+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(M::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/2.27.1/src/well_known_types_util/mod.rs b/2.27.1/src/well_known_types_util/mod.rs
new file mode 100644
index 0000000..bd4c243
--- /dev/null
+++ b/2.27.1/src/well_known_types_util/mod.rs
@@ -0,0 +1 @@
+mod any;
diff --git a/2.27.1/src/wire_format.rs b/2.27.1/src/wire_format.rs
new file mode 100644
index 0000000..9f54af3
--- /dev/null
+++ b/2.27.1/src/wire_format.rs
@@ -0,0 +1,105 @@
+//! Serialization constants.
+
+// 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) - 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
+ }
+}
diff --git a/2.27.1/src/zigzag.rs b/2.27.1/src/zigzag.rs
new file mode 100644
index 0000000..4c7d27d
--- /dev/null
+++ b/2.27.1/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);
+ }
+}
