// This file is generated by rust-protobuf 3.0.0-pre. Do not edit // .proto file is parsed by protoc --rust-out=... // @generated // https://github.com/rust-lang/rust-clippy/issues/702 #![allow(unknown_lints)] #![allow(clippy::all)] #![allow(unused_attributes)] #![cfg_attr(rustfmt, rustfmt::skip)] #![allow(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_results)] #![allow(unused_mut)] //! Generated file from `google/protobuf/descriptor.proto` /// The protocol compiler can output a FileDescriptorSet containing the .proto /// files it parses. #[derive(PartialEq,Clone,Default,Debug)] // @@protoc_insertion_point(message:google.protobuf.FileDescriptorSet) pub struct FileDescriptorSet { // message fields // @@protoc_insertion_point(field:google.protobuf.FileDescriptorSet.file) pub file: ::std::vec::Vec, // special fields // @@protoc_insertion_point(special_field:google.protobuf.FileDescriptorSet.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a FileDescriptorSet { fn default() -> &'a FileDescriptorSet { ::default_instance() } } impl FileDescriptorSet { pub fn new() -> FileDescriptorSet { ::std::default::Default::default() } fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(1); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "file", |m: &FileDescriptorSet| { &m.file }, |m: &mut FileDescriptorSet| { &mut m.file }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "FileDescriptorSet", fields, oneofs, ) } } impl crate::Message for FileDescriptorSet { const NAME: &'static str = "FileDescriptorSet"; fn is_initialized(&self) -> bool { for v in &self.file { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.file.push(is.read_message()?); }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; for value in &self.file { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { for v in &self.file { crate::rt::write_message_field_with_cached_size(1, v, os)?; }; os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> FileDescriptorSet { FileDescriptorSet::new() } fn clear(&mut self) { self.file.clear(); self.special_fields.clear(); } fn default_instance() -> &'static FileDescriptorSet { static instance: FileDescriptorSet = FileDescriptorSet { file: ::std::vec::Vec::new(), special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for FileDescriptorSet { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("FileDescriptorSet").unwrap()).clone() } } impl ::std::fmt::Display for FileDescriptorSet { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for FileDescriptorSet { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } /// Describes a complete .proto file. #[derive(PartialEq,Clone,Default,Debug)] // @@protoc_insertion_point(message:google.protobuf.FileDescriptorProto) pub struct FileDescriptorProto { // message fields // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.name) pub name: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.package) pub package: ::std::option::Option<::std::string::String>, /// Names of files imported by this file. // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.dependency) pub dependency: ::std::vec::Vec<::std::string::String>, /// Indexes of the public imported files in the dependency list above. // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.public_dependency) pub public_dependency: ::std::vec::Vec, /// Indexes of the weak imported files in the dependency list. /// For Google-internal migration only. Do not use. // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.weak_dependency) pub weak_dependency: ::std::vec::Vec, /// All top-level definitions in this file. // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.message_type) pub message_type: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.enum_type) pub enum_type: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.service) pub service: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.extension) pub extension: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.options) pub options: crate::MessageField, /// This field contains optional information about the original source code. /// You may safely remove this entire field without harming runtime /// functionality of the descriptors -- the information is needed only by /// development tools. // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.source_code_info) pub source_code_info: crate::MessageField, /// The syntax of the proto file. /// The supported values are "proto2" and "proto3". // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.syntax) pub syntax: ::std::option::Option<::std::string::String>, // special fields // @@protoc_insertion_point(special_field:google.protobuf.FileDescriptorProto.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a FileDescriptorProto { fn default() -> &'a FileDescriptorProto { ::default_instance() } } impl FileDescriptorProto { pub fn new() -> FileDescriptorProto { ::std::default::Default::default() } // optional string name = 1; pub fn name(&self) -> &str { match self.name.as_ref() { Some(v) => v, None => "", } } pub fn clear_name(&mut self) { self.name = ::std::option::Option::None; } pub fn has_name(&self) -> bool { self.name.is_some() } // Param is passed by value, moved pub fn set_name(&mut self, v: ::std::string::String) { self.name = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_name(&mut self) -> &mut ::std::string::String { if self.name.is_none() { self.name = ::std::option::Option::Some(::std::string::String::new()); } self.name.as_mut().unwrap() } // Take field pub fn take_name(&mut self) -> ::std::string::String { self.name.take().unwrap_or_else(|| ::std::string::String::new()) } // optional string package = 2; pub fn package(&self) -> &str { match self.package.as_ref() { Some(v) => v, None => "", } } pub fn clear_package(&mut self) { self.package = ::std::option::Option::None; } pub fn has_package(&self) -> bool { self.package.is_some() } // Param is passed by value, moved pub fn set_package(&mut self, v: ::std::string::String) { self.package = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_package(&mut self) -> &mut ::std::string::String { if self.package.is_none() { self.package = ::std::option::Option::Some(::std::string::String::new()); } self.package.as_mut().unwrap() } // Take field pub fn take_package(&mut self) -> ::std::string::String { self.package.take().unwrap_or_else(|| ::std::string::String::new()) } // optional string syntax = 12; pub fn syntax(&self) -> &str { match self.syntax.as_ref() { Some(v) => v, None => "", } } pub fn clear_syntax(&mut self) { self.syntax = ::std::option::Option::None; } pub fn has_syntax(&self) -> bool { self.syntax.is_some() } // Param is passed by value, moved pub fn set_syntax(&mut self, v: ::std::string::String) { self.syntax = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_syntax(&mut self) -> &mut ::std::string::String { if self.syntax.is_none() { self.syntax = ::std::option::Option::Some(::std::string::String::new()); } self.syntax.as_mut().unwrap() } // Take field pub fn take_syntax(&mut self) -> ::std::string::String { self.syntax.take().unwrap_or_else(|| ::std::string::String::new()) } fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(12); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "name", |m: &FileDescriptorProto| { &m.name }, |m: &mut FileDescriptorProto| { &mut m.name }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "package", |m: &FileDescriptorProto| { &m.package }, |m: &mut FileDescriptorProto| { &mut m.package }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "dependency", |m: &FileDescriptorProto| { &m.dependency }, |m: &mut FileDescriptorProto| { &mut m.dependency }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "public_dependency", |m: &FileDescriptorProto| { &m.public_dependency }, |m: &mut FileDescriptorProto| { &mut m.public_dependency }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "weak_dependency", |m: &FileDescriptorProto| { &m.weak_dependency }, |m: &mut FileDescriptorProto| { &mut m.weak_dependency }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "message_type", |m: &FileDescriptorProto| { &m.message_type }, |m: &mut FileDescriptorProto| { &mut m.message_type }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "enum_type", |m: &FileDescriptorProto| { &m.enum_type }, |m: &mut FileDescriptorProto| { &mut m.enum_type }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "service", |m: &FileDescriptorProto| { &m.service }, |m: &mut FileDescriptorProto| { &mut m.service }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "extension", |m: &FileDescriptorProto| { &m.extension }, |m: &mut FileDescriptorProto| { &mut m.extension }, )); fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, FileOptions>( "options", |m: &FileDescriptorProto| { &m.options }, |m: &mut FileDescriptorProto| { &mut m.options }, )); fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, SourceCodeInfo>( "source_code_info", |m: &FileDescriptorProto| { &m.source_code_info }, |m: &mut FileDescriptorProto| { &mut m.source_code_info }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "syntax", |m: &FileDescriptorProto| { &m.syntax }, |m: &mut FileDescriptorProto| { &mut m.syntax }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "FileDescriptorProto", fields, oneofs, ) } } impl crate::Message for FileDescriptorProto { const NAME: &'static str = "FileDescriptorProto"; fn is_initialized(&self) -> bool { for v in &self.message_type { if !v.is_initialized() { return false; } }; for v in &self.enum_type { if !v.is_initialized() { return false; } }; for v in &self.service { if !v.is_initialized() { return false; } }; for v in &self.extension { if !v.is_initialized() { return false; } }; for v in &self.options { if !v.is_initialized() { return false; } }; for v in &self.source_code_info { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.name = ::std::option::Option::Some(is.read_string()?); }, 18 => { self.package = ::std::option::Option::Some(is.read_string()?); }, 26 => { self.dependency.push(is.read_string()?); }, 82 => { is.read_repeated_packed_int32_into(&mut self.public_dependency)?; }, 80 => { self.public_dependency.push(is.read_int32()?); }, 90 => { is.read_repeated_packed_int32_into(&mut self.weak_dependency)?; }, 88 => { self.weak_dependency.push(is.read_int32()?); }, 34 => { self.message_type.push(is.read_message()?); }, 42 => { self.enum_type.push(is.read_message()?); }, 50 => { self.service.push(is.read_message()?); }, 58 => { self.extension.push(is.read_message()?); }, 66 => { crate::rt::read_singular_message_into_field(is, &mut self.options)?; }, 74 => { crate::rt::read_singular_message_into_field(is, &mut self.source_code_info)?; }, 98 => { self.syntax = ::std::option::Option::Some(is.read_string()?); }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.name.as_ref() { my_size += crate::rt::string_size(1, &v); } if let Some(v) = self.package.as_ref() { my_size += crate::rt::string_size(2, &v); } for value in &self.dependency { my_size += crate::rt::string_size(3, &value); }; for value in &self.public_dependency { my_size += crate::rt::int32_size(10, *value); }; for value in &self.weak_dependency { my_size += crate::rt::int32_size(11, *value); }; for value in &self.message_type { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.enum_type { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.service { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.extension { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; if let Some(v) = self.options.as_ref() { let len = v.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.source_code_info.as_ref() { let len = v.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.syntax.as_ref() { my_size += crate::rt::string_size(12, &v); } my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { if let Some(v) = self.name.as_ref() { os.write_string(1, v)?; } if let Some(v) = self.package.as_ref() { os.write_string(2, v)?; } for v in &self.dependency { os.write_string(3, &v)?; }; for v in &self.public_dependency { os.write_int32(10, *v)?; }; for v in &self.weak_dependency { os.write_int32(11, *v)?; }; for v in &self.message_type { crate::rt::write_message_field_with_cached_size(4, v, os)?; }; for v in &self.enum_type { crate::rt::write_message_field_with_cached_size(5, v, os)?; }; for v in &self.service { crate::rt::write_message_field_with_cached_size(6, v, os)?; }; for v in &self.extension { crate::rt::write_message_field_with_cached_size(7, v, os)?; }; if let Some(v) = self.options.as_ref() { crate::rt::write_message_field_with_cached_size(8, v, os)?; } if let Some(v) = self.source_code_info.as_ref() { crate::rt::write_message_field_with_cached_size(9, v, os)?; } if let Some(v) = self.syntax.as_ref() { os.write_string(12, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> FileDescriptorProto { FileDescriptorProto::new() } fn clear(&mut self) { self.name = ::std::option::Option::None; self.package = ::std::option::Option::None; self.dependency.clear(); self.public_dependency.clear(); self.weak_dependency.clear(); self.message_type.clear(); self.enum_type.clear(); self.service.clear(); self.extension.clear(); self.options.clear(); self.source_code_info.clear(); self.syntax = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static FileDescriptorProto { static instance: FileDescriptorProto = FileDescriptorProto { name: ::std::option::Option::None, package: ::std::option::Option::None, dependency: ::std::vec::Vec::new(), public_dependency: ::std::vec::Vec::new(), weak_dependency: ::std::vec::Vec::new(), message_type: ::std::vec::Vec::new(), enum_type: ::std::vec::Vec::new(), service: ::std::vec::Vec::new(), extension: ::std::vec::Vec::new(), options: crate::MessageField::none(), source_code_info: crate::MessageField::none(), syntax: ::std::option::Option::None, special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for FileDescriptorProto { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("FileDescriptorProto").unwrap()).clone() } } impl ::std::fmt::Display for FileDescriptorProto { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for FileDescriptorProto { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } /// Describes a message type. #[derive(PartialEq,Clone,Default,Debug)] // @@protoc_insertion_point(message:google.protobuf.DescriptorProto) pub struct DescriptorProto { // message fields // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.name) pub name: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.field) pub field: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.extension) pub extension: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.nested_type) pub nested_type: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.enum_type) pub enum_type: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.extension_range) pub extension_range: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.oneof_decl) pub oneof_decl: ::std::vec::Vec, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.options) pub options: crate::MessageField, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.reserved_range) pub reserved_range: ::std::vec::Vec, /// Reserved field names, which may not be used by fields in the same message. /// A given name may only be reserved once. // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.reserved_name) pub reserved_name: ::std::vec::Vec<::std::string::String>, // special fields // @@protoc_insertion_point(special_field:google.protobuf.DescriptorProto.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a DescriptorProto { fn default() -> &'a DescriptorProto { ::default_instance() } } impl DescriptorProto { pub fn new() -> DescriptorProto { ::std::default::Default::default() } // optional string name = 1; pub fn name(&self) -> &str { match self.name.as_ref() { Some(v) => v, None => "", } } pub fn clear_name(&mut self) { self.name = ::std::option::Option::None; } pub fn has_name(&self) -> bool { self.name.is_some() } // Param is passed by value, moved pub fn set_name(&mut self, v: ::std::string::String) { self.name = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_name(&mut self) -> &mut ::std::string::String { if self.name.is_none() { self.name = ::std::option::Option::Some(::std::string::String::new()); } self.name.as_mut().unwrap() } // Take field pub fn take_name(&mut self) -> ::std::string::String { self.name.take().unwrap_or_else(|| ::std::string::String::new()) } fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(10); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "name", |m: &DescriptorProto| { &m.name }, |m: &mut DescriptorProto| { &mut m.name }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "field", |m: &DescriptorProto| { &m.field }, |m: &mut DescriptorProto| { &mut m.field }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "extension", |m: &DescriptorProto| { &m.extension }, |m: &mut DescriptorProto| { &mut m.extension }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "nested_type", |m: &DescriptorProto| { &m.nested_type }, |m: &mut DescriptorProto| { &mut m.nested_type }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "enum_type", |m: &DescriptorProto| { &m.enum_type }, |m: &mut DescriptorProto| { &mut m.enum_type }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "extension_range", |m: &DescriptorProto| { &m.extension_range }, |m: &mut DescriptorProto| { &mut m.extension_range }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "oneof_decl", |m: &DescriptorProto| { &m.oneof_decl }, |m: &mut DescriptorProto| { &mut m.oneof_decl }, )); fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, MessageOptions>( "options", |m: &DescriptorProto| { &m.options }, |m: &mut DescriptorProto| { &mut m.options }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "reserved_range", |m: &DescriptorProto| { &m.reserved_range }, |m: &mut DescriptorProto| { &mut m.reserved_range }, )); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "reserved_name", |m: &DescriptorProto| { &m.reserved_name }, |m: &mut DescriptorProto| { &mut m.reserved_name }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "DescriptorProto", fields, oneofs, ) } } impl crate::Message for DescriptorProto { const NAME: &'static str = "DescriptorProto"; fn is_initialized(&self) -> bool { for v in &self.field { if !v.is_initialized() { return false; } }; for v in &self.extension { if !v.is_initialized() { return false; } }; for v in &self.nested_type { if !v.is_initialized() { return false; } }; for v in &self.enum_type { if !v.is_initialized() { return false; } }; for v in &self.extension_range { if !v.is_initialized() { return false; } }; for v in &self.oneof_decl { if !v.is_initialized() { return false; } }; for v in &self.options { if !v.is_initialized() { return false; } }; for v in &self.reserved_range { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.name = ::std::option::Option::Some(is.read_string()?); }, 18 => { self.field.push(is.read_message()?); }, 50 => { self.extension.push(is.read_message()?); }, 26 => { self.nested_type.push(is.read_message()?); }, 34 => { self.enum_type.push(is.read_message()?); }, 42 => { self.extension_range.push(is.read_message()?); }, 66 => { self.oneof_decl.push(is.read_message()?); }, 58 => { crate::rt::read_singular_message_into_field(is, &mut self.options)?; }, 74 => { self.reserved_range.push(is.read_message()?); }, 82 => { self.reserved_name.push(is.read_string()?); }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.name.as_ref() { my_size += crate::rt::string_size(1, &v); } for value in &self.field { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.extension { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.nested_type { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.enum_type { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.extension_range { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.oneof_decl { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; if let Some(v) = self.options.as_ref() { let len = v.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; } for value in &self.reserved_range { let len = value.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; }; for value in &self.reserved_name { my_size += crate::rt::string_size(10, &value); }; my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { if let Some(v) = self.name.as_ref() { os.write_string(1, v)?; } for v in &self.field { crate::rt::write_message_field_with_cached_size(2, v, os)?; }; for v in &self.extension { crate::rt::write_message_field_with_cached_size(6, v, os)?; }; for v in &self.nested_type { crate::rt::write_message_field_with_cached_size(3, v, os)?; }; for v in &self.enum_type { crate::rt::write_message_field_with_cached_size(4, v, os)?; }; for v in &self.extension_range { crate::rt::write_message_field_with_cached_size(5, v, os)?; }; for v in &self.oneof_decl { crate::rt::write_message_field_with_cached_size(8, v, os)?; }; if let Some(v) = self.options.as_ref() { crate::rt::write_message_field_with_cached_size(7, v, os)?; } for v in &self.reserved_range { crate::rt::write_message_field_with_cached_size(9, v, os)?; }; for v in &self.reserved_name { os.write_string(10, &v)?; }; os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> DescriptorProto { DescriptorProto::new() } fn clear(&mut self) { self.name = ::std::option::Option::None; self.field.clear(); self.extension.clear(); self.nested_type.clear(); self.enum_type.clear(); self.extension_range.clear(); self.oneof_decl.clear(); self.options.clear(); self.reserved_range.clear(); self.reserved_name.clear(); self.special_fields.clear(); } fn default_instance() -> &'static DescriptorProto { static instance: DescriptorProto = DescriptorProto { name: ::std::option::Option::None, field: ::std::vec::Vec::new(), extension: ::std::vec::Vec::new(), nested_type: ::std::vec::Vec::new(), enum_type: ::std::vec::Vec::new(), extension_range: ::std::vec::Vec::new(), oneof_decl: ::std::vec::Vec::new(), options: crate::MessageField::none(), reserved_range: ::std::vec::Vec::new(), reserved_name: ::std::vec::Vec::new(), special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for DescriptorProto { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("DescriptorProto").unwrap()).clone() } } impl ::std::fmt::Display for DescriptorProto { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for DescriptorProto { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } /// Nested message and enums of message `DescriptorProto` pub mod descriptor_proto { #[derive(PartialEq,Clone,Default,Debug)] // @@protoc_insertion_point(message:google.protobuf.DescriptorProto.ExtensionRange) pub struct ExtensionRange { // message fields // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ExtensionRange.start) pub start: ::std::option::Option, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ExtensionRange.end) pub end: ::std::option::Option, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ExtensionRange.options) pub options: crate::MessageField, // special fields // @@protoc_insertion_point(special_field:google.protobuf.DescriptorProto.ExtensionRange.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a ExtensionRange { fn default() -> &'a ExtensionRange { ::default_instance() } } impl ExtensionRange { pub fn new() -> ExtensionRange { ::std::default::Default::default() } // optional int32 start = 1; pub fn start(&self) -> i32 { self.start.unwrap_or(0) } pub fn clear_start(&mut self) { self.start = ::std::option::Option::None; } pub fn has_start(&self) -> bool { self.start.is_some() } // Param is passed by value, moved pub fn set_start(&mut self, v: i32) { self.start = ::std::option::Option::Some(v); } // optional int32 end = 2; pub fn end(&self) -> i32 { self.end.unwrap_or(0) } pub fn clear_end(&mut self) { self.end = ::std::option::Option::None; } pub fn has_end(&self) -> bool { self.end.is_some() } // Param is passed by value, moved pub fn set_end(&mut self, v: i32) { self.end = ::std::option::Option::Some(v); } pub(in super) fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(3); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "start", |m: &ExtensionRange| { &m.start }, |m: &mut ExtensionRange| { &mut m.start }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "end", |m: &ExtensionRange| { &m.end }, |m: &mut ExtensionRange| { &mut m.end }, )); fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, super::ExtensionRangeOptions>( "options", |m: &ExtensionRange| { &m.options }, |m: &mut ExtensionRange| { &mut m.options }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "DescriptorProto.ExtensionRange", fields, oneofs, ) } } impl crate::Message for ExtensionRange { const NAME: &'static str = "ExtensionRange"; fn is_initialized(&self) -> bool { for v in &self.options { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 8 => { self.start = ::std::option::Option::Some(is.read_int32()?); }, 16 => { self.end = ::std::option::Option::Some(is.read_int32()?); }, 26 => { crate::rt::read_singular_message_into_field(is, &mut self.options)?; }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.start { my_size += crate::rt::int32_size(1, v); } if let Some(v) = self.end { my_size += crate::rt::int32_size(2, v); } if let Some(v) = self.options.as_ref() { let len = v.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; } my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { if let Some(v) = self.start { os.write_int32(1, v)?; } if let Some(v) = self.end { os.write_int32(2, v)?; } if let Some(v) = self.options.as_ref() { crate::rt::write_message_field_with_cached_size(3, v, os)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> ExtensionRange { ExtensionRange::new() } fn clear(&mut self) { self.start = ::std::option::Option::None; self.end = ::std::option::Option::None; self.options.clear(); self.special_fields.clear(); } fn default_instance() -> &'static ExtensionRange { static instance: ExtensionRange = ExtensionRange { start: ::std::option::Option::None, end: ::std::option::Option::None, options: crate::MessageField::none(), special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for ExtensionRange { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| super::file_descriptor().message_by_package_relative_name("DescriptorProto.ExtensionRange").unwrap()).clone() } } impl ::std::fmt::Display for ExtensionRange { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for ExtensionRange { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } /// Range of reserved tag numbers. Reserved tag numbers may not be used by /// fields or extension ranges in the same message. Reserved ranges may /// not overlap. #[derive(PartialEq,Clone,Default,Debug)] // @@protoc_insertion_point(message:google.protobuf.DescriptorProto.ReservedRange) pub struct ReservedRange { // message fields // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ReservedRange.start) pub start: ::std::option::Option, // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ReservedRange.end) pub end: ::std::option::Option, // special fields // @@protoc_insertion_point(special_field:google.protobuf.DescriptorProto.ReservedRange.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a ReservedRange { fn default() -> &'a ReservedRange { ::default_instance() } } impl ReservedRange { pub fn new() -> ReservedRange { ::std::default::Default::default() } // optional int32 start = 1; pub fn start(&self) -> i32 { self.start.unwrap_or(0) } pub fn clear_start(&mut self) { self.start = ::std::option::Option::None; } pub fn has_start(&self) -> bool { self.start.is_some() } // Param is passed by value, moved pub fn set_start(&mut self, v: i32) { self.start = ::std::option::Option::Some(v); } // optional int32 end = 2; pub fn end(&self) -> i32 { self.end.unwrap_or(0) } pub fn clear_end(&mut self) { self.end = ::std::option::Option::None; } pub fn has_end(&self) -> bool { self.end.is_some() } // Param is passed by value, moved pub fn set_end(&mut self, v: i32) { self.end = ::std::option::Option::Some(v); } pub(in super) fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(2); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "start", |m: &ReservedRange| { &m.start }, |m: &mut ReservedRange| { &mut m.start }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "end", |m: &ReservedRange| { &m.end }, |m: &mut ReservedRange| { &mut m.end }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "DescriptorProto.ReservedRange", fields, oneofs, ) } } impl crate::Message for ReservedRange { const NAME: &'static str = "ReservedRange"; fn is_initialized(&self) -> bool { true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 8 => { self.start = ::std::option::Option::Some(is.read_int32()?); }, 16 => { self.end = ::std::option::Option::Some(is.read_int32()?); }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.start { my_size += crate::rt::int32_size(1, v); } if let Some(v) = self.end { my_size += crate::rt::int32_size(2, v); } my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { if let Some(v) = self.start { os.write_int32(1, v)?; } if let Some(v) = self.end { os.write_int32(2, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> ReservedRange { ReservedRange::new() } fn clear(&mut self) { self.start = ::std::option::Option::None; self.end = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static ReservedRange { static instance: ReservedRange = ReservedRange { start: ::std::option::Option::None, end: ::std::option::Option::None, special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for ReservedRange { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| super::file_descriptor().message_by_package_relative_name("DescriptorProto.ReservedRange").unwrap()).clone() } } impl ::std::fmt::Display for ReservedRange { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for ReservedRange { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } } #[derive(PartialEq,Clone,Default,Debug)] // @@protoc_insertion_point(message:google.protobuf.ExtensionRangeOptions) pub struct ExtensionRangeOptions { // message fields /// The parser stores options it doesn't recognize here. See above. // @@protoc_insertion_point(field:google.protobuf.ExtensionRangeOptions.uninterpreted_option) pub uninterpreted_option: ::std::vec::Vec, // special fields // @@protoc_insertion_point(special_field:google.protobuf.ExtensionRangeOptions.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a ExtensionRangeOptions { fn default() -> &'a ExtensionRangeOptions { ::default_instance() } } impl ExtensionRangeOptions { pub fn new() -> ExtensionRangeOptions { ::std::default::Default::default() } fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(1); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( "uninterpreted_option", |m: &ExtensionRangeOptions| { &m.uninterpreted_option }, |m: &mut ExtensionRangeOptions| { &mut m.uninterpreted_option }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "ExtensionRangeOptions", fields, oneofs, ) } } impl crate::Message for ExtensionRangeOptions { const NAME: &'static str = "ExtensionRangeOptions"; fn is_initialized(&self) -> bool { for v in &self.uninterpreted_option { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 7994 => { self.uninterpreted_option.push(is.read_message()?); }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; for value in &self.uninterpreted_option { let len = value.compute_size(); my_size += 2 + crate::rt::compute_raw_varint64_size(len) + len; }; my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { for v in &self.uninterpreted_option { crate::rt::write_message_field_with_cached_size(999, v, os)?; }; os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> ExtensionRangeOptions { ExtensionRangeOptions::new() } fn clear(&mut self) { self.uninterpreted_option.clear(); self.special_fields.clear(); } fn default_instance() -> &'static ExtensionRangeOptions { static instance: ExtensionRangeOptions = ExtensionRangeOptions { uninterpreted_option: ::std::vec::Vec::new(), special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for ExtensionRangeOptions { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("ExtensionRangeOptions").unwrap()).clone() } } impl ::std::fmt::Display for ExtensionRangeOptions { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for ExtensionRangeOptions { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } /// Describes a field within a message. #[derive(PartialEq,Clone,Default,Debug)] // @@protoc_insertion_point(message:google.protobuf.FieldDescriptorProto) pub struct FieldDescriptorProto { // message fields // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.name) pub name: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.number) pub number: ::std::option::Option, // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.label) pub label: ::std::option::Option>, /// If type_name is set, this need not be set. If both this and type_name /// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.type) pub type_: ::std::option::Option>, /// For message and enum types, this is the name of the type. If the name /// starts with a '.', it is fully-qualified. Otherwise, C++-like scoping /// rules are used to find the type (i.e. first the nested types within this /// message are searched, then within the parent, on up to the root /// namespace). // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.type_name) pub type_name: ::std::option::Option<::std::string::String>, /// For extensions, this is the name of the type being extended. It is /// resolved in the same manner as type_name. // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.extendee) pub extendee: ::std::option::Option<::std::string::String>, /// For numeric types, contains the original text representation of the value. /// For booleans, "true" or "false". /// For strings, contains the default text contents (not escaped in any way). /// For bytes, contains the C escaped value. All bytes >= 128 are escaped. /// TODO(kenton): Base-64 encode? // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.default_value) pub default_value: ::std::option::Option<::std::string::String>, /// If set, gives the index of a oneof in the containing type's oneof_decl /// list. This field is a member of that oneof. // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.oneof_index) pub oneof_index: ::std::option::Option, /// JSON name of this field. The value is set by protocol compiler. If the /// user has set a "json_name" option on this field, that option's value /// will be used. Otherwise, it's deduced from the field's name by converting /// it to camelCase. // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.json_name) pub json_name: ::std::option::Option<::std::string::String>, // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.options) pub options: crate::MessageField, /// If true, this is a proto3 "optional". When a proto3 field is optional, it /// tracks presence regardless of field type. /// /// When proto3_optional is true, this field must be belong to a oneof to /// signal to old proto3 clients that presence is tracked for this field. This /// oneof is known as a "synthetic" oneof, and this field must be its sole /// member (each proto3 optional field gets its own synthetic oneof). Synthetic /// oneofs exist in the descriptor only, and do not generate any API. Synthetic /// oneofs must be ordered after all "real" oneofs. /// /// For message fields, proto3_optional doesn't create any semantic change, /// since non-repeated message fields always track presence. However it still /// indicates the semantic detail of whether the user wrote "optional" or not. /// This can be useful for round-tripping the .proto file. For consistency we /// give message fields a synthetic oneof also, even though it is not required /// to track presence. This is especially important because the parser can't /// tell if a field is a message or an enum, so it must always create a /// synthetic oneof. /// /// Proto2 optional fields do not set this flag, because they already indicate /// optional with `LABEL_OPTIONAL`. // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.proto3_optional) pub proto3_optional: ::std::option::Option, // special fields // @@protoc_insertion_point(special_field:google.protobuf.FieldDescriptorProto.special_fields) pub special_fields: crate::SpecialFields, } impl<'a> ::std::default::Default for &'a FieldDescriptorProto { fn default() -> &'a FieldDescriptorProto { ::default_instance() } } impl FieldDescriptorProto { pub fn new() -> FieldDescriptorProto { ::std::default::Default::default() } // optional string name = 1; pub fn name(&self) -> &str { match self.name.as_ref() { Some(v) => v, None => "", } } pub fn clear_name(&mut self) { self.name = ::std::option::Option::None; } pub fn has_name(&self) -> bool { self.name.is_some() } // Param is passed by value, moved pub fn set_name(&mut self, v: ::std::string::String) { self.name = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_name(&mut self) -> &mut ::std::string::String { if self.name.is_none() { self.name = ::std::option::Option::Some(::std::string::String::new()); } self.name.as_mut().unwrap() } // Take field pub fn take_name(&mut self) -> ::std::string::String { self.name.take().unwrap_or_else(|| ::std::string::String::new()) } // optional int32 number = 3; pub fn number(&self) -> i32 { self.number.unwrap_or(0) } pub fn clear_number(&mut self) { self.number = ::std::option::Option::None; } pub fn has_number(&self) -> bool { self.number.is_some() } // Param is passed by value, moved pub fn set_number(&mut self, v: i32) { self.number = ::std::option::Option::Some(v); } // optional .google.protobuf.FieldDescriptorProto.Label label = 4; pub fn label(&self) -> field_descriptor_proto::Label { match self.label { Some(e) => e.enum_value_or(field_descriptor_proto::Label::LABEL_OPTIONAL), None => field_descriptor_proto::Label::LABEL_OPTIONAL, } } pub fn clear_label(&mut self) { self.label = ::std::option::Option::None; } pub fn has_label(&self) -> bool { self.label.is_some() } // Param is passed by value, moved pub fn set_label(&mut self, v: field_descriptor_proto::Label) { self.label = ::std::option::Option::Some(crate::EnumOrUnknown::new(v)); } // optional .google.protobuf.FieldDescriptorProto.Type type = 5; pub fn type_(&self) -> field_descriptor_proto::Type { match self.type_ { Some(e) => e.enum_value_or(field_descriptor_proto::Type::TYPE_DOUBLE), None => field_descriptor_proto::Type::TYPE_DOUBLE, } } pub fn clear_type_(&mut self) { self.type_ = ::std::option::Option::None; } pub fn has_type(&self) -> bool { self.type_.is_some() } // Param is passed by value, moved pub fn set_type(&mut self, v: field_descriptor_proto::Type) { self.type_ = ::std::option::Option::Some(crate::EnumOrUnknown::new(v)); } // optional string type_name = 6; pub fn type_name(&self) -> &str { match self.type_name.as_ref() { Some(v) => v, None => "", } } pub fn clear_type_name(&mut self) { self.type_name = ::std::option::Option::None; } pub fn has_type_name(&self) -> bool { self.type_name.is_some() } // Param is passed by value, moved pub fn set_type_name(&mut self, v: ::std::string::String) { self.type_name = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_type_name(&mut self) -> &mut ::std::string::String { if self.type_name.is_none() { self.type_name = ::std::option::Option::Some(::std::string::String::new()); } self.type_name.as_mut().unwrap() } // Take field pub fn take_type_name(&mut self) -> ::std::string::String { self.type_name.take().unwrap_or_else(|| ::std::string::String::new()) } // optional string extendee = 2; pub fn extendee(&self) -> &str { match self.extendee.as_ref() { Some(v) => v, None => "", } } pub fn clear_extendee(&mut self) { self.extendee = ::std::option::Option::None; } pub fn has_extendee(&self) -> bool { self.extendee.is_some() } // Param is passed by value, moved pub fn set_extendee(&mut self, v: ::std::string::String) { self.extendee = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_extendee(&mut self) -> &mut ::std::string::String { if self.extendee.is_none() { self.extendee = ::std::option::Option::Some(::std::string::String::new()); } self.extendee.as_mut().unwrap() } // Take field pub fn take_extendee(&mut self) -> ::std::string::String { self.extendee.take().unwrap_or_else(|| ::std::string::String::new()) } // optional string default_value = 7; pub fn default_value(&self) -> &str { match self.default_value.as_ref() { Some(v) => v, None => "", } } pub fn clear_default_value(&mut self) { self.default_value = ::std::option::Option::None; } pub fn has_default_value(&self) -> bool { self.default_value.is_some() } // Param is passed by value, moved pub fn set_default_value(&mut self, v: ::std::string::String) { self.default_value = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_default_value(&mut self) -> &mut ::std::string::String { if self.default_value.is_none() { self.default_value = ::std::option::Option::Some(::std::string::String::new()); } self.default_value.as_mut().unwrap() } // Take field pub fn take_default_value(&mut self) -> ::std::string::String { self.default_value.take().unwrap_or_else(|| ::std::string::String::new()) } // optional int32 oneof_index = 9; pub fn oneof_index(&self) -> i32 { self.oneof_index.unwrap_or(0) } pub fn clear_oneof_index(&mut self) { self.oneof_index = ::std::option::Option::None; } pub fn has_oneof_index(&self) -> bool { self.oneof_index.is_some() } // Param is passed by value, moved pub fn set_oneof_index(&mut self, v: i32) { self.oneof_index = ::std::option::Option::Some(v); } // optional string json_name = 10; pub fn json_name(&self) -> &str { match self.json_name.as_ref() { Some(v) => v, None => "", } } pub fn clear_json_name(&mut self) { self.json_name = ::std::option::Option::None; } pub fn has_json_name(&self) -> bool { self.json_name.is_some() } // Param is passed by value, moved pub fn set_json_name(&mut self, v: ::std::string::String) { self.json_name = ::std::option::Option::Some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_json_name(&mut self) -> &mut ::std::string::String { if self.json_name.is_none() { self.json_name = ::std::option::Option::Some(::std::string::String::new()); } self.json_name.as_mut().unwrap() } // Take field pub fn take_json_name(&mut self) -> ::std::string::String { self.json_name.take().unwrap_or_else(|| ::std::string::String::new()) } // optional bool proto3_optional = 17; pub fn proto3_optional(&self) -> bool { self.proto3_optional.unwrap_or(false) } pub fn clear_proto3_optional(&mut self) { self.proto3_optional = ::std::option::Option::None; } pub fn has_proto3_optional(&self) -> bool { self.proto3_optional.is_some() } // Param is passed by value, moved pub fn set_proto3_optional(&mut self, v: bool) { self.proto3_optional = ::std::option::Option::Some(v); } fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData { let mut fields = ::std::vec::Vec::with_capacity(11); let mut oneofs = ::std::vec::Vec::with_capacity(0); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "name", |m: &FieldDescriptorProto| { &m.name }, |m: &mut FieldDescriptorProto| { &mut m.name }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "number", |m: &FieldDescriptorProto| { &m.number }, |m: &mut FieldDescriptorProto| { &mut m.number }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "label", |m: &FieldDescriptorProto| { &m.label }, |m: &mut FieldDescriptorProto| { &mut m.label }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "type", |m: &FieldDescriptorProto| { &m.type_ }, |m: &mut FieldDescriptorProto| { &mut m.type_ }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "type_name", |m: &FieldDescriptorProto| { &m.type_name }, |m: &mut FieldDescriptorProto| { &mut m.type_name }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "extendee", |m: &FieldDescriptorProto| { &m.extendee }, |m: &mut FieldDescriptorProto| { &mut m.extendee }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "default_value", |m: &FieldDescriptorProto| { &m.default_value }, |m: &mut FieldDescriptorProto| { &mut m.default_value }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "oneof_index", |m: &FieldDescriptorProto| { &m.oneof_index }, |m: &mut FieldDescriptorProto| { &mut m.oneof_index }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "json_name", |m: &FieldDescriptorProto| { &m.json_name }, |m: &mut FieldDescriptorProto| { &mut m.json_name }, )); fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, FieldOptions>( "options", |m: &FieldDescriptorProto| { &m.options }, |m: &mut FieldDescriptorProto| { &mut m.options }, )); fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>( "proto3_optional", |m: &FieldDescriptorProto| { &m.proto3_optional }, |m: &mut FieldDescriptorProto| { &mut m.proto3_optional }, )); crate::reflect::GeneratedMessageDescriptorData::new_2::( "FieldDescriptorProto", fields, oneofs, ) } } impl crate::Message for FieldDescriptorProto { const NAME: &'static str = "FieldDescriptorProto"; fn is_initialized(&self) -> bool { for v in &self.options { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> { while let Some(tag) = is.read_raw_tag_or_eof()? { match tag { 10 => { self.name = ::std::option::Option::Some(is.read_string()?); }, 24 => { self.number = ::std::option::Option::Some(is.read_int32()?); }, 32 => { self.label = ::std::option::Option::Some(is.read_enum_or_unknown()?); }, 40 => { self.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?); }, 50 => { self.type_name = ::std::option::Option::Some(is.read_string()?); }, 18 => { self.extendee = ::std::option::Option::Some(is.read_string()?); }, 58 => { self.default_value = ::std::option::Option::Some(is.read_string()?); }, 72 => { self.oneof_index = ::std::option::Option::Some(is.read_int32()?); }, 82 => { self.json_name = ::std::option::Option::Some(is.read_string()?); }, 66 => { crate::rt::read_singular_message_into_field(is, &mut self.options)?; }, 136 => { self.proto3_optional = ::std::option::Option::Some(is.read_bool()?); }, tag => { crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u64 { let mut my_size = 0; if let Some(v) = self.name.as_ref() { my_size += crate::rt::string_size(1, &v); } if let Some(v) = self.number { my_size += crate::rt::int32_size(3, v); } if let Some(v) = self.label { my_size += crate::rt::int32_size(4, v.value()); } if let Some(v) = self.type_ { my_size += crate::rt::int32_size(5, v.value()); } if let Some(v) = self.type_name.as_ref() { my_size += crate::rt::string_size(6, &v); } if let Some(v) = self.extendee.as_ref() { my_size += crate::rt::string_size(2, &v); } if let Some(v) = self.default_value.as_ref() { my_size += crate::rt::string_size(7, &v); } if let Some(v) = self.oneof_index { my_size += crate::rt::int32_size(9, v); } if let Some(v) = self.json_name.as_ref() { my_size += crate::rt::string_size(10, &v); } if let Some(v) = self.options.as_ref() { let len = v.compute_size(); my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len; } if let Some(v) = self.proto3_optional { my_size += 2 + 1; } my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields()); self.special_fields.cached_size().set(my_size as u32); my_size } fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> { if let Some(v) = self.name.as_ref() { os.write_string(1, v)?; } if let Some(v) = self.number { os.write_int32(3, v)?; } if let Some(v) = self.label { os.write_enum(4, crate::EnumOrUnknown::value(&v))?; } if let Some(v) = self.type_ { os.write_enum(5, crate::EnumOrUnknown::value(&v))?; } if let Some(v) = self.type_name.as_ref() { os.write_string(6, v)?; } if let Some(v) = self.extendee.as_ref() { os.write_string(2, v)?; } if let Some(v) = self.default_value.as_ref() { os.write_string(7, v)?; } if let Some(v) = self.oneof_index { os.write_int32(9, v)?; } if let Some(v) = self.json_name.as_ref() { os.write_string(10, v)?; } if let Some(v) = self.options.as_ref() { crate::rt::write_message_field_with_cached_size(8, v, os)?; } if let Some(v) = self.proto3_optional { os.write_bool(17, v)?; } os.write_unknown_fields(self.special_fields.unknown_fields())?; ::std::result::Result::Ok(()) } fn special_fields(&self) -> &crate::SpecialFields { &self.special_fields } fn mut_special_fields(&mut self) -> &mut crate::SpecialFields { &mut self.special_fields } fn new() -> FieldDescriptorProto { FieldDescriptorProto::new() } fn clear(&mut self) { self.name = ::std::option::Option::None; self.number = ::std::option::Option::None; self.label = ::std::option::Option::None; self.type_ = ::std::option::Option::None; self.type_name = ::std::option::Option::None; self.extendee = ::std::option::Option::None; self.default_value = ::std::option::Option::None; self.oneof_index = ::std::option::Option::None; self.json_name = ::std::option::Option::None; self.options.clear(); self.proto3_optional = ::std::option::Option::None; self.special_fields.clear(); } fn default_instance() -> &'static FieldDescriptorProto { static instance: FieldDescriptorProto = FieldDescriptorProto { name: ::std::option::Option::None, number: ::std::option::Option::None, label: ::std::option::Option::None, type_: ::std::option::Option::None, type_name: ::std::option::Option::None, extendee: ::std::option::Option::None, default_value: ::std::option::Option::None, oneof_index: ::std::option::Option::None, json_name: ::std::option::Option::None, options: crate::MessageField::none(), proto3_optional: ::std::option::Option::None, special_fields: crate::SpecialFields::new(), }; &instance } } impl crate::MessageFull for FieldDescriptorProto { fn descriptor() -> crate::reflect::MessageDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| file_descriptor().message_by_package_relative_name("FieldDescriptorProto").unwrap()).clone() } } impl ::std::fmt::Display for FieldDescriptorProto { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { crate::text_format::fmt(self, f) } } impl crate::reflect::ProtobufValue for FieldDescriptorProto { type RuntimeType = crate::reflect::rt::RuntimeTypeMessage; } /// Nested message and enums of message `FieldDescriptorProto` pub mod field_descriptor_proto { #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] // @@protoc_insertion_point(enum:google.protobuf.FieldDescriptorProto.Type) pub enum Type { // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_DOUBLE) TYPE_DOUBLE = 1, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_FLOAT) TYPE_FLOAT = 2, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_INT64) TYPE_INT64 = 3, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_UINT64) TYPE_UINT64 = 4, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_INT32) TYPE_INT32 = 5, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_FIXED64) TYPE_FIXED64 = 6, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_FIXED32) TYPE_FIXED32 = 7, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_BOOL) TYPE_BOOL = 8, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_STRING) TYPE_STRING = 9, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_GROUP) TYPE_GROUP = 10, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_MESSAGE) TYPE_MESSAGE = 11, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_BYTES) TYPE_BYTES = 12, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_UINT32) TYPE_UINT32 = 13, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_ENUM) TYPE_ENUM = 14, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SFIXED32) TYPE_SFIXED32 = 15, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SFIXED64) TYPE_SFIXED64 = 16, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SINT32) TYPE_SINT32 = 17, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SINT64) TYPE_SINT64 = 18, } impl crate::Enum for Type { const NAME: &'static str = "Type"; fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option { match value { 1 => ::std::option::Option::Some(Type::TYPE_DOUBLE), 2 => ::std::option::Option::Some(Type::TYPE_FLOAT), 3 => ::std::option::Option::Some(Type::TYPE_INT64), 4 => ::std::option::Option::Some(Type::TYPE_UINT64), 5 => ::std::option::Option::Some(Type::TYPE_INT32), 6 => ::std::option::Option::Some(Type::TYPE_FIXED64), 7 => ::std::option::Option::Some(Type::TYPE_FIXED32), 8 => ::std::option::Option::Some(Type::TYPE_BOOL), 9 => ::std::option::Option::Some(Type::TYPE_STRING), 10 => ::std::option::Option::Some(Type::TYPE_GROUP), 11 => ::std::option::Option::Some(Type::TYPE_MESSAGE), 12 => ::std::option::Option::Some(Type::TYPE_BYTES), 13 => ::std::option::Option::Some(Type::TYPE_UINT32), 14 => ::std::option::Option::Some(Type::TYPE_ENUM), 15 => ::std::option::Option::Some(Type::TYPE_SFIXED32), 16 => ::std::option::Option::Some(Type::TYPE_SFIXED64), 17 => ::std::option::Option::Some(Type::TYPE_SINT32), 18 => ::std::option::Option::Some(Type::TYPE_SINT64), _ => ::std::option::Option::None } } const VALUES: &'static [Type] = &[ Type::TYPE_DOUBLE, Type::TYPE_FLOAT, Type::TYPE_INT64, Type::TYPE_UINT64, Type::TYPE_INT32, Type::TYPE_FIXED64, Type::TYPE_FIXED32, Type::TYPE_BOOL, Type::TYPE_STRING, Type::TYPE_GROUP, Type::TYPE_MESSAGE, Type::TYPE_BYTES, Type::TYPE_UINT32, Type::TYPE_ENUM, Type::TYPE_SFIXED32, Type::TYPE_SFIXED64, Type::TYPE_SINT32, Type::TYPE_SINT64, ]; } impl crate::EnumFull for Type { fn enum_descriptor() -> crate::reflect::EnumDescriptor { static descriptor: crate::rt::Lazy = crate::rt::Lazy::new(); descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("FieldDescriptorProto.Type").unwrap()).clone() } fn descriptor(&self) -> crate::reflect::EnumValueDescriptor { let index = match self { Type::TYPE_DOUBLE => 0, Type::TYPE_FLOAT => 1, Type::TYPE_INT64 => 2, Type::TYPE_UINT64 => 3, Type::TYPE_INT32 => 4, Type::TYPE_FIXED64 => 5, Type::TYPE_FIXED32 => 6, Type::TYPE_BOOL => 7, Type::TYPE_STRING => 8, Type::TYPE_GROUP => 9, Type::TYPE_MESSAGE => 10, Type::TYPE_BYTES => 11, Type::TYPE_UINT32 => 12, Type::TYPE_ENUM => 13, Type::TYPE_SFIXED32 => 14, Type::TYPE_SFIXED64 => 15, Type::TYPE_SINT32 => 16, Type::TYPE_SINT64 => 17, }; Self::enum_descriptor().value_by_index(index) } } // Note, `Default` is implemented although default value is not 0 impl ::std::default::Default for Type { fn default() -> Self { Type::TYPE_DOUBLE } } impl Type { pub(in super) fn generated_enum_descriptor_data() -> crate::reflect::GeneratedEnumDescriptorData { crate::reflect::GeneratedEnumDescriptorData::new::("FieldDescriptorProto.Type") } } #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] // @@protoc_insertion_point(enum:google.protobuf.FieldDescriptorProto.Label) pub enum Label { // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Label.LABEL_OPTIONAL) LABEL_OPTIONAL = 1, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Label.LABEL_REQUIRED) LABEL_REQUIRED = 2, // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Label.LABEL_REPEATED) LABEL_REPEATED = 3, } impl crate::Enum for Label { const NAME: &'static str = "Label"; fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option