puroro_protobuf_compiled/google/protobuf/
compiler.rs

1mod _root {
2    #[allow(unused)]
3    pub(crate) use super::super::_root::*;
4}
5mod _puroro {
6    #[allow(unused)]
7    pub(crate) use super::_root::_puroro::*;
8}
9mod _pinternal {
10    #[allow(unused)]
11    pub(crate) use super::_root::_pinternal::*;
12}
13pub mod code_generator_response;
14#[derive(::std::default::Default)]
15/** The version number of protocol compiler.
16*/
17pub struct Version {
18    fields: self::_root::google::protobuf::compiler::_fields::VersionFields<
19        self::_pinternal::OptionalNumericalField::<
20            i32,
21            self::_pinternal::tags::Int32,
22            0usize,
23        >,
24        self::_pinternal::OptionalNumericalField::<
25            i32,
26            self::_pinternal::tags::Int32,
27            1usize,
28        >,
29        self::_pinternal::OptionalNumericalField::<
30            i32,
31            self::_pinternal::tags::Int32,
32            2usize,
33        >,
34        self::_pinternal::OptionalUnsizedField::<
35            ::std::string::String,
36            self::_pinternal::tags::String,
37            3usize,
38        >,
39    >,
40    shared: self::_pinternal::SharedItemsImpl<1usize>,
41}
42impl Version {
43    pub fn major(&self) -> i32 {
44        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
45        NonRepeatedFieldType::get_field_or_else(
46            &self.fields.major,
47            self.shared.bitfield(),
48            ::std::default::Default::default,
49        )
50    }
51    pub fn major_opt(&self) -> ::std::option::Option::<i32> {
52        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
53        NonRepeatedFieldType::get_field_opt(&self.fields.major, self.shared.bitfield())
54    }
55    pub fn major_mut(&mut self) -> &mut i32 {
56        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
57        NonRepeatedFieldType::get_field_mut(
58            &mut self.fields.major,
59            self.shared.bitfield_mut(),
60            ::std::default::Default::default,
61        )
62    }
63    pub fn has_major(&self) -> bool {
64        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
65        NonRepeatedFieldType::get_field_opt(&self.fields.major, self.shared.bitfield())
66            .is_some()
67    }
68    pub fn clear_major(&mut self) {
69        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
70        NonRepeatedFieldType::clear(&mut self.fields.major, self.shared.bitfield_mut())
71    }
72    pub fn minor(&self) -> i32 {
73        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
74        NonRepeatedFieldType::get_field_or_else(
75            &self.fields.minor,
76            self.shared.bitfield(),
77            ::std::default::Default::default,
78        )
79    }
80    pub fn minor_opt(&self) -> ::std::option::Option::<i32> {
81        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
82        NonRepeatedFieldType::get_field_opt(&self.fields.minor, self.shared.bitfield())
83    }
84    pub fn minor_mut(&mut self) -> &mut i32 {
85        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
86        NonRepeatedFieldType::get_field_mut(
87            &mut self.fields.minor,
88            self.shared.bitfield_mut(),
89            ::std::default::Default::default,
90        )
91    }
92    pub fn has_minor(&self) -> bool {
93        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
94        NonRepeatedFieldType::get_field_opt(&self.fields.minor, self.shared.bitfield())
95            .is_some()
96    }
97    pub fn clear_minor(&mut self) {
98        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
99        NonRepeatedFieldType::clear(&mut self.fields.minor, self.shared.bitfield_mut())
100    }
101    pub fn patch(&self) -> i32 {
102        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
103        NonRepeatedFieldType::get_field_or_else(
104            &self.fields.patch,
105            self.shared.bitfield(),
106            ::std::default::Default::default,
107        )
108    }
109    pub fn patch_opt(&self) -> ::std::option::Option::<i32> {
110        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
111        NonRepeatedFieldType::get_field_opt(&self.fields.patch, self.shared.bitfield())
112    }
113    pub fn patch_mut(&mut self) -> &mut i32 {
114        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
115        NonRepeatedFieldType::get_field_mut(
116            &mut self.fields.patch,
117            self.shared.bitfield_mut(),
118            ::std::default::Default::default,
119        )
120    }
121    pub fn has_patch(&self) -> bool {
122        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
123        NonRepeatedFieldType::get_field_opt(&self.fields.patch, self.shared.bitfield())
124            .is_some()
125    }
126    pub fn clear_patch(&mut self) {
127        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
128        NonRepeatedFieldType::clear(&mut self.fields.patch, self.shared.bitfield_mut())
129    }
130    pub fn suffix(&self) -> &str {
131        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
132        NonRepeatedFieldType::get_field_or_else(
133            &self.fields.suffix,
134            self.shared.bitfield(),
135            ::std::default::Default::default,
136        )
137    }
138    /** A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
139 be empty for mainline stable releases.
140*/
141    pub fn suffix_opt(&self) -> ::std::option::Option::<&str> {
142        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
143        NonRepeatedFieldType::get_field_opt(&self.fields.suffix, self.shared.bitfield())
144    }
145    pub fn suffix_mut(&mut self) -> &mut ::std::string::String {
146        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
147        NonRepeatedFieldType::get_field_mut(
148            &mut self.fields.suffix,
149            self.shared.bitfield_mut(),
150            ::std::default::Default::default,
151        )
152    }
153    pub fn has_suffix(&self) -> bool {
154        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
155        NonRepeatedFieldType::get_field_opt(&self.fields.suffix, self.shared.bitfield())
156            .is_some()
157    }
158    pub fn clear_suffix(&mut self) {
159        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
160        NonRepeatedFieldType::clear(&mut self.fields.suffix, self.shared.bitfield_mut())
161    }
162}
163impl self::_puroro::Message for Version {
164    fn from_bytes_iter<I: ::std::iter::Iterator<Item = ::std::io::Result<u8>>>(
165        iter: I,
166    ) -> self::_puroro::Result<Self> {
167        let mut msg = <Self as ::std::default::Default>::default();
168        msg.merge_from_bytes_iter(iter)?;
169        ::std::result::Result::Ok(msg)
170    }
171    fn merge_from_bytes_iter<I: ::std::iter::Iterator<Item = ::std::io::Result<u8>>>(
172        &mut self,
173        mut iter: I,
174    ) -> self::_puroro::Result<()> {
175        use self::_pinternal::ser::FieldData;
176        #[allow(unused)]
177        use self::_pinternal::OneofUnion as _;
178        use self::_pinternal::{SharedItems as _, UnknownFields as _};
179        #[allow(unused)]
180        use ::std::result::Result;
181        #[allow(unused)]
182        use ::std::result::Result::{Ok, Err};
183        #[allow(unused)]
184        use ::std::vec::Vec;
185        use self::_puroro::PuroroError;
186        while let Some((number, field_data))
187            = FieldData::from_bytes_iter(iter.by_ref())? {
188            let result: self::_puroro::Result<()> = (|| {
189                match number {
190                    1i32 => {
191                        self::_pinternal::FieldType::deser_from_iter(
192                            &mut self.fields.major,
193                            self.shared.bitfield_mut(),
194                            field_data,
195                        )?
196                    }
197                    2i32 => {
198                        self::_pinternal::FieldType::deser_from_iter(
199                            &mut self.fields.minor,
200                            self.shared.bitfield_mut(),
201                            field_data,
202                        )?
203                    }
204                    3i32 => {
205                        self::_pinternal::FieldType::deser_from_iter(
206                            &mut self.fields.patch,
207                            self.shared.bitfield_mut(),
208                            field_data,
209                        )?
210                    }
211                    4i32 => {
212                        self::_pinternal::FieldType::deser_from_iter(
213                            &mut self.fields.suffix,
214                            self.shared.bitfield_mut(),
215                            field_data,
216                        )?
217                    }
218                    _ => {
219                        let field_data = field_data
220                            .map(|iter| { iter.collect::<Result<Vec<_>, _>>() })
221                            .transpose()?;
222                        Err(PuroroError::UnknownFieldNumber(field_data))?
223                    }
224                }
225                Ok(())
226            })();
227            match result {
228                Ok(_) => {}
229                Err(PuroroError::UnknownFieldNumber(field_data)) => {
230                    self.shared.unknown_fields_mut().push(number, field_data)?;
231                }
232                Err(e) => Err(e)?,
233            }
234        }
235        Ok(())
236    }
237    fn to_bytes<W: ::std::io::Write>(
238        &self,
239        #[allow(unused)]
240        out: &mut W,
241    ) -> self::_puroro::Result<()> {
242        #[allow(unused)]
243        use self::_pinternal::OneofUnion as _;
244        use self::_pinternal::{SharedItems as _, UnknownFields as _};
245        self::_pinternal::FieldType::ser_to_write(
246            &self.fields.major,
247            self.shared.bitfield(),
248            1i32,
249            out,
250        )?;
251        self::_pinternal::FieldType::ser_to_write(
252            &self.fields.minor,
253            self.shared.bitfield(),
254            2i32,
255            out,
256        )?;
257        self::_pinternal::FieldType::ser_to_write(
258            &self.fields.patch,
259            self.shared.bitfield(),
260            3i32,
261            out,
262        )?;
263        self::_pinternal::FieldType::ser_to_write(
264            &self.fields.suffix,
265            self.shared.bitfield(),
266            4i32,
267            out,
268        )?;
269        self.shared.unknown_fields().ser_to_write(out)?;
270        ::std::result::Result::Ok(())
271    }
272}
273impl ::std::clone::Clone for Version {
274    fn clone(&self) -> Self {
275        #[allow(unused)]
276        use self::_pinternal::SharedItems as _;
277        Self {
278            fields: self::_fields::VersionFields {
279                major: ::std::clone::Clone::clone(&self.fields.major),
280                minor: ::std::clone::Clone::clone(&self.fields.minor),
281                patch: ::std::clone::Clone::clone(&self.fields.patch),
282                suffix: ::std::clone::Clone::clone(&self.fields.suffix),
283            },
284            shared: ::std::clone::Clone::clone(&self.shared),
285        }
286    }
287}
288impl ::std::ops::Drop for Version {
289    fn drop(&mut self) {
290        #[allow(unused)]
291        use self::_pinternal::{OneofUnion as _, SharedItems as _};
292    }
293}
294impl ::std::fmt::Debug for Version {
295    fn fmt(
296        &self,
297        fmt: &mut ::std::fmt::Formatter<'_>,
298    ) -> ::std::result::Result<(), ::std::fmt::Error> {
299        use self::_pinternal::{SharedItems as _, UnknownFields as _};
300        let mut debug_struct = fmt.debug_struct(stringify!(Version));
301        debug_struct
302            .field(stringify!(major), &self.major_opt())
303            .field(stringify!(minor), &self.minor_opt())
304            .field(stringify!(patch), &self.patch_opt())
305            .field(stringify!(suffix), &self.suffix_opt());
306        self.shared.unknown_fields().debug_struct_fields(&mut debug_struct)?;
307        debug_struct.finish()
308    }
309}
310impl ::std::cmp::PartialEq for Version {
311    fn eq(&self, rhs: &Self) -> bool {
312        #[allow(unused)]
313        use self::_pinternal::OneofUnion as _;
314        use self::_pinternal::SharedItems as _;
315        true && self.major_opt() == rhs.major_opt()
316            && self.minor_opt() == rhs.minor_opt() && self.patch_opt() == rhs.patch_opt()
317            && self.suffix_opt() == rhs.suffix_opt()
318            && self.shared.unknown_fields() == rhs.shared.unknown_fields()
319    }
320}
321#[derive(::std::default::Default)]
322/** An encoded CodeGeneratorRequest is written to the plugin's stdin.
323*/
324pub struct CodeGeneratorRequest {
325    fields: self::_root::google::protobuf::compiler::_fields::CodeGeneratorRequestFields<
326        self::_pinternal::RepeatedUnsizedField::<
327            ::std::string::String,
328            self::_pinternal::tags::String,
329        >,
330        self::_pinternal::OptionalUnsizedField::<
331            ::std::string::String,
332            self::_pinternal::tags::String,
333            0usize,
334        >,
335        self::_pinternal::RepeatedMessageField::<
336            self::_root::google::protobuf::FileDescriptorProto,
337        >,
338        self::_pinternal::SingularHeapMessageField::<
339            self::_root::google::protobuf::compiler::Version,
340        >,
341    >,
342    shared: self::_pinternal::SharedItemsImpl<1usize>,
343}
344impl CodeGeneratorRequest {
345    /** The .proto files that were explicitly listed on the command-line.  The
346 code generator should generate code only for these files.  Each file's
347 descriptor will be included in proto_file, below.
348*/
349    pub fn file_to_generate(
350        &self,
351    ) -> &[impl ::std::ops::Deref::<
352        Target = str,
353    > + ::std::fmt::Debug + ::std::cmp::PartialEq] {
354        use self::_pinternal::{RepeatedFieldType, SharedItems as _};
355        RepeatedFieldType::get_field(
356            &self.fields.file_to_generate,
357            self.shared.bitfield(),
358        )
359    }
360    pub fn file_to_generate_mut(
361        &mut self,
362    ) -> &mut ::std::vec::Vec::<::std::string::String> {
363        use self::_pinternal::{RepeatedFieldType, SharedItems as _};
364        RepeatedFieldType::get_field_mut(
365            &mut self.fields.file_to_generate,
366            self.shared.bitfield_mut(),
367        )
368    }
369    pub fn clear_file_to_generate(&mut self) {
370        use self::_pinternal::{RepeatedFieldType, SharedItems as _};
371        RepeatedFieldType::clear(
372            &mut self.fields.file_to_generate,
373            self.shared.bitfield_mut(),
374        )
375    }
376    pub fn parameter(&self) -> &str {
377        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
378        NonRepeatedFieldType::get_field_or_else(
379            &self.fields.parameter,
380            self.shared.bitfield(),
381            ::std::default::Default::default,
382        )
383    }
384    /** The generator parameter passed on the command-line.
385*/
386    pub fn parameter_opt(&self) -> ::std::option::Option::<&str> {
387        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
388        NonRepeatedFieldType::get_field_opt(
389            &self.fields.parameter,
390            self.shared.bitfield(),
391        )
392    }
393    pub fn parameter_mut(&mut self) -> &mut ::std::string::String {
394        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
395        NonRepeatedFieldType::get_field_mut(
396            &mut self.fields.parameter,
397            self.shared.bitfield_mut(),
398            ::std::default::Default::default,
399        )
400    }
401    pub fn has_parameter(&self) -> bool {
402        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
403        NonRepeatedFieldType::get_field_opt(
404                &self.fields.parameter,
405                self.shared.bitfield(),
406            )
407            .is_some()
408    }
409    pub fn clear_parameter(&mut self) {
410        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
411        NonRepeatedFieldType::clear(
412            &mut self.fields.parameter,
413            self.shared.bitfield_mut(),
414        )
415    }
416    /** FileDescriptorProtos for all files in files_to_generate and everything
417 they import.  The files will appear in topological order, so each file
418 appears before any file that imports it.
419
420 protoc guarantees that all proto_files will be written after
421 the fields above, even though this is not technically guaranteed by the
422 protobuf wire format.  This theoretically could allow a plugin to stream
423 in the FileDescriptorProtos and handle them one by one rather than read
424 the entire set into memory at once.  However, as of this writing, this
425 is not similarly optimized on protoc's end -- it will store all fields in
426 memory at once before sending them to the plugin.
427
428 Type names of fields and extensions in the FileDescriptorProto are always
429 fully qualified.
430*/
431    pub fn proto_file(&self) -> &[self::_root::google::protobuf::FileDescriptorProto] {
432        use self::_pinternal::{RepeatedFieldType, SharedItems as _};
433        RepeatedFieldType::get_field(&self.fields.proto_file, self.shared.bitfield())
434    }
435    pub fn proto_file_mut(
436        &mut self,
437    ) -> &mut ::std::vec::Vec::<self::_root::google::protobuf::FileDescriptorProto> {
438        use self::_pinternal::{RepeatedFieldType, SharedItems as _};
439        RepeatedFieldType::get_field_mut(
440            &mut self.fields.proto_file,
441            self.shared.bitfield_mut(),
442        )
443    }
444    pub fn clear_proto_file(&mut self) {
445        use self::_pinternal::{RepeatedFieldType, SharedItems as _};
446        RepeatedFieldType::clear(&mut self.fields.proto_file, self.shared.bitfield_mut())
447    }
448    pub fn compiler_version(
449        &self,
450    ) -> ::std::option::Option::<&self::_root::google::protobuf::compiler::Version> {
451        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
452        NonRepeatedFieldType::get_field_or_else(
453            &self.fields.compiler_version,
454            self.shared.bitfield(),
455            ::std::default::Default::default,
456        )
457    }
458    /** The version number of protocol compiler.
459*/
460    pub fn compiler_version_opt(
461        &self,
462    ) -> ::std::option::Option::<&self::_root::google::protobuf::compiler::Version> {
463        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
464        NonRepeatedFieldType::get_field_opt(
465            &self.fields.compiler_version,
466            self.shared.bitfield(),
467        )
468    }
469    pub fn compiler_version_mut(
470        &mut self,
471    ) -> &mut self::_root::google::protobuf::compiler::Version {
472        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
473        NonRepeatedFieldType::get_field_mut(
474            &mut self.fields.compiler_version,
475            self.shared.bitfield_mut(),
476            ::std::default::Default::default,
477        )
478    }
479    pub fn has_compiler_version(&self) -> bool {
480        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
481        NonRepeatedFieldType::get_field_opt(
482                &self.fields.compiler_version,
483                self.shared.bitfield(),
484            )
485            .is_some()
486    }
487    pub fn clear_compiler_version(&mut self) {
488        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
489        NonRepeatedFieldType::clear(
490            &mut self.fields.compiler_version,
491            self.shared.bitfield_mut(),
492        )
493    }
494}
495impl self::_puroro::Message for CodeGeneratorRequest {
496    fn from_bytes_iter<I: ::std::iter::Iterator<Item = ::std::io::Result<u8>>>(
497        iter: I,
498    ) -> self::_puroro::Result<Self> {
499        let mut msg = <Self as ::std::default::Default>::default();
500        msg.merge_from_bytes_iter(iter)?;
501        ::std::result::Result::Ok(msg)
502    }
503    fn merge_from_bytes_iter<I: ::std::iter::Iterator<Item = ::std::io::Result<u8>>>(
504        &mut self,
505        mut iter: I,
506    ) -> self::_puroro::Result<()> {
507        use self::_pinternal::ser::FieldData;
508        #[allow(unused)]
509        use self::_pinternal::OneofUnion as _;
510        use self::_pinternal::{SharedItems as _, UnknownFields as _};
511        #[allow(unused)]
512        use ::std::result::Result;
513        #[allow(unused)]
514        use ::std::result::Result::{Ok, Err};
515        #[allow(unused)]
516        use ::std::vec::Vec;
517        use self::_puroro::PuroroError;
518        while let Some((number, field_data))
519            = FieldData::from_bytes_iter(iter.by_ref())? {
520            let result: self::_puroro::Result<()> = (|| {
521                match number {
522                    1i32 => {
523                        self::_pinternal::FieldType::deser_from_iter(
524                            &mut self.fields.file_to_generate,
525                            self.shared.bitfield_mut(),
526                            field_data,
527                        )?
528                    }
529                    2i32 => {
530                        self::_pinternal::FieldType::deser_from_iter(
531                            &mut self.fields.parameter,
532                            self.shared.bitfield_mut(),
533                            field_data,
534                        )?
535                    }
536                    15i32 => {
537                        self::_pinternal::FieldType::deser_from_iter(
538                            &mut self.fields.proto_file,
539                            self.shared.bitfield_mut(),
540                            field_data,
541                        )?
542                    }
543                    3i32 => {
544                        self::_pinternal::FieldType::deser_from_iter(
545                            &mut self.fields.compiler_version,
546                            self.shared.bitfield_mut(),
547                            field_data,
548                        )?
549                    }
550                    _ => {
551                        let field_data = field_data
552                            .map(|iter| { iter.collect::<Result<Vec<_>, _>>() })
553                            .transpose()?;
554                        Err(PuroroError::UnknownFieldNumber(field_data))?
555                    }
556                }
557                Ok(())
558            })();
559            match result {
560                Ok(_) => {}
561                Err(PuroroError::UnknownFieldNumber(field_data)) => {
562                    self.shared.unknown_fields_mut().push(number, field_data)?;
563                }
564                Err(e) => Err(e)?,
565            }
566        }
567        Ok(())
568    }
569    fn to_bytes<W: ::std::io::Write>(
570        &self,
571        #[allow(unused)]
572        out: &mut W,
573    ) -> self::_puroro::Result<()> {
574        #[allow(unused)]
575        use self::_pinternal::OneofUnion as _;
576        use self::_pinternal::{SharedItems as _, UnknownFields as _};
577        self::_pinternal::FieldType::ser_to_write(
578            &self.fields.file_to_generate,
579            self.shared.bitfield(),
580            1i32,
581            out,
582        )?;
583        self::_pinternal::FieldType::ser_to_write(
584            &self.fields.parameter,
585            self.shared.bitfield(),
586            2i32,
587            out,
588        )?;
589        self::_pinternal::FieldType::ser_to_write(
590            &self.fields.proto_file,
591            self.shared.bitfield(),
592            15i32,
593            out,
594        )?;
595        self::_pinternal::FieldType::ser_to_write(
596            &self.fields.compiler_version,
597            self.shared.bitfield(),
598            3i32,
599            out,
600        )?;
601        self.shared.unknown_fields().ser_to_write(out)?;
602        ::std::result::Result::Ok(())
603    }
604}
605impl ::std::clone::Clone for CodeGeneratorRequest {
606    fn clone(&self) -> Self {
607        #[allow(unused)]
608        use self::_pinternal::SharedItems as _;
609        Self {
610            fields: self::_fields::CodeGeneratorRequestFields {
611                file_to_generate: ::std::clone::Clone::clone(
612                    &self.fields.file_to_generate,
613                ),
614                parameter: ::std::clone::Clone::clone(&self.fields.parameter),
615                proto_file: ::std::clone::Clone::clone(&self.fields.proto_file),
616                compiler_version: ::std::clone::Clone::clone(
617                    &self.fields.compiler_version,
618                ),
619            },
620            shared: ::std::clone::Clone::clone(&self.shared),
621        }
622    }
623}
624impl ::std::ops::Drop for CodeGeneratorRequest {
625    fn drop(&mut self) {
626        #[allow(unused)]
627        use self::_pinternal::{OneofUnion as _, SharedItems as _};
628    }
629}
630impl ::std::fmt::Debug for CodeGeneratorRequest {
631    fn fmt(
632        &self,
633        fmt: &mut ::std::fmt::Formatter<'_>,
634    ) -> ::std::result::Result<(), ::std::fmt::Error> {
635        use self::_pinternal::{SharedItems as _, UnknownFields as _};
636        let mut debug_struct = fmt.debug_struct(stringify!(CodeGeneratorRequest));
637        debug_struct
638            .field(stringify!(file_to_generate), &self.file_to_generate())
639            .field(stringify!(parameter), &self.parameter_opt())
640            .field(stringify!(proto_file), &self.proto_file())
641            .field(stringify!(compiler_version), &self.compiler_version_opt());
642        self.shared.unknown_fields().debug_struct_fields(&mut debug_struct)?;
643        debug_struct.finish()
644    }
645}
646impl ::std::cmp::PartialEq for CodeGeneratorRequest {
647    fn eq(&self, rhs: &Self) -> bool {
648        #[allow(unused)]
649        use self::_pinternal::OneofUnion as _;
650        use self::_pinternal::SharedItems as _;
651        true && self.file_to_generate() == rhs.file_to_generate()
652            && self.parameter_opt() == rhs.parameter_opt()
653            && self.proto_file() == rhs.proto_file()
654            && self.compiler_version_opt() == rhs.compiler_version_opt()
655            && self.shared.unknown_fields() == rhs.shared.unknown_fields()
656    }
657}
658#[derive(::std::default::Default)]
659/** The plugin writes an encoded CodeGeneratorResponse to stdout.
660*/
661pub struct CodeGeneratorResponse {
662    fields: self::_root::google::protobuf::compiler::_fields::CodeGeneratorResponseFields<
663        self::_pinternal::OptionalUnsizedField::<
664            ::std::string::String,
665            self::_pinternal::tags::String,
666            0usize,
667        >,
668        self::_pinternal::OptionalNumericalField::<
669            u64,
670            self::_pinternal::tags::UInt64,
671            1usize,
672        >,
673        self::_pinternal::RepeatedMessageField::<
674            self::_root::google::protobuf::compiler::code_generator_response::File,
675        >,
676    >,
677    shared: self::_pinternal::SharedItemsImpl<1usize>,
678}
679impl CodeGeneratorResponse {
680    pub fn error(&self) -> &str {
681        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
682        NonRepeatedFieldType::get_field_or_else(
683            &self.fields.error,
684            self.shared.bitfield(),
685            ::std::default::Default::default,
686        )
687    }
688    /** Error message.  If non-empty, code generation failed.  The plugin process
689 should exit with status code zero even if it reports an error in this way.
690
691 This should be used to indicate errors in .proto files which prevent the
692 code generator from generating correct code.  Errors which indicate a
693 problem in protoc itself -- such as the input CodeGeneratorRequest being
694 unparseable -- should be reported by writing a message to stderr and
695 exiting with a non-zero status code.
696*/
697    pub fn error_opt(&self) -> ::std::option::Option::<&str> {
698        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
699        NonRepeatedFieldType::get_field_opt(&self.fields.error, self.shared.bitfield())
700    }
701    pub fn error_mut(&mut self) -> &mut ::std::string::String {
702        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
703        NonRepeatedFieldType::get_field_mut(
704            &mut self.fields.error,
705            self.shared.bitfield_mut(),
706            ::std::default::Default::default,
707        )
708    }
709    pub fn has_error(&self) -> bool {
710        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
711        NonRepeatedFieldType::get_field_opt(&self.fields.error, self.shared.bitfield())
712            .is_some()
713    }
714    pub fn clear_error(&mut self) {
715        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
716        NonRepeatedFieldType::clear(&mut self.fields.error, self.shared.bitfield_mut())
717    }
718    pub fn supported_features(&self) -> u64 {
719        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
720        NonRepeatedFieldType::get_field_or_else(
721            &self.fields.supported_features,
722            self.shared.bitfield(),
723            ::std::default::Default::default,
724        )
725    }
726    /** A bitmask of supported features that the code generator supports.
727 This is a bitwise "or" of values from the Feature enum.
728*/
729    pub fn supported_features_opt(&self) -> ::std::option::Option::<u64> {
730        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
731        NonRepeatedFieldType::get_field_opt(
732            &self.fields.supported_features,
733            self.shared.bitfield(),
734        )
735    }
736    pub fn supported_features_mut(&mut self) -> &mut u64 {
737        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
738        NonRepeatedFieldType::get_field_mut(
739            &mut self.fields.supported_features,
740            self.shared.bitfield_mut(),
741            ::std::default::Default::default,
742        )
743    }
744    pub fn has_supported_features(&self) -> bool {
745        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
746        NonRepeatedFieldType::get_field_opt(
747                &self.fields.supported_features,
748                self.shared.bitfield(),
749            )
750            .is_some()
751    }
752    pub fn clear_supported_features(&mut self) {
753        use self::_pinternal::{NonRepeatedFieldType, SharedItems as _};
754        NonRepeatedFieldType::clear(
755            &mut self.fields.supported_features,
756            self.shared.bitfield_mut(),
757        )
758    }
759    pub fn file(
760        &self,
761    ) -> &[self::_root::google::protobuf::compiler::code_generator_response::File] {
762        use self::_pinternal::{RepeatedFieldType, SharedItems as _};
763        RepeatedFieldType::get_field(&self.fields.file, self.shared.bitfield())
764    }
765    pub fn file_mut(
766        &mut self,
767    ) -> &mut ::std::vec::Vec::<
768        self::_root::google::protobuf::compiler::code_generator_response::File,
769    > {
770        use self::_pinternal::{RepeatedFieldType, SharedItems as _};
771        RepeatedFieldType::get_field_mut(
772            &mut self.fields.file,
773            self.shared.bitfield_mut(),
774        )
775    }
776    pub fn clear_file(&mut self) {
777        use self::_pinternal::{RepeatedFieldType, SharedItems as _};
778        RepeatedFieldType::clear(&mut self.fields.file, self.shared.bitfield_mut())
779    }
780}
781impl self::_puroro::Message for CodeGeneratorResponse {
782    fn from_bytes_iter<I: ::std::iter::Iterator<Item = ::std::io::Result<u8>>>(
783        iter: I,
784    ) -> self::_puroro::Result<Self> {
785        let mut msg = <Self as ::std::default::Default>::default();
786        msg.merge_from_bytes_iter(iter)?;
787        ::std::result::Result::Ok(msg)
788    }
789    fn merge_from_bytes_iter<I: ::std::iter::Iterator<Item = ::std::io::Result<u8>>>(
790        &mut self,
791        mut iter: I,
792    ) -> self::_puroro::Result<()> {
793        use self::_pinternal::ser::FieldData;
794        #[allow(unused)]
795        use self::_pinternal::OneofUnion as _;
796        use self::_pinternal::{SharedItems as _, UnknownFields as _};
797        #[allow(unused)]
798        use ::std::result::Result;
799        #[allow(unused)]
800        use ::std::result::Result::{Ok, Err};
801        #[allow(unused)]
802        use ::std::vec::Vec;
803        use self::_puroro::PuroroError;
804        while let Some((number, field_data))
805            = FieldData::from_bytes_iter(iter.by_ref())? {
806            let result: self::_puroro::Result<()> = (|| {
807                match number {
808                    1i32 => {
809                        self::_pinternal::FieldType::deser_from_iter(
810                            &mut self.fields.error,
811                            self.shared.bitfield_mut(),
812                            field_data,
813                        )?
814                    }
815                    2i32 => {
816                        self::_pinternal::FieldType::deser_from_iter(
817                            &mut self.fields.supported_features,
818                            self.shared.bitfield_mut(),
819                            field_data,
820                        )?
821                    }
822                    15i32 => {
823                        self::_pinternal::FieldType::deser_from_iter(
824                            &mut self.fields.file,
825                            self.shared.bitfield_mut(),
826                            field_data,
827                        )?
828                    }
829                    _ => {
830                        let field_data = field_data
831                            .map(|iter| { iter.collect::<Result<Vec<_>, _>>() })
832                            .transpose()?;
833                        Err(PuroroError::UnknownFieldNumber(field_data))?
834                    }
835                }
836                Ok(())
837            })();
838            match result {
839                Ok(_) => {}
840                Err(PuroroError::UnknownFieldNumber(field_data)) => {
841                    self.shared.unknown_fields_mut().push(number, field_data)?;
842                }
843                Err(e) => Err(e)?,
844            }
845        }
846        Ok(())
847    }
848    fn to_bytes<W: ::std::io::Write>(
849        &self,
850        #[allow(unused)]
851        out: &mut W,
852    ) -> self::_puroro::Result<()> {
853        #[allow(unused)]
854        use self::_pinternal::OneofUnion as _;
855        use self::_pinternal::{SharedItems as _, UnknownFields as _};
856        self::_pinternal::FieldType::ser_to_write(
857            &self.fields.error,
858            self.shared.bitfield(),
859            1i32,
860            out,
861        )?;
862        self::_pinternal::FieldType::ser_to_write(
863            &self.fields.supported_features,
864            self.shared.bitfield(),
865            2i32,
866            out,
867        )?;
868        self::_pinternal::FieldType::ser_to_write(
869            &self.fields.file,
870            self.shared.bitfield(),
871            15i32,
872            out,
873        )?;
874        self.shared.unknown_fields().ser_to_write(out)?;
875        ::std::result::Result::Ok(())
876    }
877}
878impl ::std::clone::Clone for CodeGeneratorResponse {
879    fn clone(&self) -> Self {
880        #[allow(unused)]
881        use self::_pinternal::SharedItems as _;
882        Self {
883            fields: self::_fields::CodeGeneratorResponseFields {
884                error: ::std::clone::Clone::clone(&self.fields.error),
885                supported_features: ::std::clone::Clone::clone(
886                    &self.fields.supported_features,
887                ),
888                file: ::std::clone::Clone::clone(&self.fields.file),
889            },
890            shared: ::std::clone::Clone::clone(&self.shared),
891        }
892    }
893}
894impl ::std::ops::Drop for CodeGeneratorResponse {
895    fn drop(&mut self) {
896        #[allow(unused)]
897        use self::_pinternal::{OneofUnion as _, SharedItems as _};
898    }
899}
900impl ::std::fmt::Debug for CodeGeneratorResponse {
901    fn fmt(
902        &self,
903        fmt: &mut ::std::fmt::Formatter<'_>,
904    ) -> ::std::result::Result<(), ::std::fmt::Error> {
905        use self::_pinternal::{SharedItems as _, UnknownFields as _};
906        let mut debug_struct = fmt.debug_struct(stringify!(CodeGeneratorResponse));
907        debug_struct
908            .field(stringify!(error), &self.error_opt())
909            .field(stringify!(supported_features), &self.supported_features_opt())
910            .field(stringify!(file), &self.file());
911        self.shared.unknown_fields().debug_struct_fields(&mut debug_struct)?;
912        debug_struct.finish()
913    }
914}
915impl ::std::cmp::PartialEq for CodeGeneratorResponse {
916    fn eq(&self, rhs: &Self) -> bool {
917        #[allow(unused)]
918        use self::_pinternal::OneofUnion as _;
919        use self::_pinternal::SharedItems as _;
920        true && self.error_opt() == rhs.error_opt()
921            && self.supported_features_opt() == rhs.supported_features_opt()
922            && self.file() == rhs.file()
923            && self.shared.unknown_fields() == rhs.shared.unknown_fields()
924    }
925}
926#[doc(hidden)]
927pub mod _fields {
928    mod _root {
929        #[allow(unused)]
930        pub(crate) use super::super::_root::*;
931    }
932    mod _puroro {
933        #[allow(unused)]
934        pub(crate) use super::_root::_puroro::*;
935    }
936    mod _pinternal {
937        #[allow(unused)]
938        pub(crate) use super::_root::_pinternal::*;
939    }
940    #[derive(::std::default::Default)]
941    pub struct VersionFields<TMajor, TMinor, TPatch, TSuffix> {
942        pub major: TMajor,
943        pub minor: TMinor,
944        pub patch: TPatch,
945        pub suffix: TSuffix,
946    }
947    #[derive(::std::default::Default)]
948    pub struct CodeGeneratorRequestFields<
949        TFileToGenerate,
950        TParameter,
951        TProtoFile,
952        TCompilerVersion,
953    > {
954        pub file_to_generate: TFileToGenerate,
955        pub parameter: TParameter,
956        pub proto_file: TProtoFile,
957        pub compiler_version: TCompilerVersion,
958    }
959    #[derive(::std::default::Default)]
960    pub struct CodeGeneratorResponseFields<TError, TSupportedFeatures, TFile> {
961        pub error: TError,
962        pub supported_features: TSupportedFeatures,
963        pub file: TFile,
964    }
965}
966#[doc(hidden)]
967pub use self::_fields::*;
puroro_protobuf_compiled/google/protobuf/compiler.rs

puroro_protobuf_compiled/google/protobuf/
compiler.rs
