| // This file is generated by rust-protobuf 2.22.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() |
| }) |
| } |