• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // This file is generated by rust-protobuf 2.22.0. Do not edit
2 // @generated
3 
4 // https://github.com/rust-lang/rust-clippy/issues/702
5 #![allow(unknown_lints)]
6 #![allow(clippy::all)]
7 
8 #![allow(unused_attributes)]
9 #![cfg_attr(rustfmt, rustfmt::skip)]
10 
11 #![allow(box_pointers)]
12 #![allow(dead_code)]
13 #![allow(missing_docs)]
14 #![allow(non_camel_case_types)]
15 #![allow(non_snake_case)]
16 #![allow(non_upper_case_globals)]
17 #![allow(trivial_casts)]
18 #![allow(unused_imports)]
19 #![allow(unused_results)]
20 //! Generated file from `google/protobuf/compiler/plugin.proto`
21 
22 #[derive(PartialEq,Clone,Default)]
23 #[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
24 pub struct Version {
25     // message fields
26     major: ::std::option::Option<i32>,
27     minor: ::std::option::Option<i32>,
28     patch: ::std::option::Option<i32>,
29     suffix: crate::SingularField<::std::string::String>,
30     // special fields
31     #[cfg_attr(feature = "with-serde", serde(skip))]
32     pub unknown_fields: crate::UnknownFields,
33     #[cfg_attr(feature = "with-serde", serde(skip))]
34     pub cached_size: crate::CachedSize,
35 }
36 
37 impl<'a> ::std::default::Default for &'a Version {
default() -> &'a Version38     fn default() -> &'a Version {
39         <Version as crate::Message>::default_instance()
40     }
41 }
42 
43 impl Version {
new() -> Version44     pub fn new() -> Version {
45         ::std::default::Default::default()
46     }
47 
48     // optional int32 major = 1;
49 
50 
get_major(&self) -> i3251     pub fn get_major(&self) -> i32 {
52         self.major.unwrap_or(0)
53     }
clear_major(&mut self)54     pub fn clear_major(&mut self) {
55         self.major = ::std::option::Option::None;
56     }
57 
has_major(&self) -> bool58     pub fn has_major(&self) -> bool {
59         self.major.is_some()
60     }
61 
62     // Param is passed by value, moved
set_major(&mut self, v: i32)63     pub fn set_major(&mut self, v: i32) {
64         self.major = ::std::option::Option::Some(v);
65     }
66 
67     // optional int32 minor = 2;
68 
69 
get_minor(&self) -> i3270     pub fn get_minor(&self) -> i32 {
71         self.minor.unwrap_or(0)
72     }
clear_minor(&mut self)73     pub fn clear_minor(&mut self) {
74         self.minor = ::std::option::Option::None;
75     }
76 
has_minor(&self) -> bool77     pub fn has_minor(&self) -> bool {
78         self.minor.is_some()
79     }
80 
81     // Param is passed by value, moved
set_minor(&mut self, v: i32)82     pub fn set_minor(&mut self, v: i32) {
83         self.minor = ::std::option::Option::Some(v);
84     }
85 
86     // optional int32 patch = 3;
87 
88 
get_patch(&self) -> i3289     pub fn get_patch(&self) -> i32 {
90         self.patch.unwrap_or(0)
91     }
clear_patch(&mut self)92     pub fn clear_patch(&mut self) {
93         self.patch = ::std::option::Option::None;
94     }
95 
has_patch(&self) -> bool96     pub fn has_patch(&self) -> bool {
97         self.patch.is_some()
98     }
99 
100     // Param is passed by value, moved
set_patch(&mut self, v: i32)101     pub fn set_patch(&mut self, v: i32) {
102         self.patch = ::std::option::Option::Some(v);
103     }
104 
105     // optional string suffix = 4;
106 
107 
get_suffix(&self) -> &str108     pub fn get_suffix(&self) -> &str {
109         match self.suffix.as_ref() {
110             Some(v) => &v,
111             None => "",
112         }
113     }
clear_suffix(&mut self)114     pub fn clear_suffix(&mut self) {
115         self.suffix.clear();
116     }
117 
has_suffix(&self) -> bool118     pub fn has_suffix(&self) -> bool {
119         self.suffix.is_some()
120     }
121 
122     // Param is passed by value, moved
set_suffix(&mut self, v: ::std::string::String)123     pub fn set_suffix(&mut self, v: ::std::string::String) {
124         self.suffix = crate::SingularField::some(v);
125     }
126 
127     // Mutable pointer to the field.
128     // If field is not initialized, it is initialized with default value first.
mut_suffix(&mut self) -> &mut ::std::string::String129     pub fn mut_suffix(&mut self) -> &mut ::std::string::String {
130         if self.suffix.is_none() {
131             self.suffix.set_default();
132         }
133         self.suffix.as_mut().unwrap()
134     }
135 
136     // Take field
take_suffix(&mut self) -> ::std::string::String137     pub fn take_suffix(&mut self) -> ::std::string::String {
138         self.suffix.take().unwrap_or_else(|| ::std::string::String::new())
139     }
140 }
141 
142 impl crate::Message for Version {
is_initialized(&self) -> bool143     fn is_initialized(&self) -> bool {
144         true
145     }
146 
merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()>147     fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
148         while !is.eof()? {
149             let (field_number, wire_type) = is.read_tag_unpack()?;
150             match field_number {
151                 1 => {
152                     if wire_type != crate::wire_format::WireTypeVarint {
153                         return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
154                     }
155                     let tmp = is.read_int32()?;
156                     self.major = ::std::option::Option::Some(tmp);
157                 },
158                 2 => {
159                     if wire_type != crate::wire_format::WireTypeVarint {
160                         return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
161                     }
162                     let tmp = is.read_int32()?;
163                     self.minor = ::std::option::Option::Some(tmp);
164                 },
165                 3 => {
166                     if wire_type != crate::wire_format::WireTypeVarint {
167                         return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
168                     }
169                     let tmp = is.read_int32()?;
170                     self.patch = ::std::option::Option::Some(tmp);
171                 },
172                 4 => {
173                     crate::rt::read_singular_string_into(wire_type, is, &mut self.suffix)?;
174                 },
175                 _ => {
176                     crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
177                 },
178             };
179         }
180         ::std::result::Result::Ok(())
181     }
182 
183     // Compute sizes of nested messages
184     #[allow(unused_variables)]
compute_size(&self) -> u32185     fn compute_size(&self) -> u32 {
186         let mut my_size = 0;
187         if let Some(v) = self.major {
188             my_size += crate::rt::value_size(1, v, crate::wire_format::WireTypeVarint);
189         }
190         if let Some(v) = self.minor {
191             my_size += crate::rt::value_size(2, v, crate::wire_format::WireTypeVarint);
192         }
193         if let Some(v) = self.patch {
194             my_size += crate::rt::value_size(3, v, crate::wire_format::WireTypeVarint);
195         }
196         if let Some(ref v) = self.suffix.as_ref() {
197             my_size += crate::rt::string_size(4, &v);
198         }
199         my_size += crate::rt::unknown_fields_size(self.get_unknown_fields());
200         self.cached_size.set(my_size);
201         my_size
202     }
203 
write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()>204     fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
205         if let Some(v) = self.major {
206             os.write_int32(1, v)?;
207         }
208         if let Some(v) = self.minor {
209             os.write_int32(2, v)?;
210         }
211         if let Some(v) = self.patch {
212             os.write_int32(3, v)?;
213         }
214         if let Some(ref v) = self.suffix.as_ref() {
215             os.write_string(4, &v)?;
216         }
217         os.write_unknown_fields(self.get_unknown_fields())?;
218         ::std::result::Result::Ok(())
219     }
220 
get_cached_size(&self) -> u32221     fn get_cached_size(&self) -> u32 {
222         self.cached_size.get()
223     }
224 
get_unknown_fields(&self) -> &crate::UnknownFields225     fn get_unknown_fields(&self) -> &crate::UnknownFields {
226         &self.unknown_fields
227     }
228 
mut_unknown_fields(&mut self) -> &mut crate::UnknownFields229     fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
230         &mut self.unknown_fields
231     }
232 
as_any(&self) -> &dyn (::std::any::Any)233     fn as_any(&self) -> &dyn (::std::any::Any) {
234         self as &dyn (::std::any::Any)
235     }
as_any_mut(&mut self) -> &mut dyn (::std::any::Any)236     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
237         self as &mut dyn (::std::any::Any)
238     }
into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)>239     fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
240         self
241     }
242 
descriptor(&self) -> &'static crate::reflect::MessageDescriptor243     fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
244         Self::descriptor_static()
245     }
246 
new() -> Version247     fn new() -> Version {
248         Version::new()
249     }
250 
descriptor_static() -> &'static crate::reflect::MessageDescriptor251     fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
252         static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
253         descriptor.get(|| {
254             let mut fields = ::std::vec::Vec::new();
255             fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
256                 "major",
257                 |m: &Version| { &m.major },
258                 |m: &mut Version| { &mut m.major },
259             ));
260             fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
261                 "minor",
262                 |m: &Version| { &m.minor },
263                 |m: &mut Version| { &mut m.minor },
264             ));
265             fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
266                 "patch",
267                 |m: &Version| { &m.patch },
268                 |m: &mut Version| { &mut m.patch },
269             ));
270             fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
271                 "suffix",
272                 |m: &Version| { &m.suffix },
273                 |m: &mut Version| { &mut m.suffix },
274             ));
275             crate::reflect::MessageDescriptor::new_pb_name::<Version>(
276                 "Version",
277                 fields,
278                 file_descriptor_proto()
279             )
280         })
281     }
282 
default_instance() -> &'static Version283     fn default_instance() -> &'static Version {
284         static instance: crate::rt::LazyV2<Version> = crate::rt::LazyV2::INIT;
285         instance.get(Version::new)
286     }
287 }
288 
289 impl crate::Clear for Version {
clear(&mut self)290     fn clear(&mut self) {
291         self.major = ::std::option::Option::None;
292         self.minor = ::std::option::Option::None;
293         self.patch = ::std::option::Option::None;
294         self.suffix.clear();
295         self.unknown_fields.clear();
296     }
297 }
298 
299 impl ::std::fmt::Debug for Version {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result300     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
301         crate::text_format::fmt(self, f)
302     }
303 }
304 
305 impl crate::reflect::ProtobufValue for Version {
as_ref(&self) -> crate::reflect::ReflectValueRef306     fn as_ref(&self) -> crate::reflect::ReflectValueRef {
307         crate::reflect::ReflectValueRef::Message(self)
308     }
309 }
310 
311 #[derive(PartialEq,Clone,Default)]
312 #[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
313 pub struct CodeGeneratorRequest {
314     // message fields
315     pub file_to_generate: crate::RepeatedField<::std::string::String>,
316     parameter: crate::SingularField<::std::string::String>,
317     pub proto_file: crate::RepeatedField<crate::descriptor::FileDescriptorProto>,
318     pub compiler_version: crate::SingularPtrField<Version>,
319     // special fields
320     #[cfg_attr(feature = "with-serde", serde(skip))]
321     pub unknown_fields: crate::UnknownFields,
322     #[cfg_attr(feature = "with-serde", serde(skip))]
323     pub cached_size: crate::CachedSize,
324 }
325 
326 impl<'a> ::std::default::Default for &'a CodeGeneratorRequest {
default() -> &'a CodeGeneratorRequest327     fn default() -> &'a CodeGeneratorRequest {
328         <CodeGeneratorRequest as crate::Message>::default_instance()
329     }
330 }
331 
332 impl CodeGeneratorRequest {
new() -> CodeGeneratorRequest333     pub fn new() -> CodeGeneratorRequest {
334         ::std::default::Default::default()
335     }
336 
337     // repeated string file_to_generate = 1;
338 
339 
get_file_to_generate(&self) -> &[::std::string::String]340     pub fn get_file_to_generate(&self) -> &[::std::string::String] {
341         &self.file_to_generate
342     }
clear_file_to_generate(&mut self)343     pub fn clear_file_to_generate(&mut self) {
344         self.file_to_generate.clear();
345     }
346 
347     // Param is passed by value, moved
set_file_to_generate(&mut self, v: crate::RepeatedField<::std::string::String>)348     pub fn set_file_to_generate(&mut self, v: crate::RepeatedField<::std::string::String>) {
349         self.file_to_generate = v;
350     }
351 
352     // Mutable pointer to the field.
mut_file_to_generate(&mut self) -> &mut crate::RepeatedField<::std::string::String>353     pub fn mut_file_to_generate(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
354         &mut self.file_to_generate
355     }
356 
357     // Take field
take_file_to_generate(&mut self) -> crate::RepeatedField<::std::string::String>358     pub fn take_file_to_generate(&mut self) -> crate::RepeatedField<::std::string::String> {
359         ::std::mem::replace(&mut self.file_to_generate, crate::RepeatedField::new())
360     }
361 
362     // optional string parameter = 2;
363 
364 
get_parameter(&self) -> &str365     pub fn get_parameter(&self) -> &str {
366         match self.parameter.as_ref() {
367             Some(v) => &v,
368             None => "",
369         }
370     }
clear_parameter(&mut self)371     pub fn clear_parameter(&mut self) {
372         self.parameter.clear();
373     }
374 
has_parameter(&self) -> bool375     pub fn has_parameter(&self) -> bool {
376         self.parameter.is_some()
377     }
378 
379     // Param is passed by value, moved
set_parameter(&mut self, v: ::std::string::String)380     pub fn set_parameter(&mut self, v: ::std::string::String) {
381         self.parameter = crate::SingularField::some(v);
382     }
383 
384     // Mutable pointer to the field.
385     // If field is not initialized, it is initialized with default value first.
mut_parameter(&mut self) -> &mut ::std::string::String386     pub fn mut_parameter(&mut self) -> &mut ::std::string::String {
387         if self.parameter.is_none() {
388             self.parameter.set_default();
389         }
390         self.parameter.as_mut().unwrap()
391     }
392 
393     // Take field
take_parameter(&mut self) -> ::std::string::String394     pub fn take_parameter(&mut self) -> ::std::string::String {
395         self.parameter.take().unwrap_or_else(|| ::std::string::String::new())
396     }
397 
398     // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
399 
400 
get_proto_file(&self) -> &[crate::descriptor::FileDescriptorProto]401     pub fn get_proto_file(&self) -> &[crate::descriptor::FileDescriptorProto] {
402         &self.proto_file
403     }
clear_proto_file(&mut self)404     pub fn clear_proto_file(&mut self) {
405         self.proto_file.clear();
406     }
407 
408     // Param is passed by value, moved
set_proto_file(&mut self, v: crate::RepeatedField<crate::descriptor::FileDescriptorProto>)409     pub fn set_proto_file(&mut self, v: crate::RepeatedField<crate::descriptor::FileDescriptorProto>) {
410         self.proto_file = v;
411     }
412 
413     // Mutable pointer to the field.
mut_proto_file(&mut self) -> &mut crate::RepeatedField<crate::descriptor::FileDescriptorProto>414     pub fn mut_proto_file(&mut self) -> &mut crate::RepeatedField<crate::descriptor::FileDescriptorProto> {
415         &mut self.proto_file
416     }
417 
418     // Take field
take_proto_file(&mut self) -> crate::RepeatedField<crate::descriptor::FileDescriptorProto>419     pub fn take_proto_file(&mut self) -> crate::RepeatedField<crate::descriptor::FileDescriptorProto> {
420         ::std::mem::replace(&mut self.proto_file, crate::RepeatedField::new())
421     }
422 
423     // optional .google.protobuf.compiler.Version compiler_version = 3;
424 
425 
get_compiler_version(&self) -> &Version426     pub fn get_compiler_version(&self) -> &Version {
427         self.compiler_version.as_ref().unwrap_or_else(|| <Version as crate::Message>::default_instance())
428     }
clear_compiler_version(&mut self)429     pub fn clear_compiler_version(&mut self) {
430         self.compiler_version.clear();
431     }
432 
has_compiler_version(&self) -> bool433     pub fn has_compiler_version(&self) -> bool {
434         self.compiler_version.is_some()
435     }
436 
437     // Param is passed by value, moved
set_compiler_version(&mut self, v: Version)438     pub fn set_compiler_version(&mut self, v: Version) {
439         self.compiler_version = crate::SingularPtrField::some(v);
440     }
441 
442     // Mutable pointer to the field.
443     // If field is not initialized, it is initialized with default value first.
mut_compiler_version(&mut self) -> &mut Version444     pub fn mut_compiler_version(&mut self) -> &mut Version {
445         if self.compiler_version.is_none() {
446             self.compiler_version.set_default();
447         }
448         self.compiler_version.as_mut().unwrap()
449     }
450 
451     // Take field
take_compiler_version(&mut self) -> Version452     pub fn take_compiler_version(&mut self) -> Version {
453         self.compiler_version.take().unwrap_or_else(|| Version::new())
454     }
455 }
456 
457 impl crate::Message for CodeGeneratorRequest {
is_initialized(&self) -> bool458     fn is_initialized(&self) -> bool {
459         for v in &self.proto_file {
460             if !v.is_initialized() {
461                 return false;
462             }
463         };
464         for v in &self.compiler_version {
465             if !v.is_initialized() {
466                 return false;
467             }
468         };
469         true
470     }
471 
merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()>472     fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
473         while !is.eof()? {
474             let (field_number, wire_type) = is.read_tag_unpack()?;
475             match field_number {
476                 1 => {
477                     crate::rt::read_repeated_string_into(wire_type, is, &mut self.file_to_generate)?;
478                 },
479                 2 => {
480                     crate::rt::read_singular_string_into(wire_type, is, &mut self.parameter)?;
481                 },
482                 15 => {
483                     crate::rt::read_repeated_message_into(wire_type, is, &mut self.proto_file)?;
484                 },
485                 3 => {
486                     crate::rt::read_singular_message_into(wire_type, is, &mut self.compiler_version)?;
487                 },
488                 _ => {
489                     crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
490                 },
491             };
492         }
493         ::std::result::Result::Ok(())
494     }
495 
496     // Compute sizes of nested messages
497     #[allow(unused_variables)]
compute_size(&self) -> u32498     fn compute_size(&self) -> u32 {
499         let mut my_size = 0;
500         for value in &self.file_to_generate {
501             my_size += crate::rt::string_size(1, &value);
502         };
503         if let Some(ref v) = self.parameter.as_ref() {
504             my_size += crate::rt::string_size(2, &v);
505         }
506         for value in &self.proto_file {
507             let len = value.compute_size();
508             my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
509         };
510         if let Some(ref v) = self.compiler_version.as_ref() {
511             let len = v.compute_size();
512             my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
513         }
514         my_size += crate::rt::unknown_fields_size(self.get_unknown_fields());
515         self.cached_size.set(my_size);
516         my_size
517     }
518 
write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()>519     fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
520         for v in &self.file_to_generate {
521             os.write_string(1, &v)?;
522         };
523         if let Some(ref v) = self.parameter.as_ref() {
524             os.write_string(2, &v)?;
525         }
526         for v in &self.proto_file {
527             os.write_tag(15, crate::wire_format::WireTypeLengthDelimited)?;
528             os.write_raw_varint32(v.get_cached_size())?;
529             v.write_to_with_cached_sizes(os)?;
530         };
531         if let Some(ref v) = self.compiler_version.as_ref() {
532             os.write_tag(3, crate::wire_format::WireTypeLengthDelimited)?;
533             os.write_raw_varint32(v.get_cached_size())?;
534             v.write_to_with_cached_sizes(os)?;
535         }
536         os.write_unknown_fields(self.get_unknown_fields())?;
537         ::std::result::Result::Ok(())
538     }
539 
get_cached_size(&self) -> u32540     fn get_cached_size(&self) -> u32 {
541         self.cached_size.get()
542     }
543 
get_unknown_fields(&self) -> &crate::UnknownFields544     fn get_unknown_fields(&self) -> &crate::UnknownFields {
545         &self.unknown_fields
546     }
547 
mut_unknown_fields(&mut self) -> &mut crate::UnknownFields548     fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
549         &mut self.unknown_fields
550     }
551 
as_any(&self) -> &dyn (::std::any::Any)552     fn as_any(&self) -> &dyn (::std::any::Any) {
553         self as &dyn (::std::any::Any)
554     }
as_any_mut(&mut self) -> &mut dyn (::std::any::Any)555     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
556         self as &mut dyn (::std::any::Any)
557     }
into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)>558     fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
559         self
560     }
561 
descriptor(&self) -> &'static crate::reflect::MessageDescriptor562     fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
563         Self::descriptor_static()
564     }
565 
new() -> CodeGeneratorRequest566     fn new() -> CodeGeneratorRequest {
567         CodeGeneratorRequest::new()
568     }
569 
descriptor_static() -> &'static crate::reflect::MessageDescriptor570     fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
571         static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
572         descriptor.get(|| {
573             let mut fields = ::std::vec::Vec::new();
574             fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
575                 "file_to_generate",
576                 |m: &CodeGeneratorRequest| { &m.file_to_generate },
577                 |m: &mut CodeGeneratorRequest| { &mut m.file_to_generate },
578             ));
579             fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
580                 "parameter",
581                 |m: &CodeGeneratorRequest| { &m.parameter },
582                 |m: &mut CodeGeneratorRequest| { &mut m.parameter },
583             ));
584             fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::descriptor::FileDescriptorProto>>(
585                 "proto_file",
586                 |m: &CodeGeneratorRequest| { &m.proto_file },
587                 |m: &mut CodeGeneratorRequest| { &mut m.proto_file },
588             ));
589             fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<Version>>(
590                 "compiler_version",
591                 |m: &CodeGeneratorRequest| { &m.compiler_version },
592                 |m: &mut CodeGeneratorRequest| { &mut m.compiler_version },
593             ));
594             crate::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorRequest>(
595                 "CodeGeneratorRequest",
596                 fields,
597                 file_descriptor_proto()
598             )
599         })
600     }
601 
default_instance() -> &'static CodeGeneratorRequest602     fn default_instance() -> &'static CodeGeneratorRequest {
603         static instance: crate::rt::LazyV2<CodeGeneratorRequest> = crate::rt::LazyV2::INIT;
604         instance.get(CodeGeneratorRequest::new)
605     }
606 }
607 
608 impl crate::Clear for CodeGeneratorRequest {
clear(&mut self)609     fn clear(&mut self) {
610         self.file_to_generate.clear();
611         self.parameter.clear();
612         self.proto_file.clear();
613         self.compiler_version.clear();
614         self.unknown_fields.clear();
615     }
616 }
617 
618 impl ::std::fmt::Debug for CodeGeneratorRequest {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result619     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
620         crate::text_format::fmt(self, f)
621     }
622 }
623 
624 impl crate::reflect::ProtobufValue for CodeGeneratorRequest {
as_ref(&self) -> crate::reflect::ReflectValueRef625     fn as_ref(&self) -> crate::reflect::ReflectValueRef {
626         crate::reflect::ReflectValueRef::Message(self)
627     }
628 }
629 
630 #[derive(PartialEq,Clone,Default)]
631 #[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
632 pub struct CodeGeneratorResponse {
633     // message fields
634     error: crate::SingularField<::std::string::String>,
635     supported_features: ::std::option::Option<u64>,
636     pub file: crate::RepeatedField<CodeGeneratorResponse_File>,
637     // special fields
638     #[cfg_attr(feature = "with-serde", serde(skip))]
639     pub unknown_fields: crate::UnknownFields,
640     #[cfg_attr(feature = "with-serde", serde(skip))]
641     pub cached_size: crate::CachedSize,
642 }
643 
644 impl<'a> ::std::default::Default for &'a CodeGeneratorResponse {
default() -> &'a CodeGeneratorResponse645     fn default() -> &'a CodeGeneratorResponse {
646         <CodeGeneratorResponse as crate::Message>::default_instance()
647     }
648 }
649 
650 impl CodeGeneratorResponse {
new() -> CodeGeneratorResponse651     pub fn new() -> CodeGeneratorResponse {
652         ::std::default::Default::default()
653     }
654 
655     // optional string error = 1;
656 
657 
get_error(&self) -> &str658     pub fn get_error(&self) -> &str {
659         match self.error.as_ref() {
660             Some(v) => &v,
661             None => "",
662         }
663     }
clear_error(&mut self)664     pub fn clear_error(&mut self) {
665         self.error.clear();
666     }
667 
has_error(&self) -> bool668     pub fn has_error(&self) -> bool {
669         self.error.is_some()
670     }
671 
672     // Param is passed by value, moved
set_error(&mut self, v: ::std::string::String)673     pub fn set_error(&mut self, v: ::std::string::String) {
674         self.error = crate::SingularField::some(v);
675     }
676 
677     // Mutable pointer to the field.
678     // If field is not initialized, it is initialized with default value first.
mut_error(&mut self) -> &mut ::std::string::String679     pub fn mut_error(&mut self) -> &mut ::std::string::String {
680         if self.error.is_none() {
681             self.error.set_default();
682         }
683         self.error.as_mut().unwrap()
684     }
685 
686     // Take field
take_error(&mut self) -> ::std::string::String687     pub fn take_error(&mut self) -> ::std::string::String {
688         self.error.take().unwrap_or_else(|| ::std::string::String::new())
689     }
690 
691     // optional uint64 supported_features = 2;
692 
693 
get_supported_features(&self) -> u64694     pub fn get_supported_features(&self) -> u64 {
695         self.supported_features.unwrap_or(0)
696     }
clear_supported_features(&mut self)697     pub fn clear_supported_features(&mut self) {
698         self.supported_features = ::std::option::Option::None;
699     }
700 
has_supported_features(&self) -> bool701     pub fn has_supported_features(&self) -> bool {
702         self.supported_features.is_some()
703     }
704 
705     // Param is passed by value, moved
set_supported_features(&mut self, v: u64)706     pub fn set_supported_features(&mut self, v: u64) {
707         self.supported_features = ::std::option::Option::Some(v);
708     }
709 
710     // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
711 
712 
get_file(&self) -> &[CodeGeneratorResponse_File]713     pub fn get_file(&self) -> &[CodeGeneratorResponse_File] {
714         &self.file
715     }
clear_file(&mut self)716     pub fn clear_file(&mut self) {
717         self.file.clear();
718     }
719 
720     // Param is passed by value, moved
set_file(&mut self, v: crate::RepeatedField<CodeGeneratorResponse_File>)721     pub fn set_file(&mut self, v: crate::RepeatedField<CodeGeneratorResponse_File>) {
722         self.file = v;
723     }
724 
725     // Mutable pointer to the field.
mut_file(&mut self) -> &mut crate::RepeatedField<CodeGeneratorResponse_File>726     pub fn mut_file(&mut self) -> &mut crate::RepeatedField<CodeGeneratorResponse_File> {
727         &mut self.file
728     }
729 
730     // Take field
take_file(&mut self) -> crate::RepeatedField<CodeGeneratorResponse_File>731     pub fn take_file(&mut self) -> crate::RepeatedField<CodeGeneratorResponse_File> {
732         ::std::mem::replace(&mut self.file, crate::RepeatedField::new())
733     }
734 }
735 
736 impl crate::Message for CodeGeneratorResponse {
is_initialized(&self) -> bool737     fn is_initialized(&self) -> bool {
738         for v in &self.file {
739             if !v.is_initialized() {
740                 return false;
741             }
742         };
743         true
744     }
745 
merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()>746     fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
747         while !is.eof()? {
748             let (field_number, wire_type) = is.read_tag_unpack()?;
749             match field_number {
750                 1 => {
751                     crate::rt::read_singular_string_into(wire_type, is, &mut self.error)?;
752                 },
753                 2 => {
754                     if wire_type != crate::wire_format::WireTypeVarint {
755                         return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
756                     }
757                     let tmp = is.read_uint64()?;
758                     self.supported_features = ::std::option::Option::Some(tmp);
759                 },
760                 15 => {
761                     crate::rt::read_repeated_message_into(wire_type, is, &mut self.file)?;
762                 },
763                 _ => {
764                     crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
765                 },
766             };
767         }
768         ::std::result::Result::Ok(())
769     }
770 
771     // Compute sizes of nested messages
772     #[allow(unused_variables)]
compute_size(&self) -> u32773     fn compute_size(&self) -> u32 {
774         let mut my_size = 0;
775         if let Some(ref v) = self.error.as_ref() {
776             my_size += crate::rt::string_size(1, &v);
777         }
778         if let Some(v) = self.supported_features {
779             my_size += crate::rt::value_size(2, v, crate::wire_format::WireTypeVarint);
780         }
781         for value in &self.file {
782             let len = value.compute_size();
783             my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
784         };
785         my_size += crate::rt::unknown_fields_size(self.get_unknown_fields());
786         self.cached_size.set(my_size);
787         my_size
788     }
789 
write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()>790     fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
791         if let Some(ref v) = self.error.as_ref() {
792             os.write_string(1, &v)?;
793         }
794         if let Some(v) = self.supported_features {
795             os.write_uint64(2, v)?;
796         }
797         for v in &self.file {
798             os.write_tag(15, crate::wire_format::WireTypeLengthDelimited)?;
799             os.write_raw_varint32(v.get_cached_size())?;
800             v.write_to_with_cached_sizes(os)?;
801         };
802         os.write_unknown_fields(self.get_unknown_fields())?;
803         ::std::result::Result::Ok(())
804     }
805 
get_cached_size(&self) -> u32806     fn get_cached_size(&self) -> u32 {
807         self.cached_size.get()
808     }
809 
get_unknown_fields(&self) -> &crate::UnknownFields810     fn get_unknown_fields(&self) -> &crate::UnknownFields {
811         &self.unknown_fields
812     }
813 
mut_unknown_fields(&mut self) -> &mut crate::UnknownFields814     fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
815         &mut self.unknown_fields
816     }
817 
as_any(&self) -> &dyn (::std::any::Any)818     fn as_any(&self) -> &dyn (::std::any::Any) {
819         self as &dyn (::std::any::Any)
820     }
as_any_mut(&mut self) -> &mut dyn (::std::any::Any)821     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
822         self as &mut dyn (::std::any::Any)
823     }
into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)>824     fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
825         self
826     }
827 
descriptor(&self) -> &'static crate::reflect::MessageDescriptor828     fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
829         Self::descriptor_static()
830     }
831 
new() -> CodeGeneratorResponse832     fn new() -> CodeGeneratorResponse {
833         CodeGeneratorResponse::new()
834     }
835 
descriptor_static() -> &'static crate::reflect::MessageDescriptor836     fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
837         static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
838         descriptor.get(|| {
839             let mut fields = ::std::vec::Vec::new();
840             fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
841                 "error",
842                 |m: &CodeGeneratorResponse| { &m.error },
843                 |m: &mut CodeGeneratorResponse| { &mut m.error },
844             ));
845             fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeUint64>(
846                 "supported_features",
847                 |m: &CodeGeneratorResponse| { &m.supported_features },
848                 |m: &mut CodeGeneratorResponse| { &mut m.supported_features },
849             ));
850             fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<CodeGeneratorResponse_File>>(
851                 "file",
852                 |m: &CodeGeneratorResponse| { &m.file },
853                 |m: &mut CodeGeneratorResponse| { &mut m.file },
854             ));
855             crate::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorResponse>(
856                 "CodeGeneratorResponse",
857                 fields,
858                 file_descriptor_proto()
859             )
860         })
861     }
862 
default_instance() -> &'static CodeGeneratorResponse863     fn default_instance() -> &'static CodeGeneratorResponse {
864         static instance: crate::rt::LazyV2<CodeGeneratorResponse> = crate::rt::LazyV2::INIT;
865         instance.get(CodeGeneratorResponse::new)
866     }
867 }
868 
869 impl crate::Clear for CodeGeneratorResponse {
clear(&mut self)870     fn clear(&mut self) {
871         self.error.clear();
872         self.supported_features = ::std::option::Option::None;
873         self.file.clear();
874         self.unknown_fields.clear();
875     }
876 }
877 
878 impl ::std::fmt::Debug for CodeGeneratorResponse {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result879     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
880         crate::text_format::fmt(self, f)
881     }
882 }
883 
884 impl crate::reflect::ProtobufValue for CodeGeneratorResponse {
as_ref(&self) -> crate::reflect::ReflectValueRef885     fn as_ref(&self) -> crate::reflect::ReflectValueRef {
886         crate::reflect::ReflectValueRef::Message(self)
887     }
888 }
889 
890 #[derive(PartialEq,Clone,Default)]
891 #[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
892 pub struct CodeGeneratorResponse_File {
893     // message fields
894     name: crate::SingularField<::std::string::String>,
895     insertion_point: crate::SingularField<::std::string::String>,
896     content: crate::SingularField<::std::string::String>,
897     pub generated_code_info: crate::SingularPtrField<crate::descriptor::GeneratedCodeInfo>,
898     // special fields
899     #[cfg_attr(feature = "with-serde", serde(skip))]
900     pub unknown_fields: crate::UnknownFields,
901     #[cfg_attr(feature = "with-serde", serde(skip))]
902     pub cached_size: crate::CachedSize,
903 }
904 
905 impl<'a> ::std::default::Default for &'a CodeGeneratorResponse_File {
default() -> &'a CodeGeneratorResponse_File906     fn default() -> &'a CodeGeneratorResponse_File {
907         <CodeGeneratorResponse_File as crate::Message>::default_instance()
908     }
909 }
910 
911 impl CodeGeneratorResponse_File {
new() -> CodeGeneratorResponse_File912     pub fn new() -> CodeGeneratorResponse_File {
913         ::std::default::Default::default()
914     }
915 
916     // optional string name = 1;
917 
918 
get_name(&self) -> &str919     pub fn get_name(&self) -> &str {
920         match self.name.as_ref() {
921             Some(v) => &v,
922             None => "",
923         }
924     }
clear_name(&mut self)925     pub fn clear_name(&mut self) {
926         self.name.clear();
927     }
928 
has_name(&self) -> bool929     pub fn has_name(&self) -> bool {
930         self.name.is_some()
931     }
932 
933     // Param is passed by value, moved
set_name(&mut self, v: ::std::string::String)934     pub fn set_name(&mut self, v: ::std::string::String) {
935         self.name = crate::SingularField::some(v);
936     }
937 
938     // Mutable pointer to the field.
939     // If field is not initialized, it is initialized with default value first.
mut_name(&mut self) -> &mut ::std::string::String940     pub fn mut_name(&mut self) -> &mut ::std::string::String {
941         if self.name.is_none() {
942             self.name.set_default();
943         }
944         self.name.as_mut().unwrap()
945     }
946 
947     // Take field
take_name(&mut self) -> ::std::string::String948     pub fn take_name(&mut self) -> ::std::string::String {
949         self.name.take().unwrap_or_else(|| ::std::string::String::new())
950     }
951 
952     // optional string insertion_point = 2;
953 
954 
get_insertion_point(&self) -> &str955     pub fn get_insertion_point(&self) -> &str {
956         match self.insertion_point.as_ref() {
957             Some(v) => &v,
958             None => "",
959         }
960     }
clear_insertion_point(&mut self)961     pub fn clear_insertion_point(&mut self) {
962         self.insertion_point.clear();
963     }
964 
has_insertion_point(&self) -> bool965     pub fn has_insertion_point(&self) -> bool {
966         self.insertion_point.is_some()
967     }
968 
969     // Param is passed by value, moved
set_insertion_point(&mut self, v: ::std::string::String)970     pub fn set_insertion_point(&mut self, v: ::std::string::String) {
971         self.insertion_point = crate::SingularField::some(v);
972     }
973 
974     // Mutable pointer to the field.
975     // If field is not initialized, it is initialized with default value first.
mut_insertion_point(&mut self) -> &mut ::std::string::String976     pub fn mut_insertion_point(&mut self) -> &mut ::std::string::String {
977         if self.insertion_point.is_none() {
978             self.insertion_point.set_default();
979         }
980         self.insertion_point.as_mut().unwrap()
981     }
982 
983     // Take field
take_insertion_point(&mut self) -> ::std::string::String984     pub fn take_insertion_point(&mut self) -> ::std::string::String {
985         self.insertion_point.take().unwrap_or_else(|| ::std::string::String::new())
986     }
987 
988     // optional string content = 15;
989 
990 
get_content(&self) -> &str991     pub fn get_content(&self) -> &str {
992         match self.content.as_ref() {
993             Some(v) => &v,
994             None => "",
995         }
996     }
clear_content(&mut self)997     pub fn clear_content(&mut self) {
998         self.content.clear();
999     }
1000 
has_content(&self) -> bool1001     pub fn has_content(&self) -> bool {
1002         self.content.is_some()
1003     }
1004 
1005     // Param is passed by value, moved
set_content(&mut self, v: ::std::string::String)1006     pub fn set_content(&mut self, v: ::std::string::String) {
1007         self.content = crate::SingularField::some(v);
1008     }
1009 
1010     // Mutable pointer to the field.
1011     // If field is not initialized, it is initialized with default value first.
mut_content(&mut self) -> &mut ::std::string::String1012     pub fn mut_content(&mut self) -> &mut ::std::string::String {
1013         if self.content.is_none() {
1014             self.content.set_default();
1015         }
1016         self.content.as_mut().unwrap()
1017     }
1018 
1019     // Take field
take_content(&mut self) -> ::std::string::String1020     pub fn take_content(&mut self) -> ::std::string::String {
1021         self.content.take().unwrap_or_else(|| ::std::string::String::new())
1022     }
1023 
1024     // optional .google.protobuf.GeneratedCodeInfo generated_code_info = 16;
1025 
1026 
get_generated_code_info(&self) -> &crate::descriptor::GeneratedCodeInfo1027     pub fn get_generated_code_info(&self) -> &crate::descriptor::GeneratedCodeInfo {
1028         self.generated_code_info.as_ref().unwrap_or_else(|| <crate::descriptor::GeneratedCodeInfo as crate::Message>::default_instance())
1029     }
clear_generated_code_info(&mut self)1030     pub fn clear_generated_code_info(&mut self) {
1031         self.generated_code_info.clear();
1032     }
1033 
has_generated_code_info(&self) -> bool1034     pub fn has_generated_code_info(&self) -> bool {
1035         self.generated_code_info.is_some()
1036     }
1037 
1038     // Param is passed by value, moved
set_generated_code_info(&mut self, v: crate::descriptor::GeneratedCodeInfo)1039     pub fn set_generated_code_info(&mut self, v: crate::descriptor::GeneratedCodeInfo) {
1040         self.generated_code_info = crate::SingularPtrField::some(v);
1041     }
1042 
1043     // Mutable pointer to the field.
1044     // If field is not initialized, it is initialized with default value first.
mut_generated_code_info(&mut self) -> &mut crate::descriptor::GeneratedCodeInfo1045     pub fn mut_generated_code_info(&mut self) -> &mut crate::descriptor::GeneratedCodeInfo {
1046         if self.generated_code_info.is_none() {
1047             self.generated_code_info.set_default();
1048         }
1049         self.generated_code_info.as_mut().unwrap()
1050     }
1051 
1052     // Take field
take_generated_code_info(&mut self) -> crate::descriptor::GeneratedCodeInfo1053     pub fn take_generated_code_info(&mut self) -> crate::descriptor::GeneratedCodeInfo {
1054         self.generated_code_info.take().unwrap_or_else(|| crate::descriptor::GeneratedCodeInfo::new())
1055     }
1056 }
1057 
1058 impl crate::Message for CodeGeneratorResponse_File {
is_initialized(&self) -> bool1059     fn is_initialized(&self) -> bool {
1060         for v in &self.generated_code_info {
1061             if !v.is_initialized() {
1062                 return false;
1063             }
1064         };
1065         true
1066     }
1067 
merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()>1068     fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
1069         while !is.eof()? {
1070             let (field_number, wire_type) = is.read_tag_unpack()?;
1071             match field_number {
1072                 1 => {
1073                     crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
1074                 },
1075                 2 => {
1076                     crate::rt::read_singular_string_into(wire_type, is, &mut self.insertion_point)?;
1077                 },
1078                 15 => {
1079                     crate::rt::read_singular_string_into(wire_type, is, &mut self.content)?;
1080                 },
1081                 16 => {
1082                     crate::rt::read_singular_message_into(wire_type, is, &mut self.generated_code_info)?;
1083                 },
1084                 _ => {
1085                     crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1086                 },
1087             };
1088         }
1089         ::std::result::Result::Ok(())
1090     }
1091 
1092     // Compute sizes of nested messages
1093     #[allow(unused_variables)]
compute_size(&self) -> u321094     fn compute_size(&self) -> u32 {
1095         let mut my_size = 0;
1096         if let Some(ref v) = self.name.as_ref() {
1097             my_size += crate::rt::string_size(1, &v);
1098         }
1099         if let Some(ref v) = self.insertion_point.as_ref() {
1100             my_size += crate::rt::string_size(2, &v);
1101         }
1102         if let Some(ref v) = self.content.as_ref() {
1103             my_size += crate::rt::string_size(15, &v);
1104         }
1105         if let Some(ref v) = self.generated_code_info.as_ref() {
1106             let len = v.compute_size();
1107             my_size += 2 + crate::rt::compute_raw_varint32_size(len) + len;
1108         }
1109         my_size += crate::rt::unknown_fields_size(self.get_unknown_fields());
1110         self.cached_size.set(my_size);
1111         my_size
1112     }
1113 
write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()>1114     fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
1115         if let Some(ref v) = self.name.as_ref() {
1116             os.write_string(1, &v)?;
1117         }
1118         if let Some(ref v) = self.insertion_point.as_ref() {
1119             os.write_string(2, &v)?;
1120         }
1121         if let Some(ref v) = self.content.as_ref() {
1122             os.write_string(15, &v)?;
1123         }
1124         if let Some(ref v) = self.generated_code_info.as_ref() {
1125             os.write_tag(16, crate::wire_format::WireTypeLengthDelimited)?;
1126             os.write_raw_varint32(v.get_cached_size())?;
1127             v.write_to_with_cached_sizes(os)?;
1128         }
1129         os.write_unknown_fields(self.get_unknown_fields())?;
1130         ::std::result::Result::Ok(())
1131     }
1132 
get_cached_size(&self) -> u321133     fn get_cached_size(&self) -> u32 {
1134         self.cached_size.get()
1135     }
1136 
get_unknown_fields(&self) -> &crate::UnknownFields1137     fn get_unknown_fields(&self) -> &crate::UnknownFields {
1138         &self.unknown_fields
1139     }
1140 
mut_unknown_fields(&mut self) -> &mut crate::UnknownFields1141     fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
1142         &mut self.unknown_fields
1143     }
1144 
as_any(&self) -> &dyn (::std::any::Any)1145     fn as_any(&self) -> &dyn (::std::any::Any) {
1146         self as &dyn (::std::any::Any)
1147     }
as_any_mut(&mut self) -> &mut dyn (::std::any::Any)1148     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1149         self as &mut dyn (::std::any::Any)
1150     }
into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)>1151     fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1152         self
1153     }
1154 
descriptor(&self) -> &'static crate::reflect::MessageDescriptor1155     fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
1156         Self::descriptor_static()
1157     }
1158 
new() -> CodeGeneratorResponse_File1159     fn new() -> CodeGeneratorResponse_File {
1160         CodeGeneratorResponse_File::new()
1161     }
1162 
descriptor_static() -> &'static crate::reflect::MessageDescriptor1163     fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
1164         static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
1165         descriptor.get(|| {
1166             let mut fields = ::std::vec::Vec::new();
1167             fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
1168                 "name",
1169                 |m: &CodeGeneratorResponse_File| { &m.name },
1170                 |m: &mut CodeGeneratorResponse_File| { &mut m.name },
1171             ));
1172             fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
1173                 "insertion_point",
1174                 |m: &CodeGeneratorResponse_File| { &m.insertion_point },
1175                 |m: &mut CodeGeneratorResponse_File| { &mut m.insertion_point },
1176             ));
1177             fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
1178                 "content",
1179                 |m: &CodeGeneratorResponse_File| { &m.content },
1180                 |m: &mut CodeGeneratorResponse_File| { &mut m.content },
1181             ));
1182             fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::descriptor::GeneratedCodeInfo>>(
1183                 "generated_code_info",
1184                 |m: &CodeGeneratorResponse_File| { &m.generated_code_info },
1185                 |m: &mut CodeGeneratorResponse_File| { &mut m.generated_code_info },
1186             ));
1187             crate::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorResponse_File>(
1188                 "CodeGeneratorResponse.File",
1189                 fields,
1190                 file_descriptor_proto()
1191             )
1192         })
1193     }
1194 
default_instance() -> &'static CodeGeneratorResponse_File1195     fn default_instance() -> &'static CodeGeneratorResponse_File {
1196         static instance: crate::rt::LazyV2<CodeGeneratorResponse_File> = crate::rt::LazyV2::INIT;
1197         instance.get(CodeGeneratorResponse_File::new)
1198     }
1199 }
1200 
1201 impl crate::Clear for CodeGeneratorResponse_File {
clear(&mut self)1202     fn clear(&mut self) {
1203         self.name.clear();
1204         self.insertion_point.clear();
1205         self.content.clear();
1206         self.generated_code_info.clear();
1207         self.unknown_fields.clear();
1208     }
1209 }
1210 
1211 impl ::std::fmt::Debug for CodeGeneratorResponse_File {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1212     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1213         crate::text_format::fmt(self, f)
1214     }
1215 }
1216 
1217 impl crate::reflect::ProtobufValue for CodeGeneratorResponse_File {
as_ref(&self) -> crate::reflect::ReflectValueRef1218     fn as_ref(&self) -> crate::reflect::ReflectValueRef {
1219         crate::reflect::ReflectValueRef::Message(self)
1220     }
1221 }
1222 
1223 #[derive(Clone,PartialEq,Eq,Debug,Hash)]
1224 #[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
1225 pub enum CodeGeneratorResponse_Feature {
1226     FEATURE_NONE = 0,
1227     FEATURE_PROTO3_OPTIONAL = 1,
1228 }
1229 
1230 impl crate::ProtobufEnum for CodeGeneratorResponse_Feature {
value(&self) -> i321231     fn value(&self) -> i32 {
1232         *self as i32
1233     }
1234 
from_i32(value: i32) -> ::std::option::Option<CodeGeneratorResponse_Feature>1235     fn from_i32(value: i32) -> ::std::option::Option<CodeGeneratorResponse_Feature> {
1236         match value {
1237             0 => ::std::option::Option::Some(CodeGeneratorResponse_Feature::FEATURE_NONE),
1238             1 => ::std::option::Option::Some(CodeGeneratorResponse_Feature::FEATURE_PROTO3_OPTIONAL),
1239             _ => ::std::option::Option::None
1240         }
1241     }
1242 
values() -> &'static [Self]1243     fn values() -> &'static [Self] {
1244         static values: &'static [CodeGeneratorResponse_Feature] = &[
1245             CodeGeneratorResponse_Feature::FEATURE_NONE,
1246             CodeGeneratorResponse_Feature::FEATURE_PROTO3_OPTIONAL,
1247         ];
1248         values
1249     }
1250 
enum_descriptor_static() -> &'static crate::reflect::EnumDescriptor1251     fn enum_descriptor_static() -> &'static crate::reflect::EnumDescriptor {
1252         static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
1253         descriptor.get(|| {
1254             crate::reflect::EnumDescriptor::new_pb_name::<CodeGeneratorResponse_Feature>("CodeGeneratorResponse.Feature", file_descriptor_proto())
1255         })
1256     }
1257 }
1258 
1259 impl ::std::marker::Copy for CodeGeneratorResponse_Feature {
1260 }
1261 
1262 impl ::std::default::Default for CodeGeneratorResponse_Feature {
default() -> Self1263     fn default() -> Self {
1264         CodeGeneratorResponse_Feature::FEATURE_NONE
1265     }
1266 }
1267 
1268 impl crate::reflect::ProtobufValue for CodeGeneratorResponse_Feature {
as_ref(&self) -> crate::reflect::ReflectValueRef1269     fn as_ref(&self) -> crate::reflect::ReflectValueRef {
1270         crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
1271     }
1272 }
1273 
1274 static file_descriptor_proto_data: &'static [u8] = b"\
1275     \n%google/protobuf/compiler/plugin.proto\x12\x18google.protobuf.compiler\
1276     \x1a\x20google/protobuf/descriptor.proto\"c\n\x07Version\x12\x14\n\x05ma\
1277     jor\x18\x01\x20\x01(\x05R\x05major\x12\x14\n\x05minor\x18\x02\x20\x01(\
1278     \x05R\x05minor\x12\x14\n\x05patch\x18\x03\x20\x01(\x05R\x05patch\x12\x16\
1279     \n\x06suffix\x18\x04\x20\x01(\tR\x06suffix\"\xf1\x01\n\x14CodeGeneratorR\
1280     equest\x12(\n\x10file_to_generate\x18\x01\x20\x03(\tR\x0efileToGenerate\
1281     \x12\x1c\n\tparameter\x18\x02\x20\x01(\tR\tparameter\x12C\n\nproto_file\
1282     \x18\x0f\x20\x03(\x0b2$.google.protobuf.FileDescriptorProtoR\tprotoFile\
1283     \x12L\n\x10compiler_version\x18\x03\x20\x01(\x0b2!.google.protobuf.compi\
1284     ler.VersionR\x0fcompilerVersion\"\x94\x03\n\x15CodeGeneratorResponse\x12\
1285     \x14\n\x05error\x18\x01\x20\x01(\tR\x05error\x12-\n\x12supported_feature\
1286     s\x18\x02\x20\x01(\x04R\x11supportedFeatures\x12H\n\x04file\x18\x0f\x20\
1287     \x03(\x0b24.google.protobuf.compiler.CodeGeneratorResponse.FileR\x04file\
1288     \x1a\xb1\x01\n\x04File\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\
1289     '\n\x0finsertion_point\x18\x02\x20\x01(\tR\x0einsertionPoint\x12\x18\n\
1290     \x07content\x18\x0f\x20\x01(\tR\x07content\x12R\n\x13generated_code_info\
1291     \x18\x10\x20\x01(\x0b2\".google.protobuf.GeneratedCodeInfoR\x11generated\
1292     CodeInfo\"8\n\x07Feature\x12\x10\n\x0cFEATURE_NONE\x10\0\x12\x1b\n\x17FE\
1293     ATURE_PROTO3_OPTIONAL\x10\x01BW\n\x1ccom.google.protobuf.compilerB\x0cPl\
1294     uginProtosZ)google.golang.org/protobuf/types/pluginpbJ\xf9C\n\x07\x12\
1295     \x05.\0\xb6\x01\x01\n\xca\x11\n\x01\x0c\x12\x03.\0\x122\xc1\x0c\x20Proto\
1296     col\x20Buffers\x20-\x20Google's\x20data\x20interchange\x20format\n\x20Co\
1297     pyright\x202008\x20Google\x20Inc.\x20\x20All\x20rights\x20reserved.\n\
1298     \x20https://developers.google.com/protocol-buffers/\n\n\x20Redistributio\
1299     n\x20and\x20use\x20in\x20source\x20and\x20binary\x20forms,\x20with\x20or\
1300     \x20without\n\x20modification,\x20are\x20permitted\x20provided\x20that\
1301     \x20the\x20following\x20conditions\x20are\n\x20met:\n\n\x20\x20\x20\x20\
1302     \x20*\x20Redistributions\x20of\x20source\x20code\x20must\x20retain\x20th\
1303     e\x20above\x20copyright\n\x20notice,\x20this\x20list\x20of\x20conditions\
1304     \x20and\x20the\x20following\x20disclaimer.\n\x20\x20\x20\x20\x20*\x20Red\
1305     istributions\x20in\x20binary\x20form\x20must\x20reproduce\x20the\x20abov\
1306     e\n\x20copyright\x20notice,\x20this\x20list\x20of\x20conditions\x20and\
1307     \x20the\x20following\x20disclaimer\n\x20in\x20the\x20documentation\x20an\
1308     d/or\x20other\x20materials\x20provided\x20with\x20the\n\x20distribution.\
1309     \n\x20\x20\x20\x20\x20*\x20Neither\x20the\x20name\x20of\x20Google\x20Inc\
1310     .\x20nor\x20the\x20names\x20of\x20its\n\x20contributors\x20may\x20be\x20\
1311     used\x20to\x20endorse\x20or\x20promote\x20products\x20derived\x20from\n\
1312     \x20this\x20software\x20without\x20specific\x20prior\x20written\x20permi\
1313     ssion.\n\n\x20THIS\x20SOFTWARE\x20IS\x20PROVIDED\x20BY\x20THE\x20COPYRIG\
1314     HT\x20HOLDERS\x20AND\x20CONTRIBUTORS\n\x20\"AS\x20IS\"\x20AND\x20ANY\x20\
1315     EXPRESS\x20OR\x20IMPLIED\x20WARRANTIES,\x20INCLUDING,\x20BUT\x20NOT\n\
1316     \x20LIMITED\x20TO,\x20THE\x20IMPLIED\x20WARRANTIES\x20OF\x20MERCHANTABIL\
1317     ITY\x20AND\x20FITNESS\x20FOR\n\x20A\x20PARTICULAR\x20PURPOSE\x20ARE\x20D\
1318     ISCLAIMED.\x20IN\x20NO\x20EVENT\x20SHALL\x20THE\x20COPYRIGHT\n\x20OWNER\
1319     \x20OR\x20CONTRIBUTORS\x20BE\x20LIABLE\x20FOR\x20ANY\x20DIRECT,\x20INDIR\
1320     ECT,\x20INCIDENTAL,\n\x20SPECIAL,\x20EXEMPLARY,\x20OR\x20CONSEQUENTIAL\
1321     \x20DAMAGES\x20(INCLUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\x20PROCUREM\
1322     ENT\x20OF\x20SUBSTITUTE\x20GOODS\x20OR\x20SERVICES;\x20LOSS\x20OF\x20USE\
1323     ,\n\x20DATA,\x20OR\x20PROFITS;\x20OR\x20BUSINESS\x20INTERRUPTION)\x20HOW\
1324     EVER\x20CAUSED\x20AND\x20ON\x20ANY\n\x20THEORY\x20OF\x20LIABILITY,\x20WH\
1325     ETHER\x20IN\x20CONTRACT,\x20STRICT\x20LIABILITY,\x20OR\x20TORT\n\x20(INC\
1326     LUDING\x20NEGLIGENCE\x20OR\x20OTHERWISE)\x20ARISING\x20IN\x20ANY\x20WAY\
1327     \x20OUT\x20OF\x20THE\x20USE\n\x20OF\x20THIS\x20SOFTWARE,\x20EVEN\x20IF\
1328     \x20ADVISED\x20OF\x20THE\x20POSSIBILITY\x20OF\x20SUCH\x20DAMAGE.\n2\xfb\
1329     \x04\x20Author:\x20kenton@google.com\x20(Kenton\x20Varda)\n\n\x20WARNING\
1330     :\x20\x20The\x20plugin\x20interface\x20is\x20currently\x20EXPERIMENTAL\
1331     \x20and\x20is\x20subject\x20to\n\x20\x20\x20change.\n\n\x20protoc\x20(ak\
1332     a\x20the\x20Protocol\x20Compiler)\x20can\x20be\x20extended\x20via\x20plu\
1333     gins.\x20\x20A\x20plugin\x20is\n\x20just\x20a\x20program\x20that\x20read\
1334     s\x20a\x20CodeGeneratorRequest\x20from\x20stdin\x20and\x20writes\x20a\n\
1335     \x20CodeGeneratorResponse\x20to\x20stdout.\n\n\x20Plugins\x20written\x20\
1336     using\x20C++\x20can\x20use\x20google/protobuf/compiler/plugin.h\x20inste\
1337     ad\n\x20of\x20dealing\x20with\x20the\x20raw\x20protocol\x20defined\x20he\
1338     re.\n\n\x20A\x20plugin\x20executable\x20needs\x20only\x20to\x20be\x20pla\
1339     ced\x20somewhere\x20in\x20the\x20path.\x20\x20The\n\x20plugin\x20should\
1340     \x20be\x20named\x20\"protoc-gen-$NAME\",\x20and\x20will\x20then\x20be\
1341     \x20used\x20when\x20the\n\x20flag\x20\"--${NAME}_out\"\x20is\x20passed\
1342     \x20to\x20protoc.\n\n\x08\n\x01\x02\x12\x030\0!\n\x08\n\x01\x08\x12\x031\
1343     \05\n\t\n\x02\x08\x01\x12\x031\05\n\x08\n\x01\x08\x12\x032\0-\n\t\n\x02\
1344     \x08\x08\x12\x032\0-\n\x08\n\x01\x08\x12\x034\0@\n\t\n\x02\x08\x0b\x12\
1345     \x034\0@\n\t\n\x02\x03\0\x12\x036\0*\n6\n\x02\x04\0\x12\x049\0@\x01\x1a*\
1346     \x20The\x20version\x20number\x20of\x20protocol\x20compiler.\n\n\n\n\x03\
1347     \x04\0\x01\x12\x039\x08\x0f\n\x0b\n\x04\x04\0\x02\0\x12\x03:\x02\x1b\n\
1348     \x0c\n\x05\x04\0\x02\0\x04\x12\x03:\x02\n\n\x0c\n\x05\x04\0\x02\0\x05\
1349     \x12\x03:\x0b\x10\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03:\x11\x16\n\x0c\n\
1350     \x05\x04\0\x02\0\x03\x12\x03:\x19\x1a\n\x0b\n\x04\x04\0\x02\x01\x12\x03;\
1351     \x02\x1b\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x03;\x02\n\n\x0c\n\x05\x04\0\
1352     \x02\x01\x05\x12\x03;\x0b\x10\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03;\x11\
1353     \x16\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03;\x19\x1a\n\x0b\n\x04\x04\0\
1354     \x02\x02\x12\x03<\x02\x1b\n\x0c\n\x05\x04\0\x02\x02\x04\x12\x03<\x02\n\n\
1355     \x0c\n\x05\x04\0\x02\x02\x05\x12\x03<\x0b\x10\n\x0c\n\x05\x04\0\x02\x02\
1356     \x01\x12\x03<\x11\x16\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03<\x19\x1a\n\
1357     \x80\x01\n\x04\x04\0\x02\x03\x12\x03?\x02\x1d\x1as\x20A\x20suffix\x20for\
1358     \x20alpha,\x20beta\x20or\x20rc\x20release,\x20e.g.,\x20\"alpha-1\",\x20\
1359     \"rc2\".\x20It\x20should\n\x20be\x20empty\x20for\x20mainline\x20stable\
1360     \x20releases.\n\n\x0c\n\x05\x04\0\x02\x03\x04\x12\x03?\x02\n\n\x0c\n\x05\
1361     \x04\0\x02\x03\x05\x12\x03?\x0b\x11\n\x0c\n\x05\x04\0\x02\x03\x01\x12\
1362     \x03?\x12\x18\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03?\x1b\x1c\nO\n\x02\
1363     \x04\x01\x12\x04C\0_\x01\x1aC\x20An\x20encoded\x20CodeGeneratorRequest\
1364     \x20is\x20written\x20to\x20the\x20plugin's\x20stdin.\n\n\n\n\x03\x04\x01\
1365     \x01\x12\x03C\x08\x1c\n\xd1\x01\n\x04\x04\x01\x02\0\x12\x03G\x02'\x1a\
1366     \xc3\x01\x20The\x20.proto\x20files\x20that\x20were\x20explicitly\x20list\
1367     ed\x20on\x20the\x20command-line.\x20\x20The\n\x20code\x20generator\x20sh\
1368     ould\x20generate\x20code\x20only\x20for\x20these\x20files.\x20\x20Each\
1369     \x20file's\n\x20descriptor\x20will\x20be\x20included\x20in\x20proto_file\
1370     ,\x20below.\n\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03G\x02\n\n\x0c\n\x05\
1371     \x04\x01\x02\0\x05\x12\x03G\x0b\x11\n\x0c\n\x05\x04\x01\x02\0\x01\x12\
1372     \x03G\x12\"\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03G%&\nB\n\x04\x04\x01\
1373     \x02\x01\x12\x03J\x02\x20\x1a5\x20The\x20generator\x20parameter\x20passe\
1374     d\x20on\x20the\x20command-line.\n\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\
1375     \x03J\x02\n\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03J\x0b\x11\n\x0c\n\x05\
1376     \x04\x01\x02\x01\x01\x12\x03J\x12\x1b\n\x0c\n\x05\x04\x01\x02\x01\x03\
1377     \x12\x03J\x1e\x1f\n\x87\x06\n\x04\x04\x01\x02\x02\x12\x03Z\x02/\x1a\xf9\
1378     \x05\x20FileDescriptorProtos\x20for\x20all\x20files\x20in\x20files_to_ge\
1379     nerate\x20and\x20everything\n\x20they\x20import.\x20\x20The\x20files\x20\
1380     will\x20appear\x20in\x20topological\x20order,\x20so\x20each\x20file\n\
1381     \x20appears\x20before\x20any\x20file\x20that\x20imports\x20it.\n\n\x20pr\
1382     otoc\x20guarantees\x20that\x20all\x20proto_files\x20will\x20be\x20writte\
1383     n\x20after\n\x20the\x20fields\x20above,\x20even\x20though\x20this\x20is\
1384     \x20not\x20technically\x20guaranteed\x20by\x20the\n\x20protobuf\x20wire\
1385     \x20format.\x20\x20This\x20theoretically\x20could\x20allow\x20a\x20plugi\
1386     n\x20to\x20stream\n\x20in\x20the\x20FileDescriptorProtos\x20and\x20handl\
1387     e\x20them\x20one\x20by\x20one\x20rather\x20than\x20read\n\x20the\x20enti\
1388     re\x20set\x20into\x20memory\x20at\x20once.\x20\x20However,\x20as\x20of\
1389     \x20this\x20writing,\x20this\n\x20is\x20not\x20similarly\x20optimized\
1390     \x20on\x20protoc's\x20end\x20--\x20it\x20will\x20store\x20all\x20fields\
1391     \x20in\n\x20memory\x20at\x20once\x20before\x20sending\x20them\x20to\x20t\
1392     he\x20plugin.\n\n\x20Type\x20names\x20of\x20fields\x20and\x20extensions\
1393     \x20in\x20the\x20FileDescriptorProto\x20are\x20always\n\x20fully\x20qual\
1394     ified.\n\n\x0c\n\x05\x04\x01\x02\x02\x04\x12\x03Z\x02\n\n\x0c\n\x05\x04\
1395     \x01\x02\x02\x06\x12\x03Z\x0b\x1e\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\
1396     \x03Z\x1f)\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03Z,.\n7\n\x04\x04\x01\
1397     \x02\x03\x12\x03]\x02(\x1a*\x20The\x20version\x20number\x20of\x20protoco\
1398     l\x20compiler.\n\n\x0c\n\x05\x04\x01\x02\x03\x04\x12\x03]\x02\n\n\x0c\n\
1399     \x05\x04\x01\x02\x03\x06\x12\x03]\x0b\x12\n\x0c\n\x05\x04\x01\x02\x03\
1400     \x01\x12\x03]\x13#\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03]&'\nL\n\x02\
1401     \x04\x02\x12\x05b\0\xb6\x01\x01\x1a?\x20The\x20plugin\x20writes\x20an\
1402     \x20encoded\x20CodeGeneratorResponse\x20to\x20stdout.\n\n\n\n\x03\x04\
1403     \x02\x01\x12\x03b\x08\x1d\n\xed\x03\n\x04\x04\x02\x02\0\x12\x03k\x02\x1c\
1404     \x1a\xdf\x03\x20Error\x20message.\x20\x20If\x20non-empty,\x20code\x20gen\
1405     eration\x20failed.\x20\x20The\x20plugin\x20process\n\x20should\x20exit\
1406     \x20with\x20status\x20code\x20zero\x20even\x20if\x20it\x20reports\x20an\
1407     \x20error\x20in\x20this\x20way.\n\n\x20This\x20should\x20be\x20used\x20t\
1408     o\x20indicate\x20errors\x20in\x20.proto\x20files\x20which\x20prevent\x20\
1409     the\n\x20code\x20generator\x20from\x20generating\x20correct\x20code.\x20\
1410     \x20Errors\x20which\x20indicate\x20a\n\x20problem\x20in\x20protoc\x20its\
1411     elf\x20--\x20such\x20as\x20the\x20input\x20CodeGeneratorRequest\x20being\
1412     \n\x20unparseable\x20--\x20should\x20be\x20reported\x20by\x20writing\x20\
1413     a\x20message\x20to\x20stderr\x20and\n\x20exiting\x20with\x20a\x20non-zer\
1414     o\x20status\x20code.\n\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03k\x02\n\n\
1415     \x0c\n\x05\x04\x02\x02\0\x05\x12\x03k\x0b\x11\n\x0c\n\x05\x04\x02\x02\0\
1416     \x01\x12\x03k\x12\x17\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03k\x1a\x1b\n\
1417     \x89\x01\n\x04\x04\x02\x02\x01\x12\x03o\x02)\x1a|\x20A\x20bitmask\x20of\
1418     \x20supported\x20features\x20that\x20the\x20code\x20generator\x20support\
1419     s.\n\x20This\x20is\x20a\x20bitwise\x20\"or\"\x20of\x20values\x20from\x20\
1420     the\x20Feature\x20enum.\n\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\x03o\x02\n\
1421     \n\x0c\n\x05\x04\x02\x02\x01\x05\x12\x03o\x0b\x11\n\x0c\n\x05\x04\x02\
1422     \x02\x01\x01\x12\x03o\x12$\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03o'(\n+\
1423     \n\x04\x04\x02\x04\0\x12\x04r\x02u\x03\x1a\x1d\x20Sync\x20with\x20code_g\
1424     enerator.h.\n\n\x0c\n\x05\x04\x02\x04\0\x01\x12\x03r\x07\x0e\n\r\n\x06\
1425     \x04\x02\x04\0\x02\0\x12\x03s\x04\x15\n\x0e\n\x07\x04\x02\x04\0\x02\0\
1426     \x01\x12\x03s\x04\x10\n\x0e\n\x07\x04\x02\x04\0\x02\0\x02\x12\x03s\x13\
1427     \x14\n\r\n\x06\x04\x02\x04\0\x02\x01\x12\x03t\x04\x20\n\x0e\n\x07\x04\
1428     \x02\x04\0\x02\x01\x01\x12\x03t\x04\x1b\n\x0e\n\x07\x04\x02\x04\0\x02\
1429     \x01\x02\x12\x03t\x1e\x1f\n4\n\x04\x04\x02\x03\0\x12\x05x\x02\xb4\x01\
1430     \x03\x1a%\x20Represents\x20a\x20single\x20generated\x20file.\n\n\x0c\n\
1431     \x05\x04\x02\x03\0\x01\x12\x03x\n\x0e\n\xae\x05\n\x06\x04\x02\x03\0\x02\
1432     \0\x12\x04\x84\x01\x04\x1d\x1a\x9d\x05\x20The\x20file\x20name,\x20relati\
1433     ve\x20to\x20the\x20output\x20directory.\x20\x20The\x20name\x20must\x20no\
1434     t\n\x20contain\x20\".\"\x20or\x20\"..\"\x20components\x20and\x20must\x20\
1435     be\x20relative,\x20not\x20be\x20absolute\x20(so,\n\x20the\x20file\x20can\
1436     not\x20lie\x20outside\x20the\x20output\x20directory).\x20\x20\"/\"\x20mu\
1437     st\x20be\x20used\x20as\n\x20the\x20path\x20separator,\x20not\x20\"\\\".\
1438     \n\n\x20If\x20the\x20name\x20is\x20omitted,\x20the\x20content\x20will\
1439     \x20be\x20appended\x20to\x20the\x20previous\n\x20file.\x20\x20This\x20al\
1440     lows\x20the\x20generator\x20to\x20break\x20large\x20files\x20into\x20sma\
1441     ll\x20chunks,\n\x20and\x20allows\x20the\x20generated\x20text\x20to\x20be\
1442     \x20streamed\x20back\x20to\x20protoc\x20so\x20that\x20large\n\x20files\
1443     \x20need\x20not\x20reside\x20completely\x20in\x20memory\x20at\x20one\x20\
1444     time.\x20\x20Note\x20that\x20as\x20of\n\x20this\x20writing\x20protoc\x20\
1445     does\x20not\x20optimize\x20for\x20this\x20--\x20it\x20will\x20read\x20th\
1446     e\x20entire\n\x20CodeGeneratorResponse\x20before\x20writing\x20files\x20\
1447     to\x20disk.\n\n\x0f\n\x07\x04\x02\x03\0\x02\0\x04\x12\x04\x84\x01\x04\
1448     \x0c\n\x0f\n\x07\x04\x02\x03\0\x02\0\x05\x12\x04\x84\x01\r\x13\n\x0f\n\
1449     \x07\x04\x02\x03\0\x02\0\x01\x12\x04\x84\x01\x14\x18\n\x0f\n\x07\x04\x02\
1450     \x03\0\x02\0\x03\x12\x04\x84\x01\x1b\x1c\n\xae\x10\n\x06\x04\x02\x03\0\
1451     \x02\x01\x12\x04\xab\x01\x04(\x1a\x9d\x10\x20If\x20non-empty,\x20indicat\
1452     es\x20that\x20the\x20named\x20file\x20should\x20already\x20exist,\x20and\
1453     \x20the\n\x20content\x20here\x20is\x20to\x20be\x20inserted\x20into\x20th\
1454     at\x20file\x20at\x20a\x20defined\x20insertion\n\x20point.\x20\x20This\
1455     \x20feature\x20allows\x20a\x20code\x20generator\x20to\x20extend\x20the\
1456     \x20output\n\x20produced\x20by\x20another\x20code\x20generator.\x20\x20T\
1457     he\x20original\x20generator\x20may\x20provide\n\x20insertion\x20points\
1458     \x20by\x20placing\x20special\x20annotations\x20in\x20the\x20file\x20that\
1459     \x20look\n\x20like:\n\x20\x20\x20@@protoc_insertion_point(NAME)\n\x20The\
1460     \x20annotation\x20can\x20have\x20arbitrary\x20text\x20before\x20and\x20a\
1461     fter\x20it\x20on\x20the\x20line,\n\x20which\x20allows\x20it\x20to\x20be\
1462     \x20placed\x20in\x20a\x20comment.\x20\x20NAME\x20should\x20be\x20replace\
1463     d\x20with\n\x20an\x20identifier\x20naming\x20the\x20point\x20--\x20this\
1464     \x20is\x20what\x20other\x20generators\x20will\x20use\n\x20as\x20the\x20i\
1465     nsertion_point.\x20\x20Code\x20inserted\x20at\x20this\x20point\x20will\
1466     \x20be\x20placed\n\x20immediately\x20above\x20the\x20line\x20containing\
1467     \x20the\x20insertion\x20point\x20(thus\x20multiple\n\x20insertions\x20to\
1468     \x20the\x20same\x20point\x20will\x20come\x20out\x20in\x20the\x20order\
1469     \x20they\x20were\x20added).\n\x20The\x20double-@\x20is\x20intended\x20to\
1470     \x20make\x20it\x20unlikely\x20that\x20the\x20generated\x20code\n\x20coul\
1471     d\x20contain\x20things\x20that\x20look\x20like\x20insertion\x20points\
1472     \x20by\x20accident.\n\n\x20For\x20example,\x20the\x20C++\x20code\x20gene\
1473     rator\x20places\x20the\x20following\x20line\x20in\x20the\n\x20.pb.h\x20f\
1474     iles\x20that\x20it\x20generates:\n\x20\x20\x20//\x20@@protoc_insertion_p\
1475     oint(namespace_scope)\n\x20This\x20line\x20appears\x20within\x20the\x20s\
1476     cope\x20of\x20the\x20file's\x20package\x20namespace,\x20but\n\x20outside\
1477     \x20of\x20any\x20particular\x20class.\x20\x20Another\x20plugin\x20can\
1478     \x20then\x20specify\x20the\n\x20insertion_point\x20\"namespace_scope\"\
1479     \x20to\x20generate\x20additional\x20classes\x20or\n\x20other\x20declarat\
1480     ions\x20that\x20should\x20be\x20placed\x20in\x20this\x20scope.\n\n\x20No\
1481     te\x20that\x20if\x20the\x20line\x20containing\x20the\x20insertion\x20poi\
1482     nt\x20begins\x20with\n\x20whitespace,\x20the\x20same\x20whitespace\x20wi\
1483     ll\x20be\x20added\x20to\x20every\x20line\x20of\x20the\n\x20inserted\x20t\
1484     ext.\x20\x20This\x20is\x20useful\x20for\x20languages\x20like\x20Python,\
1485     \x20where\n\x20indentation\x20matters.\x20\x20In\x20these\x20languages,\
1486     \x20the\x20insertion\x20point\x20comment\n\x20should\x20be\x20indented\
1487     \x20the\x20same\x20amount\x20as\x20any\x20inserted\x20code\x20will\x20ne\
1488     ed\x20to\x20be\n\x20in\x20order\x20to\x20work\x20correctly\x20in\x20that\
1489     \x20context.\n\n\x20The\x20code\x20generator\x20that\x20generates\x20the\
1490     \x20initial\x20file\x20and\x20the\x20one\x20which\n\x20inserts\x20into\
1491     \x20it\x20must\x20both\x20run\x20as\x20part\x20of\x20a\x20single\x20invo\
1492     cation\x20of\x20protoc.\n\x20Code\x20generators\x20are\x20executed\x20in\
1493     \x20the\x20order\x20in\x20which\x20they\x20appear\x20on\x20the\n\x20comm\
1494     and\x20line.\n\n\x20If\x20|insertion_point|\x20is\x20present,\x20|name|\
1495     \x20must\x20also\x20be\x20present.\n\n\x0f\n\x07\x04\x02\x03\0\x02\x01\
1496     \x04\x12\x04\xab\x01\x04\x0c\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x05\x12\
1497     \x04\xab\x01\r\x13\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x01\x12\x04\xab\x01\
1498     \x14#\n\x0f\n\x07\x04\x02\x03\0\x02\x01\x03\x12\x04\xab\x01&'\n$\n\x06\
1499     \x04\x02\x03\0\x02\x02\x12\x04\xae\x01\x04!\x1a\x14\x20The\x20file\x20co\
1500     ntents.\n\n\x0f\n\x07\x04\x02\x03\0\x02\x02\x04\x12\x04\xae\x01\x04\x0c\
1501     \n\x0f\n\x07\x04\x02\x03\0\x02\x02\x05\x12\x04\xae\x01\r\x13\n\x0f\n\x07\
1502     \x04\x02\x03\0\x02\x02\x01\x12\x04\xae\x01\x14\x1b\n\x0f\n\x07\x04\x02\
1503     \x03\0\x02\x02\x03\x12\x04\xae\x01\x1e\x20\n\xe1\x01\n\x06\x04\x02\x03\0\
1504     \x02\x03\x12\x04\xb3\x01\x048\x1a\xd0\x01\x20Information\x20describing\
1505     \x20the\x20file\x20content\x20being\x20inserted.\x20If\x20an\x20insertio\
1506     n\n\x20point\x20is\x20used,\x20this\x20information\x20will\x20be\x20appr\
1507     opriately\x20offset\x20and\x20inserted\n\x20into\x20the\x20code\x20gener\
1508     ation\x20metadata\x20for\x20the\x20generated\x20files.\n\n\x0f\n\x07\x04\
1509     \x02\x03\0\x02\x03\x04\x12\x04\xb3\x01\x04\x0c\n\x0f\n\x07\x04\x02\x03\0\
1510     \x02\x03\x06\x12\x04\xb3\x01\r\x1e\n\x0f\n\x07\x04\x02\x03\0\x02\x03\x01\
1511     \x12\x04\xb3\x01\x1f2\n\x0f\n\x07\x04\x02\x03\0\x02\x03\x03\x12\x04\xb3\
1512     \x0157\n\x0c\n\x04\x04\x02\x02\x02\x12\x04\xb5\x01\x02\x1a\n\r\n\x05\x04\
1513     \x02\x02\x02\x04\x12\x04\xb5\x01\x02\n\n\r\n\x05\x04\x02\x02\x02\x06\x12\
1514     \x04\xb5\x01\x0b\x0f\n\r\n\x05\x04\x02\x02\x02\x01\x12\x04\xb5\x01\x10\
1515     \x14\n\r\n\x05\x04\x02\x02\x02\x03\x12\x04\xb5\x01\x17\x19\
1516 ";
1517 
1518 static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
1519 
parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto1520 fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
1521     crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
1522 }
1523 
file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto1524 pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
1525     file_descriptor_proto_lazy.get(|| {
1526         parse_descriptor_proto()
1527     })
1528 }
1529