buffa_descriptor/generated/
google.protobuf.compiler.plugin.rs

1// @generated by buffa-codegen. DO NOT EDIT.
2// source: google/protobuf/compiler/plugin.proto
3
4/// The version number of protocol compiler.
5#[derive(Clone, PartialEq, Default)]
6#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
7#[cfg_attr(feature = "json", serde(default))]
8#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
9pub struct Version {
10    /// Field 1: `major`
11    #[cfg_attr(
12        feature = "json",
13        serde(
14            rename = "major",
15            with = "::buffa::json_helpers::opt_int32",
16            skip_serializing_if = "::core::option::Option::is_none"
17        )
18    )]
19    pub major: ::core::option::Option<i32>,
20    /// Field 2: `minor`
21    #[cfg_attr(
22        feature = "json",
23        serde(
24            rename = "minor",
25            with = "::buffa::json_helpers::opt_int32",
26            skip_serializing_if = "::core::option::Option::is_none"
27        )
28    )]
29    pub minor: ::core::option::Option<i32>,
30    /// Field 3: `patch`
31    #[cfg_attr(
32        feature = "json",
33        serde(
34            rename = "patch",
35            with = "::buffa::json_helpers::opt_int32",
36            skip_serializing_if = "::core::option::Option::is_none"
37        )
38    )]
39    pub patch: ::core::option::Option<i32>,
40    /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
41    /// be empty for mainline stable releases.
42    ///
43    /// Field 4: `suffix`
44    #[cfg_attr(
45        feature = "json",
46        serde(rename = "suffix", skip_serializing_if = "::core::option::Option::is_none")
47    )]
48    pub suffix: ::core::option::Option<::buffa::alloc::string::String>,
49    #[cfg_attr(feature = "json", serde(skip))]
50    #[doc(hidden)]
51    pub __buffa_unknown_fields: ::buffa::UnknownFields,
52}
53impl ::core::fmt::Debug for Version {
54    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
55        f.debug_struct("Version")
56            .field("major", &self.major)
57            .field("minor", &self.minor)
58            .field("patch", &self.patch)
59            .field("suffix", &self.suffix)
60            .finish()
61    }
62}
63impl Version {
64    /// Protobuf type URL for this message, for use with `Any::pack` and
65    /// `Any::unpack_if`.
66    ///
67    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
68    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.compiler.Version";
69}
70impl Version {
71    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
72    #[inline]
73    ///Sets [`Self::major`] to `Some(value)`, consuming and returning `self`.
74    pub fn with_major(mut self, value: i32) -> Self {
75        self.major = Some(value);
76        self
77    }
78    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
79    #[inline]
80    ///Sets [`Self::minor`] to `Some(value)`, consuming and returning `self`.
81    pub fn with_minor(mut self, value: i32) -> Self {
82        self.minor = Some(value);
83        self
84    }
85    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
86    #[inline]
87    ///Sets [`Self::patch`] to `Some(value)`, consuming and returning `self`.
88    pub fn with_patch(mut self, value: i32) -> Self {
89        self.patch = Some(value);
90        self
91    }
92    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
93    #[inline]
94    ///Sets [`Self::suffix`] to `Some(value)`, consuming and returning `self`.
95    pub fn with_suffix(
96        mut self,
97        value: impl Into<::buffa::alloc::string::String>,
98    ) -> Self {
99        self.suffix = Some(value.into());
100        self
101    }
102}
103::buffa::impl_default_instance!(Version);
104impl ::buffa::MessageName for Version {
105    const PACKAGE: &'static str = "google.protobuf.compiler";
106    const NAME: &'static str = "Version";
107    const FULL_NAME: &'static str = "google.protobuf.compiler.Version";
108    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.compiler.Version";
109}
110impl ::buffa::Message for Version {
111    /// Returns the total encoded size in bytes.
112    ///
113    /// Accumulates in `u64` (which cannot overflow for in-memory
114    /// data) and saturates to `u32` at return, so a message whose
115    /// encoded size exceeds the 2 GiB protobuf limit yields a value
116    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
117    /// points reject, never a silently wrapped size.
118    #[allow(clippy::let_and_return)]
119    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
120        #[allow(unused_imports)]
121        use ::buffa::Enumeration as _;
122        let mut size = 0u64;
123        if let Some(v) = self.major {
124            size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
125        }
126        if let Some(v) = self.minor {
127            size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
128        }
129        if let Some(v) = self.patch {
130            size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
131        }
132        if let Some(ref v) = self.suffix {
133            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
134        }
135        size += self.__buffa_unknown_fields.encoded_len() as u64;
136        ::buffa::saturate_size(size)
137    }
138    fn write_to(
139        &self,
140        _cache: &mut ::buffa::SizeCache,
141        buf: &mut impl ::buffa::EncodeSink,
142    ) {
143        #[allow(unused_imports)]
144        use ::buffa::Enumeration as _;
145        if let Some(v) = self.major {
146            ::buffa::types::put_int32_field(1u32, v, buf);
147        }
148        if let Some(v) = self.minor {
149            ::buffa::types::put_int32_field(2u32, v, buf);
150        }
151        if let Some(v) = self.patch {
152            ::buffa::types::put_int32_field(3u32, v, buf);
153        }
154        if let Some(ref v) = self.suffix {
155            ::buffa::types::put_string_field(4u32, v, buf);
156        }
157        self.__buffa_unknown_fields.write_to(buf);
158    }
159    fn merge_field(
160        &mut self,
161        tag: ::buffa::encoding::Tag,
162        buf: &mut impl ::buffa::bytes::Buf,
163        ctx: ::buffa::DecodeContext<'_>,
164    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
165        #[allow(unused_imports)]
166        use ::buffa::bytes::Buf as _;
167        #[allow(unused_imports)]
168        use ::buffa::Enumeration as _;
169        match tag.field_number() {
170            1u32 => {
171                ::buffa::encoding::check_wire_type(
172                    tag,
173                    ::buffa::encoding::WireType::Varint,
174                )?;
175                self.major = ::core::option::Option::Some(
176                    ::buffa::types::decode_int32(buf)?,
177                );
178            }
179            2u32 => {
180                ::buffa::encoding::check_wire_type(
181                    tag,
182                    ::buffa::encoding::WireType::Varint,
183                )?;
184                self.minor = ::core::option::Option::Some(
185                    ::buffa::types::decode_int32(buf)?,
186                );
187            }
188            3u32 => {
189                ::buffa::encoding::check_wire_type(
190                    tag,
191                    ::buffa::encoding::WireType::Varint,
192                )?;
193                self.patch = ::core::option::Option::Some(
194                    ::buffa::types::decode_int32(buf)?,
195                );
196            }
197            4u32 => {
198                ::buffa::encoding::check_wire_type(
199                    tag,
200                    ::buffa::encoding::WireType::LengthDelimited,
201                )?;
202                ::buffa::types::merge_string(
203                    self.suffix.get_or_insert_with(::buffa::alloc::string::String::new),
204                    buf,
205                )?;
206            }
207            _ => {
208                self.__buffa_unknown_fields
209                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
210            }
211        }
212        ::core::result::Result::Ok(())
213    }
214    fn clear(&mut self) {
215        self.major = ::core::option::Option::None;
216        self.minor = ::core::option::Option::None;
217        self.patch = ::core::option::Option::None;
218        self.suffix = ::core::option::Option::None;
219        self.__buffa_unknown_fields.clear();
220    }
221}
222impl ::buffa::ExtensionSet for Version {
223    const PROTO_FQN: &'static str = "google.protobuf.compiler.Version";
224    fn unknown_fields(&self) -> &::buffa::UnknownFields {
225        &self.__buffa_unknown_fields
226    }
227    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
228        &mut self.__buffa_unknown_fields
229    }
230}
231#[cfg(feature = "text")]
232impl ::buffa::text::TextFormat for Version {
233    fn encode_text(
234        &self,
235        enc: &mut ::buffa::text::TextEncoder<'_>,
236    ) -> ::core::fmt::Result {
237        #[allow(unused_imports)]
238        use ::buffa::Enumeration as _;
239        if let ::core::option::Option::Some(ref __v) = self.major {
240            enc.write_field_name("major")?;
241            enc.write_i32(*__v)?;
242        }
243        if let ::core::option::Option::Some(ref __v) = self.minor {
244            enc.write_field_name("minor")?;
245            enc.write_i32(*__v)?;
246        }
247        if let ::core::option::Option::Some(ref __v) = self.patch {
248            enc.write_field_name("patch")?;
249            enc.write_i32(*__v)?;
250        }
251        if let ::core::option::Option::Some(ref __v) = self.suffix {
252            enc.write_field_name("suffix")?;
253            enc.write_string(__v)?;
254        }
255        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
256        ::core::result::Result::Ok(())
257    }
258    fn merge_text(
259        &mut self,
260        dec: &mut ::buffa::text::TextDecoder<'_>,
261    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
262        #[allow(unused_imports)]
263        use ::buffa::Enumeration as _;
264        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
265            match __name {
266                "major" => self.major = ::core::option::Option::Some(dec.read_i32()?),
267                "minor" => self.minor = ::core::option::Option::Some(dec.read_i32()?),
268                "patch" => self.patch = ::core::option::Option::Some(dec.read_i32()?),
269                "suffix" => {
270                    self.suffix = ::core::option::Option::Some(
271                        dec.read_string()?.into_owned(),
272                    );
273                }
274                _ => dec.skip_value()?,
275            }
276        }
277        ::core::result::Result::Ok(())
278    }
279}
280#[cfg(feature = "json")]
281impl ::buffa::json_helpers::ProtoElemJson for Version {
282    fn serialize_proto_json<S: ::serde::Serializer>(
283        v: &Self,
284        s: S,
285    ) -> ::core::result::Result<S::Ok, S::Error> {
286        ::serde::Serialize::serialize(v, s)
287    }
288    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
289        d: D,
290    ) -> ::core::result::Result<Self, D::Error> {
291        <Self as ::serde::Deserialize>::deserialize(d)
292    }
293}
294#[cfg(feature = "json")]
295#[doc(hidden)]
296pub const __VERSION_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
297    type_url: "type.googleapis.com/google.protobuf.compiler.Version",
298    to_json: ::buffa::type_registry::any_to_json::<Version>,
299    from_json: ::buffa::type_registry::any_from_json::<Version>,
300    is_wkt: false,
301};
302#[cfg(feature = "text")]
303#[doc(hidden)]
304pub const __VERSION_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
305    type_url: "type.googleapis.com/google.protobuf.compiler.Version",
306    text_encode: ::buffa::type_registry::any_encode_text::<Version>,
307    text_merge: ::buffa::type_registry::any_merge_text::<Version>,
308};
309/// An encoded CodeGeneratorRequest is written to the plugin's stdin.
310#[derive(Clone, PartialEq, Default)]
311#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
312#[cfg_attr(feature = "json", serde(default))]
313#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
314pub struct CodeGeneratorRequest {
315    /// The .proto files that were explicitly listed on the command-line.  The
316    /// code generator should generate code only for these files.  Each file's
317    /// descriptor will be included in proto_file, below.
318    ///
319    /// Field 1: `file_to_generate`
320    #[cfg_attr(
321        feature = "json",
322        serde(
323            rename = "fileToGenerate",
324            alias = "file_to_generate",
325            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
326            deserialize_with = "::buffa::json_helpers::null_as_default"
327        )
328    )]
329    pub file_to_generate: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
330    /// The generator parameter passed on the command-line.
331    ///
332    /// Field 2: `parameter`
333    #[cfg_attr(
334        feature = "json",
335        serde(
336            rename = "parameter",
337            skip_serializing_if = "::core::option::Option::is_none"
338        )
339    )]
340    pub parameter: ::core::option::Option<::buffa::alloc::string::String>,
341    /// FileDescriptorProtos for all files in files_to_generate and everything
342    /// they import.  The files will appear in topological order, so each file
343    /// appears before any file that imports it.
344    ///
345    /// Note: the files listed in files_to_generate will include runtime-retention
346    /// options only, but all other files will include source-retention options.
347    /// The source_file_descriptors field below is available in case you need
348    /// source-retention options for files_to_generate.
349    ///
350    /// protoc guarantees that all proto_files will be written after
351    /// the fields above, even though this is not technically guaranteed by the
352    /// protobuf wire format.  This theoretically could allow a plugin to stream
353    /// in the FileDescriptorProtos and handle them one by one rather than read
354    /// the entire set into memory at once.  However, as of this writing, this
355    /// is not similarly optimized on protoc's end -- it will store all fields in
356    /// memory at once before sending them to the plugin.
357    ///
358    /// Type names of fields and extensions in the FileDescriptorProto are always
359    /// fully qualified.
360    ///
361    /// Field 15: `proto_file`
362    #[cfg_attr(
363        feature = "json",
364        serde(
365            rename = "protoFile",
366            alias = "proto_file",
367            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
368            deserialize_with = "::buffa::json_helpers::null_as_default"
369        )
370    )]
371    pub proto_file: ::buffa::alloc::vec::Vec<super::FileDescriptorProto>,
372    /// File descriptors with all options, including source-retention options.
373    /// These descriptors are only provided for the files listed in
374    /// files_to_generate.
375    ///
376    /// Field 17: `source_file_descriptors`
377    #[cfg_attr(
378        feature = "json",
379        serde(
380            rename = "sourceFileDescriptors",
381            alias = "source_file_descriptors",
382            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
383            deserialize_with = "::buffa::json_helpers::null_as_default"
384        )
385    )]
386    pub source_file_descriptors: ::buffa::alloc::vec::Vec<super::FileDescriptorProto>,
387    /// The version number of protocol compiler.
388    ///
389    /// Field 3: `compiler_version`
390    #[cfg_attr(
391        feature = "json",
392        serde(
393            rename = "compilerVersion",
394            alias = "compiler_version",
395            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
396        )
397    )]
398    pub compiler_version: ::buffa::MessageField<Version, ::buffa::Inline<Version>>,
399    #[cfg_attr(feature = "json", serde(skip))]
400    #[doc(hidden)]
401    pub __buffa_unknown_fields: ::buffa::UnknownFields,
402}
403impl ::core::fmt::Debug for CodeGeneratorRequest {
404    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
405        f.debug_struct("CodeGeneratorRequest")
406            .field("file_to_generate", &self.file_to_generate)
407            .field("parameter", &self.parameter)
408            .field("proto_file", &self.proto_file)
409            .field("source_file_descriptors", &self.source_file_descriptors)
410            .field("compiler_version", &self.compiler_version)
411            .finish()
412    }
413}
414impl CodeGeneratorRequest {
415    /// Protobuf type URL for this message, for use with `Any::pack` and
416    /// `Any::unpack_if`.
417    ///
418    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
419    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.compiler.CodeGeneratorRequest";
420}
421impl CodeGeneratorRequest {
422    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
423    #[inline]
424    ///Sets [`Self::parameter`] to `Some(value)`, consuming and returning `self`.
425    pub fn with_parameter(
426        mut self,
427        value: impl Into<::buffa::alloc::string::String>,
428    ) -> Self {
429        self.parameter = Some(value.into());
430        self
431    }
432}
433::buffa::impl_default_instance!(CodeGeneratorRequest);
434impl ::buffa::MessageName for CodeGeneratorRequest {
435    const PACKAGE: &'static str = "google.protobuf.compiler";
436    const NAME: &'static str = "CodeGeneratorRequest";
437    const FULL_NAME: &'static str = "google.protobuf.compiler.CodeGeneratorRequest";
438    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.compiler.CodeGeneratorRequest";
439}
440impl ::buffa::Message for CodeGeneratorRequest {
441    /// Returns the total encoded size in bytes.
442    ///
443    /// Accumulates in `u64` (which cannot overflow for in-memory
444    /// data) and saturates to `u32` at return, so a message whose
445    /// encoded size exceeds the 2 GiB protobuf limit yields a value
446    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
447    /// points reject, never a silently wrapped size.
448    #[allow(clippy::let_and_return)]
449    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
450        #[allow(unused_imports)]
451        use ::buffa::Enumeration as _;
452        let mut size = 0u64;
453        for v in &self.file_to_generate {
454            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
455        }
456        if let Some(ref v) = self.parameter {
457            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
458        }
459        if self.compiler_version.is_set() {
460            let __slot = __cache.reserve();
461            let inner_size = self.compiler_version.compute_size(__cache);
462            __cache.set(__slot, inner_size);
463            size
464                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
465                    + inner_size as u64;
466        }
467        for v in &self.proto_file {
468            let __slot = __cache.reserve();
469            let inner_size = v.compute_size(__cache);
470            __cache.set(__slot, inner_size);
471            size
472                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
473                    + inner_size as u64;
474        }
475        for v in &self.source_file_descriptors {
476            let __slot = __cache.reserve();
477            let inner_size = v.compute_size(__cache);
478            __cache.set(__slot, inner_size);
479            size
480                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
481                    + inner_size as u64;
482        }
483        size += self.__buffa_unknown_fields.encoded_len() as u64;
484        ::buffa::saturate_size(size)
485    }
486    fn write_to(
487        &self,
488        __cache: &mut ::buffa::SizeCache,
489        buf: &mut impl ::buffa::EncodeSink,
490    ) {
491        #[allow(unused_imports)]
492        use ::buffa::Enumeration as _;
493        for v in &self.file_to_generate {
494            ::buffa::types::put_string_field(1u32, v, buf);
495        }
496        if let Some(ref v) = self.parameter {
497            ::buffa::types::put_string_field(2u32, v, buf);
498        }
499        if self.compiler_version.is_set() {
500            ::buffa::types::put_len_delimited_header(
501                3u32,
502                u64::from(__cache.consume_next()),
503                buf,
504            );
505            self.compiler_version.write_to(__cache, buf);
506        }
507        for v in &self.proto_file {
508            ::buffa::types::put_len_delimited_header(
509                15u32,
510                u64::from(__cache.consume_next()),
511                buf,
512            );
513            v.write_to(__cache, buf);
514        }
515        for v in &self.source_file_descriptors {
516            ::buffa::types::put_len_delimited_header(
517                17u32,
518                u64::from(__cache.consume_next()),
519                buf,
520            );
521            v.write_to(__cache, buf);
522        }
523        self.__buffa_unknown_fields.write_to(buf);
524    }
525    fn merge_field(
526        &mut self,
527        tag: ::buffa::encoding::Tag,
528        buf: &mut impl ::buffa::bytes::Buf,
529        ctx: ::buffa::DecodeContext<'_>,
530    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
531        #[allow(unused_imports)]
532        use ::buffa::bytes::Buf as _;
533        #[allow(unused_imports)]
534        use ::buffa::Enumeration as _;
535        match tag.field_number() {
536            1u32 => {
537                ::buffa::encoding::check_wire_type(
538                    tag,
539                    ::buffa::encoding::WireType::LengthDelimited,
540                )?;
541                let __elem = ::buffa::types::decode_string(buf)?;
542                ctx.register_element_memory(
543                    ::buffa::__private::element_footprint(&__elem),
544                )?;
545                self.file_to_generate.push(__elem);
546            }
547            2u32 => {
548                ::buffa::encoding::check_wire_type(
549                    tag,
550                    ::buffa::encoding::WireType::LengthDelimited,
551                )?;
552                ::buffa::types::merge_string(
553                    self
554                        .parameter
555                        .get_or_insert_with(::buffa::alloc::string::String::new),
556                    buf,
557                )?;
558            }
559            3u32 => {
560                ::buffa::encoding::check_wire_type(
561                    tag,
562                    ::buffa::encoding::WireType::LengthDelimited,
563                )?;
564                ::buffa::Message::merge_length_delimited(
565                    self.compiler_version.get_or_insert_default(),
566                    buf,
567                    ctx,
568                )?;
569            }
570            15u32 => {
571                ::buffa::encoding::check_wire_type(
572                    tag,
573                    ::buffa::encoding::WireType::LengthDelimited,
574                )?;
575                let mut elem = ::core::default::Default::default();
576                ctx.register_element_memory(
577                    ::buffa::__private::element_footprint(&elem),
578                )?;
579                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
580                self.proto_file.push(elem);
581            }
582            17u32 => {
583                ::buffa::encoding::check_wire_type(
584                    tag,
585                    ::buffa::encoding::WireType::LengthDelimited,
586                )?;
587                let mut elem = ::core::default::Default::default();
588                ctx.register_element_memory(
589                    ::buffa::__private::element_footprint(&elem),
590                )?;
591                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
592                self.source_file_descriptors.push(elem);
593            }
594            _ => {
595                self.__buffa_unknown_fields
596                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
597            }
598        }
599        ::core::result::Result::Ok(())
600    }
601    fn clear(&mut self) {
602        self.file_to_generate.clear();
603        self.parameter = ::core::option::Option::None;
604        self.compiler_version = ::buffa::MessageField::none();
605        self.proto_file.clear();
606        self.source_file_descriptors.clear();
607        self.__buffa_unknown_fields.clear();
608    }
609}
610impl ::buffa::ExtensionSet for CodeGeneratorRequest {
611    const PROTO_FQN: &'static str = "google.protobuf.compiler.CodeGeneratorRequest";
612    fn unknown_fields(&self) -> &::buffa::UnknownFields {
613        &self.__buffa_unknown_fields
614    }
615    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
616        &mut self.__buffa_unknown_fields
617    }
618}
619#[cfg(feature = "text")]
620impl ::buffa::text::TextFormat for CodeGeneratorRequest {
621    fn encode_text(
622        &self,
623        enc: &mut ::buffa::text::TextEncoder<'_>,
624    ) -> ::core::fmt::Result {
625        #[allow(unused_imports)]
626        use ::buffa::Enumeration as _;
627        if let ::core::option::Option::Some(ref __v) = self.parameter {
628            enc.write_field_name("parameter")?;
629            enc.write_string(__v)?;
630        }
631        if self.compiler_version.is_set() {
632            enc.write_field_name("compiler_version")?;
633            enc.write_message(&*self.compiler_version)?;
634        }
635        for __v in &self.file_to_generate {
636            enc.write_field_name("file_to_generate")?;
637            enc.write_string(__v)?;
638        }
639        for __v in &self.proto_file {
640            enc.write_field_name("proto_file")?;
641            enc.write_message(__v)?;
642        }
643        for __v in &self.source_file_descriptors {
644            enc.write_field_name("source_file_descriptors")?;
645            enc.write_message(__v)?;
646        }
647        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
648        ::core::result::Result::Ok(())
649    }
650    fn merge_text(
651        &mut self,
652        dec: &mut ::buffa::text::TextDecoder<'_>,
653    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
654        #[allow(unused_imports)]
655        use ::buffa::Enumeration as _;
656        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
657            match __name {
658                "parameter" => {
659                    self.parameter = ::core::option::Option::Some(
660                        dec.read_string()?.into_owned(),
661                    );
662                }
663                "compiler_version" => {
664                    dec.merge_message(self.compiler_version.get_or_insert_default())?
665                }
666                "file_to_generate" => {
667                    dec.read_repeated_into(
668                        &mut self.file_to_generate,
669                        |__d| ::core::result::Result::Ok(__d.read_string()?.into_owned()),
670                    )?
671                }
672                "proto_file" => {
673                    dec.read_repeated_into(
674                        &mut self.proto_file,
675                        |__d| {
676                            let mut __m = ::core::default::Default::default();
677                            __d.merge_message(&mut __m)?;
678                            ::core::result::Result::Ok(__m)
679                        },
680                    )?
681                }
682                "source_file_descriptors" => {
683                    dec.read_repeated_into(
684                        &mut self.source_file_descriptors,
685                        |__d| {
686                            let mut __m = ::core::default::Default::default();
687                            __d.merge_message(&mut __m)?;
688                            ::core::result::Result::Ok(__m)
689                        },
690                    )?
691                }
692                _ => dec.skip_value()?,
693            }
694        }
695        ::core::result::Result::Ok(())
696    }
697}
698#[cfg(feature = "json")]
699impl ::buffa::json_helpers::ProtoElemJson for CodeGeneratorRequest {
700    fn serialize_proto_json<S: ::serde::Serializer>(
701        v: &Self,
702        s: S,
703    ) -> ::core::result::Result<S::Ok, S::Error> {
704        ::serde::Serialize::serialize(v, s)
705    }
706    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
707        d: D,
708    ) -> ::core::result::Result<Self, D::Error> {
709        <Self as ::serde::Deserialize>::deserialize(d)
710    }
711}
712#[cfg(feature = "json")]
713#[doc(hidden)]
714pub const __CODE_GENERATOR_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
715    type_url: "type.googleapis.com/google.protobuf.compiler.CodeGeneratorRequest",
716    to_json: ::buffa::type_registry::any_to_json::<CodeGeneratorRequest>,
717    from_json: ::buffa::type_registry::any_from_json::<CodeGeneratorRequest>,
718    is_wkt: false,
719};
720#[cfg(feature = "text")]
721#[doc(hidden)]
722pub const __CODE_GENERATOR_REQUEST_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
723    type_url: "type.googleapis.com/google.protobuf.compiler.CodeGeneratorRequest",
724    text_encode: ::buffa::type_registry::any_encode_text::<CodeGeneratorRequest>,
725    text_merge: ::buffa::type_registry::any_merge_text::<CodeGeneratorRequest>,
726};
727/// The plugin writes an encoded CodeGeneratorResponse to stdout.
728#[derive(Clone, PartialEq, Default)]
729#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
730#[cfg_attr(feature = "json", serde(default))]
731#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
732pub struct CodeGeneratorResponse {
733    /// Error message.  If non-empty, code generation failed.  The plugin process
734    /// should exit with status code zero even if it reports an error in this way.
735    ///
736    /// This should be used to indicate errors in .proto files which prevent the
737    /// code generator from generating correct code.  Errors which indicate a
738    /// problem in protoc itself -- such as the input CodeGeneratorRequest being
739    /// unparseable -- should be reported by writing a message to stderr and
740    /// exiting with a non-zero status code.
741    ///
742    /// Field 1: `error`
743    #[cfg_attr(
744        feature = "json",
745        serde(rename = "error", skip_serializing_if = "::core::option::Option::is_none")
746    )]
747    pub error: ::core::option::Option<::buffa::alloc::string::String>,
748    /// A bitmask of supported features that the code generator supports.
749    /// This is a bitwise "or" of values from the Feature enum.
750    ///
751    /// Field 2: `supported_features`
752    #[cfg_attr(
753        feature = "json",
754        serde(
755            rename = "supportedFeatures",
756            alias = "supported_features",
757            with = "::buffa::json_helpers::opt_uint64",
758            skip_serializing_if = "::core::option::Option::is_none"
759        )
760    )]
761    pub supported_features: ::core::option::Option<u64>,
762    /// The minimum edition this plugin supports.  This will be treated as an
763    /// Edition enum, but we want to allow unknown values.  It should be specified
764    /// according the edition enum value, *not* the edition number.  Only takes
765    /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.
766    ///
767    /// Field 3: `minimum_edition`
768    #[cfg_attr(
769        feature = "json",
770        serde(
771            rename = "minimumEdition",
772            alias = "minimum_edition",
773            with = "::buffa::json_helpers::opt_int32",
774            skip_serializing_if = "::core::option::Option::is_none"
775        )
776    )]
777    pub minimum_edition: ::core::option::Option<i32>,
778    /// The maximum edition this plugin supports.  This will be treated as an
779    /// Edition enum, but we want to allow unknown values.  It should be specified
780    /// according the edition enum value, *not* the edition number.  Only takes
781    /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.
782    ///
783    /// Field 4: `maximum_edition`
784    #[cfg_attr(
785        feature = "json",
786        serde(
787            rename = "maximumEdition",
788            alias = "maximum_edition",
789            with = "::buffa::json_helpers::opt_int32",
790            skip_serializing_if = "::core::option::Option::is_none"
791        )
792    )]
793    pub maximum_edition: ::core::option::Option<i32>,
794    /// Field 15: `file`
795    #[cfg_attr(
796        feature = "json",
797        serde(
798            rename = "file",
799            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
800            deserialize_with = "::buffa::json_helpers::null_as_default"
801        )
802    )]
803    pub file: ::buffa::alloc::vec::Vec<code_generator_response::File>,
804    #[cfg_attr(feature = "json", serde(skip))]
805    #[doc(hidden)]
806    pub __buffa_unknown_fields: ::buffa::UnknownFields,
807}
808impl ::core::fmt::Debug for CodeGeneratorResponse {
809    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
810        f.debug_struct("CodeGeneratorResponse")
811            .field("error", &self.error)
812            .field("supported_features", &self.supported_features)
813            .field("minimum_edition", &self.minimum_edition)
814            .field("maximum_edition", &self.maximum_edition)
815            .field("file", &self.file)
816            .finish()
817    }
818}
819impl CodeGeneratorResponse {
820    /// Protobuf type URL for this message, for use with `Any::pack` and
821    /// `Any::unpack_if`.
822    ///
823    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
824    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.compiler.CodeGeneratorResponse";
825}
826impl CodeGeneratorResponse {
827    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
828    #[inline]
829    ///Sets [`Self::error`] to `Some(value)`, consuming and returning `self`.
830    pub fn with_error(
831        mut self,
832        value: impl Into<::buffa::alloc::string::String>,
833    ) -> Self {
834        self.error = Some(value.into());
835        self
836    }
837    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
838    #[inline]
839    ///Sets [`Self::supported_features`] to `Some(value)`, consuming and returning `self`.
840    pub fn with_supported_features(mut self, value: u64) -> Self {
841        self.supported_features = Some(value);
842        self
843    }
844    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
845    #[inline]
846    ///Sets [`Self::minimum_edition`] to `Some(value)`, consuming and returning `self`.
847    pub fn with_minimum_edition(mut self, value: i32) -> Self {
848        self.minimum_edition = Some(value);
849        self
850    }
851    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
852    #[inline]
853    ///Sets [`Self::maximum_edition`] to `Some(value)`, consuming and returning `self`.
854    pub fn with_maximum_edition(mut self, value: i32) -> Self {
855        self.maximum_edition = Some(value);
856        self
857    }
858}
859::buffa::impl_default_instance!(CodeGeneratorResponse);
860impl ::buffa::MessageName for CodeGeneratorResponse {
861    const PACKAGE: &'static str = "google.protobuf.compiler";
862    const NAME: &'static str = "CodeGeneratorResponse";
863    const FULL_NAME: &'static str = "google.protobuf.compiler.CodeGeneratorResponse";
864    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.compiler.CodeGeneratorResponse";
865}
866impl ::buffa::Message for CodeGeneratorResponse {
867    /// Returns the total encoded size in bytes.
868    ///
869    /// Accumulates in `u64` (which cannot overflow for in-memory
870    /// data) and saturates to `u32` at return, so a message whose
871    /// encoded size exceeds the 2 GiB protobuf limit yields a value
872    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
873    /// points reject, never a silently wrapped size.
874    #[allow(clippy::let_and_return)]
875    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
876        #[allow(unused_imports)]
877        use ::buffa::Enumeration as _;
878        let mut size = 0u64;
879        if let Some(ref v) = self.error {
880            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
881        }
882        if let Some(v) = self.supported_features {
883            size += 1u64 + ::buffa::types::uint64_encoded_len(v) as u64;
884        }
885        if let Some(v) = self.minimum_edition {
886            size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
887        }
888        if let Some(v) = self.maximum_edition {
889            size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
890        }
891        for v in &self.file {
892            let __slot = __cache.reserve();
893            let inner_size = v.compute_size(__cache);
894            __cache.set(__slot, inner_size);
895            size
896                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
897                    + inner_size as u64;
898        }
899        size += self.__buffa_unknown_fields.encoded_len() as u64;
900        ::buffa::saturate_size(size)
901    }
902    fn write_to(
903        &self,
904        __cache: &mut ::buffa::SizeCache,
905        buf: &mut impl ::buffa::EncodeSink,
906    ) {
907        #[allow(unused_imports)]
908        use ::buffa::Enumeration as _;
909        if let Some(ref v) = self.error {
910            ::buffa::types::put_string_field(1u32, v, buf);
911        }
912        if let Some(v) = self.supported_features {
913            ::buffa::types::put_uint64_field(2u32, v, buf);
914        }
915        if let Some(v) = self.minimum_edition {
916            ::buffa::types::put_int32_field(3u32, v, buf);
917        }
918        if let Some(v) = self.maximum_edition {
919            ::buffa::types::put_int32_field(4u32, v, buf);
920        }
921        for v in &self.file {
922            ::buffa::types::put_len_delimited_header(
923                15u32,
924                u64::from(__cache.consume_next()),
925                buf,
926            );
927            v.write_to(__cache, buf);
928        }
929        self.__buffa_unknown_fields.write_to(buf);
930    }
931    fn merge_field(
932        &mut self,
933        tag: ::buffa::encoding::Tag,
934        buf: &mut impl ::buffa::bytes::Buf,
935        ctx: ::buffa::DecodeContext<'_>,
936    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
937        #[allow(unused_imports)]
938        use ::buffa::bytes::Buf as _;
939        #[allow(unused_imports)]
940        use ::buffa::Enumeration as _;
941        match tag.field_number() {
942            1u32 => {
943                ::buffa::encoding::check_wire_type(
944                    tag,
945                    ::buffa::encoding::WireType::LengthDelimited,
946                )?;
947                ::buffa::types::merge_string(
948                    self.error.get_or_insert_with(::buffa::alloc::string::String::new),
949                    buf,
950                )?;
951            }
952            2u32 => {
953                ::buffa::encoding::check_wire_type(
954                    tag,
955                    ::buffa::encoding::WireType::Varint,
956                )?;
957                self.supported_features = ::core::option::Option::Some(
958                    ::buffa::types::decode_uint64(buf)?,
959                );
960            }
961            3u32 => {
962                ::buffa::encoding::check_wire_type(
963                    tag,
964                    ::buffa::encoding::WireType::Varint,
965                )?;
966                self.minimum_edition = ::core::option::Option::Some(
967                    ::buffa::types::decode_int32(buf)?,
968                );
969            }
970            4u32 => {
971                ::buffa::encoding::check_wire_type(
972                    tag,
973                    ::buffa::encoding::WireType::Varint,
974                )?;
975                self.maximum_edition = ::core::option::Option::Some(
976                    ::buffa::types::decode_int32(buf)?,
977                );
978            }
979            15u32 => {
980                ::buffa::encoding::check_wire_type(
981                    tag,
982                    ::buffa::encoding::WireType::LengthDelimited,
983                )?;
984                let mut elem = ::core::default::Default::default();
985                ctx.register_element_memory(
986                    ::buffa::__private::element_footprint(&elem),
987                )?;
988                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
989                self.file.push(elem);
990            }
991            _ => {
992                self.__buffa_unknown_fields
993                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
994            }
995        }
996        ::core::result::Result::Ok(())
997    }
998    fn clear(&mut self) {
999        self.error = ::core::option::Option::None;
1000        self.supported_features = ::core::option::Option::None;
1001        self.minimum_edition = ::core::option::Option::None;
1002        self.maximum_edition = ::core::option::Option::None;
1003        self.file.clear();
1004        self.__buffa_unknown_fields.clear();
1005    }
1006}
1007impl ::buffa::ExtensionSet for CodeGeneratorResponse {
1008    const PROTO_FQN: &'static str = "google.protobuf.compiler.CodeGeneratorResponse";
1009    fn unknown_fields(&self) -> &::buffa::UnknownFields {
1010        &self.__buffa_unknown_fields
1011    }
1012    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1013        &mut self.__buffa_unknown_fields
1014    }
1015}
1016#[cfg(feature = "text")]
1017impl ::buffa::text::TextFormat for CodeGeneratorResponse {
1018    fn encode_text(
1019        &self,
1020        enc: &mut ::buffa::text::TextEncoder<'_>,
1021    ) -> ::core::fmt::Result {
1022        #[allow(unused_imports)]
1023        use ::buffa::Enumeration as _;
1024        if let ::core::option::Option::Some(ref __v) = self.error {
1025            enc.write_field_name("error")?;
1026            enc.write_string(__v)?;
1027        }
1028        if let ::core::option::Option::Some(ref __v) = self.supported_features {
1029            enc.write_field_name("supported_features")?;
1030            enc.write_u64(*__v)?;
1031        }
1032        if let ::core::option::Option::Some(ref __v) = self.minimum_edition {
1033            enc.write_field_name("minimum_edition")?;
1034            enc.write_i32(*__v)?;
1035        }
1036        if let ::core::option::Option::Some(ref __v) = self.maximum_edition {
1037            enc.write_field_name("maximum_edition")?;
1038            enc.write_i32(*__v)?;
1039        }
1040        for __v in &self.file {
1041            enc.write_field_name("file")?;
1042            enc.write_message(__v)?;
1043        }
1044        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
1045        ::core::result::Result::Ok(())
1046    }
1047    fn merge_text(
1048        &mut self,
1049        dec: &mut ::buffa::text::TextDecoder<'_>,
1050    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
1051        #[allow(unused_imports)]
1052        use ::buffa::Enumeration as _;
1053        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
1054            match __name {
1055                "error" => {
1056                    self.error = ::core::option::Option::Some(
1057                        dec.read_string()?.into_owned(),
1058                    );
1059                }
1060                "supported_features" => {
1061                    self.supported_features = ::core::option::Option::Some(
1062                        dec.read_u64()?,
1063                    );
1064                }
1065                "minimum_edition" => {
1066                    self.minimum_edition = ::core::option::Option::Some(dec.read_i32()?);
1067                }
1068                "maximum_edition" => {
1069                    self.maximum_edition = ::core::option::Option::Some(dec.read_i32()?);
1070                }
1071                "file" => {
1072                    dec.read_repeated_into(
1073                        &mut self.file,
1074                        |__d| {
1075                            let mut __m = ::core::default::Default::default();
1076                            __d.merge_message(&mut __m)?;
1077                            ::core::result::Result::Ok(__m)
1078                        },
1079                    )?
1080                }
1081                _ => dec.skip_value()?,
1082            }
1083        }
1084        ::core::result::Result::Ok(())
1085    }
1086}
1087#[cfg(feature = "json")]
1088impl ::buffa::json_helpers::ProtoElemJson for CodeGeneratorResponse {
1089    fn serialize_proto_json<S: ::serde::Serializer>(
1090        v: &Self,
1091        s: S,
1092    ) -> ::core::result::Result<S::Ok, S::Error> {
1093        ::serde::Serialize::serialize(v, s)
1094    }
1095    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1096        d: D,
1097    ) -> ::core::result::Result<Self, D::Error> {
1098        <Self as ::serde::Deserialize>::deserialize(d)
1099    }
1100}
1101#[cfg(feature = "json")]
1102#[doc(hidden)]
1103pub const __CODE_GENERATOR_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1104    type_url: "type.googleapis.com/google.protobuf.compiler.CodeGeneratorResponse",
1105    to_json: ::buffa::type_registry::any_to_json::<CodeGeneratorResponse>,
1106    from_json: ::buffa::type_registry::any_from_json::<CodeGeneratorResponse>,
1107    is_wkt: false,
1108};
1109#[cfg(feature = "text")]
1110#[doc(hidden)]
1111pub const __CODE_GENERATOR_RESPONSE_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
1112    type_url: "type.googleapis.com/google.protobuf.compiler.CodeGeneratorResponse",
1113    text_encode: ::buffa::type_registry::any_encode_text::<CodeGeneratorResponse>,
1114    text_merge: ::buffa::type_registry::any_merge_text::<CodeGeneratorResponse>,
1115};
1116pub mod code_generator_response {
1117    #[allow(unused_imports)]
1118    use super::*;
1119    /// Sync with code_generator.h.
1120    #[allow(non_camel_case_types)]
1121    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
1122    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
1123    #[repr(i32)]
1124    pub enum Feature {
1125        FEATURE_NONE = 0i32,
1126        FEATURE_PROTO3_OPTIONAL = 1i32,
1127        FEATURE_SUPPORTS_EDITIONS = 2i32,
1128    }
1129    impl Feature {
1130        ///Idiomatic alias for [`Self::FEATURE_NONE`]; `Debug` prints the variant name.
1131        #[allow(non_upper_case_globals)]
1132        pub const None: Self = Self::FEATURE_NONE;
1133        ///Idiomatic alias for [`Self::FEATURE_PROTO3_OPTIONAL`]; `Debug` prints the variant name.
1134        #[allow(non_upper_case_globals)]
1135        pub const Proto3Optional: Self = Self::FEATURE_PROTO3_OPTIONAL;
1136        ///Idiomatic alias for [`Self::FEATURE_SUPPORTS_EDITIONS`]; `Debug` prints the variant name.
1137        #[allow(non_upper_case_globals)]
1138        pub const SupportsEditions: Self = Self::FEATURE_SUPPORTS_EDITIONS;
1139    }
1140    impl ::core::default::Default for Feature {
1141        fn default() -> Self {
1142            Self::FEATURE_NONE
1143        }
1144    }
1145    #[cfg(feature = "json")]
1146    const _: () = {
1147        impl ::serde::Serialize for Feature {
1148            fn serialize<S: ::serde::Serializer>(
1149                &self,
1150                s: S,
1151            ) -> ::core::result::Result<S::Ok, S::Error> {
1152                s.serialize_str(::buffa::Enumeration::proto_name(self))
1153            }
1154        }
1155        impl<'de> ::serde::Deserialize<'de> for Feature {
1156            fn deserialize<D: ::serde::Deserializer<'de>>(
1157                d: D,
1158            ) -> ::core::result::Result<Self, D::Error> {
1159                struct _V;
1160                impl ::serde::de::Visitor<'_> for _V {
1161                    type Value = Feature;
1162                    fn expecting(
1163                        &self,
1164                        f: &mut ::core::fmt::Formatter<'_>,
1165                    ) -> ::core::fmt::Result {
1166                        f.write_str(
1167                            concat!(
1168                                "a string, integer, or null for ", stringify!(Feature)
1169                            ),
1170                        )
1171                    }
1172                    fn visit_str<E: ::serde::de::Error>(
1173                        self,
1174                        v: &str,
1175                    ) -> ::core::result::Result<Feature, E> {
1176                        <Feature as ::buffa::Enumeration>::from_proto_name(v)
1177                            .ok_or_else(|| {
1178                                ::serde::de::Error::unknown_variant(v, &[])
1179                            })
1180                    }
1181                    fn visit_i64<E: ::serde::de::Error>(
1182                        self,
1183                        v: i64,
1184                    ) -> ::core::result::Result<Feature, E> {
1185                        let v32 = i32::try_from(v)
1186                            .map_err(|_| {
1187                                ::serde::de::Error::custom(
1188                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
1189                                )
1190                            })?;
1191                        <Feature as ::buffa::Enumeration>::from_i32(v32)
1192                            .ok_or_else(|| {
1193                                ::serde::de::Error::custom(
1194                                    ::buffa::alloc::format!("unknown enum value {v32}"),
1195                                )
1196                            })
1197                    }
1198                    fn visit_u64<E: ::serde::de::Error>(
1199                        self,
1200                        v: u64,
1201                    ) -> ::core::result::Result<Feature, E> {
1202                        let v32 = i32::try_from(v)
1203                            .map_err(|_| {
1204                                ::serde::de::Error::custom(
1205                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
1206                                )
1207                            })?;
1208                        <Feature as ::buffa::Enumeration>::from_i32(v32)
1209                            .ok_or_else(|| {
1210                                ::serde::de::Error::custom(
1211                                    ::buffa::alloc::format!("unknown enum value {v32}"),
1212                                )
1213                            })
1214                    }
1215                    fn visit_unit<E: ::serde::de::Error>(
1216                        self,
1217                    ) -> ::core::result::Result<Feature, E> {
1218                        ::core::result::Result::Ok(::core::default::Default::default())
1219                    }
1220                }
1221                d.deserialize_any(_V)
1222            }
1223        }
1224        impl ::buffa::json_helpers::ProtoElemJson for Feature {
1225            fn serialize_proto_json<S: ::serde::Serializer>(
1226                v: &Self,
1227                s: S,
1228            ) -> ::core::result::Result<S::Ok, S::Error> {
1229                ::serde::Serialize::serialize(v, s)
1230            }
1231            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1232                d: D,
1233            ) -> ::core::result::Result<Self, D::Error> {
1234                <Self as ::serde::Deserialize>::deserialize(d)
1235            }
1236        }
1237    };
1238    impl ::buffa::Enumeration for Feature {
1239        fn from_i32(value: i32) -> ::core::option::Option<Self> {
1240            match value {
1241                0i32 => ::core::option::Option::Some(Self::FEATURE_NONE),
1242                1i32 => ::core::option::Option::Some(Self::FEATURE_PROTO3_OPTIONAL),
1243                2i32 => ::core::option::Option::Some(Self::FEATURE_SUPPORTS_EDITIONS),
1244                _ => ::core::option::Option::None,
1245            }
1246        }
1247        fn to_i32(&self) -> i32 {
1248            *self as i32
1249        }
1250        fn proto_name(&self) -> &'static str {
1251            match self {
1252                Self::FEATURE_NONE => "FEATURE_NONE",
1253                Self::FEATURE_PROTO3_OPTIONAL => "FEATURE_PROTO3_OPTIONAL",
1254                Self::FEATURE_SUPPORTS_EDITIONS => "FEATURE_SUPPORTS_EDITIONS",
1255            }
1256        }
1257        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
1258            match name {
1259                "FEATURE_NONE" => ::core::option::Option::Some(Self::FEATURE_NONE),
1260                "FEATURE_PROTO3_OPTIONAL" => {
1261                    ::core::option::Option::Some(Self::FEATURE_PROTO3_OPTIONAL)
1262                }
1263                "FEATURE_SUPPORTS_EDITIONS" => {
1264                    ::core::option::Option::Some(Self::FEATURE_SUPPORTS_EDITIONS)
1265                }
1266                _ => ::core::option::Option::None,
1267            }
1268        }
1269        fn values() -> &'static [Self] {
1270            &[
1271                Self::FEATURE_NONE,
1272                Self::FEATURE_PROTO3_OPTIONAL,
1273                Self::FEATURE_SUPPORTS_EDITIONS,
1274            ]
1275        }
1276    }
1277    /// Represents a single generated file.
1278    #[derive(Clone, PartialEq, Default)]
1279    #[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
1280    #[cfg_attr(feature = "json", serde(default))]
1281    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
1282    pub struct File {
1283        /// The file name, relative to the output directory.  The name must not
1284        /// contain "." or ".." components and must be relative, not be absolute (so,
1285        /// the file cannot lie outside the output directory).  "/" must be used as
1286        /// the path separator, not "\".
1287        ///
1288        /// If the name is omitted, the content will be appended to the previous
1289        /// file.  This allows the generator to break large files into small chunks,
1290        /// and allows the generated text to be streamed back to protoc so that large
1291        /// files need not reside completely in memory at one time.  Note that as of
1292        /// this writing protoc does not optimize for this -- it will read the entire
1293        /// CodeGeneratorResponse before writing files to disk.
1294        ///
1295        /// Field 1: `name`
1296        #[cfg_attr(
1297            feature = "json",
1298            serde(
1299                rename = "name",
1300                skip_serializing_if = "::core::option::Option::is_none"
1301            )
1302        )]
1303        pub name: ::core::option::Option<::buffa::alloc::string::String>,
1304        /// If non-empty, indicates that the named file should already exist, and the
1305        /// content here is to be inserted into that file at a defined insertion
1306        /// point.  This feature allows a code generator to extend the output
1307        /// produced by another code generator.  The original generator may provide
1308        /// insertion points by placing special annotations in the file that look
1309        /// like:
1310        ///   @@protoc_insertion_point(NAME)
1311        /// The annotation can have arbitrary text before and after it on the line,
1312        /// which allows it to be placed in a comment.  NAME should be replaced with
1313        /// an identifier naming the point -- this is what other generators will use
1314        /// as the insertion_point.  Code inserted at this point will be placed
1315        /// immediately above the line containing the insertion point (thus multiple
1316        /// insertions to the same point will come out in the order they were added).
1317        /// The double-@ is intended to make it unlikely that the generated code
1318        /// could contain things that look like insertion points by accident.
1319        ///
1320        /// For example, the C++ code generator places the following line in the
1321        /// .pb.h files that it generates:
1322        ///   // @@protoc_insertion_point(namespace_scope)
1323        /// This line appears within the scope of the file's package namespace, but
1324        /// outside of any particular class.  Another plugin can then specify the
1325        /// insertion_point "namespace_scope" to generate additional classes or
1326        /// other declarations that should be placed in this scope.
1327        ///
1328        /// Note that if the line containing the insertion point begins with
1329        /// whitespace, the same whitespace will be added to every line of the
1330        /// inserted text.  This is useful for languages like Python, where
1331        /// indentation matters.  In these languages, the insertion point comment
1332        /// should be indented the same amount as any inserted code will need to be
1333        /// in order to work correctly in that context.
1334        ///
1335        /// The code generator that generates the initial file and the one which
1336        /// inserts into it must both run as part of a single invocation of protoc.
1337        /// Code generators are executed in the order in which they appear on the
1338        /// command line.
1339        ///
1340        /// If |insertion_point| is present, |name| must also be present.
1341        ///
1342        /// Field 2: `insertion_point`
1343        #[cfg_attr(
1344            feature = "json",
1345            serde(
1346                rename = "insertionPoint",
1347                alias = "insertion_point",
1348                skip_serializing_if = "::core::option::Option::is_none"
1349            )
1350        )]
1351        pub insertion_point: ::core::option::Option<::buffa::alloc::string::String>,
1352        /// The file contents.
1353        ///
1354        /// Field 15: `content`
1355        #[cfg_attr(
1356            feature = "json",
1357            serde(
1358                rename = "content",
1359                skip_serializing_if = "::core::option::Option::is_none"
1360            )
1361        )]
1362        pub content: ::core::option::Option<::buffa::alloc::string::String>,
1363        /// Information describing the file content being inserted. If an insertion
1364        /// point is used, this information will be appropriately offset and inserted
1365        /// into the code generation metadata for the generated files.
1366        ///
1367        /// Field 16: `generated_code_info`
1368        #[cfg_attr(
1369            feature = "json",
1370            serde(
1371                rename = "generatedCodeInfo",
1372                alias = "generated_code_info",
1373                skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
1374            )
1375        )]
1376        pub generated_code_info: ::buffa::MessageField<
1377            super::super::GeneratedCodeInfo,
1378            ::buffa::Inline<super::super::GeneratedCodeInfo>,
1379        >,
1380        #[cfg_attr(feature = "json", serde(skip))]
1381        #[doc(hidden)]
1382        pub __buffa_unknown_fields: ::buffa::UnknownFields,
1383    }
1384    impl ::core::fmt::Debug for File {
1385        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1386            f.debug_struct("File")
1387                .field("name", &self.name)
1388                .field("insertion_point", &self.insertion_point)
1389                .field("content", &self.content)
1390                .field("generated_code_info", &self.generated_code_info)
1391                .finish()
1392        }
1393    }
1394    impl File {
1395        /// Protobuf type URL for this message, for use with `Any::pack` and
1396        /// `Any::unpack_if`.
1397        ///
1398        /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
1399        pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.compiler.CodeGeneratorResponse.File";
1400    }
1401    impl File {
1402        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
1403        #[inline]
1404        ///Sets [`Self::name`] to `Some(value)`, consuming and returning `self`.
1405        pub fn with_name(
1406            mut self,
1407            value: impl Into<::buffa::alloc::string::String>,
1408        ) -> Self {
1409            self.name = Some(value.into());
1410            self
1411        }
1412        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
1413        #[inline]
1414        ///Sets [`Self::insertion_point`] to `Some(value)`, consuming and returning `self`.
1415        pub fn with_insertion_point(
1416            mut self,
1417            value: impl Into<::buffa::alloc::string::String>,
1418        ) -> Self {
1419            self.insertion_point = Some(value.into());
1420            self
1421        }
1422        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
1423        #[inline]
1424        ///Sets [`Self::content`] to `Some(value)`, consuming and returning `self`.
1425        pub fn with_content(
1426            mut self,
1427            value: impl Into<::buffa::alloc::string::String>,
1428        ) -> Self {
1429            self.content = Some(value.into());
1430            self
1431        }
1432    }
1433    ::buffa::impl_default_instance!(File);
1434    impl ::buffa::MessageName for File {
1435        const PACKAGE: &'static str = "google.protobuf.compiler";
1436        const NAME: &'static str = "CodeGeneratorResponse.File";
1437        const FULL_NAME: &'static str = "google.protobuf.compiler.CodeGeneratorResponse.File";
1438        const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.compiler.CodeGeneratorResponse.File";
1439    }
1440    impl ::buffa::Message for File {
1441        /// Returns the total encoded size in bytes.
1442        ///
1443        /// Accumulates in `u64` (which cannot overflow for in-memory
1444        /// data) and saturates to `u32` at return, so a message whose
1445        /// encoded size exceeds the 2 GiB protobuf limit yields a value
1446        /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
1447        /// points reject, never a silently wrapped size.
1448        #[allow(clippy::let_and_return)]
1449        fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
1450            #[allow(unused_imports)]
1451            use ::buffa::Enumeration as _;
1452            let mut size = 0u64;
1453            if let Some(ref v) = self.name {
1454                size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
1455            }
1456            if let Some(ref v) = self.insertion_point {
1457                size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
1458            }
1459            if let Some(ref v) = self.content {
1460                size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
1461            }
1462            if self.generated_code_info.is_set() {
1463                let __slot = __cache.reserve();
1464                let inner_size = self.generated_code_info.compute_size(__cache);
1465                __cache.set(__slot, inner_size);
1466                size
1467                    += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
1468                        + inner_size as u64;
1469            }
1470            size += self.__buffa_unknown_fields.encoded_len() as u64;
1471            ::buffa::saturate_size(size)
1472        }
1473        fn write_to(
1474            &self,
1475            __cache: &mut ::buffa::SizeCache,
1476            buf: &mut impl ::buffa::EncodeSink,
1477        ) {
1478            #[allow(unused_imports)]
1479            use ::buffa::Enumeration as _;
1480            if let Some(ref v) = self.name {
1481                ::buffa::types::put_string_field(1u32, v, buf);
1482            }
1483            if let Some(ref v) = self.insertion_point {
1484                ::buffa::types::put_string_field(2u32, v, buf);
1485            }
1486            if let Some(ref v) = self.content {
1487                ::buffa::types::put_string_field(15u32, v, buf);
1488            }
1489            if self.generated_code_info.is_set() {
1490                ::buffa::types::put_len_delimited_header(
1491                    16u32,
1492                    u64::from(__cache.consume_next()),
1493                    buf,
1494                );
1495                self.generated_code_info.write_to(__cache, buf);
1496            }
1497            self.__buffa_unknown_fields.write_to(buf);
1498        }
1499        fn merge_field(
1500            &mut self,
1501            tag: ::buffa::encoding::Tag,
1502            buf: &mut impl ::buffa::bytes::Buf,
1503            ctx: ::buffa::DecodeContext<'_>,
1504        ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1505            #[allow(unused_imports)]
1506            use ::buffa::bytes::Buf as _;
1507            #[allow(unused_imports)]
1508            use ::buffa::Enumeration as _;
1509            match tag.field_number() {
1510                1u32 => {
1511                    ::buffa::encoding::check_wire_type(
1512                        tag,
1513                        ::buffa::encoding::WireType::LengthDelimited,
1514                    )?;
1515                    ::buffa::types::merge_string(
1516                        self
1517                            .name
1518                            .get_or_insert_with(::buffa::alloc::string::String::new),
1519                        buf,
1520                    )?;
1521                }
1522                2u32 => {
1523                    ::buffa::encoding::check_wire_type(
1524                        tag,
1525                        ::buffa::encoding::WireType::LengthDelimited,
1526                    )?;
1527                    ::buffa::types::merge_string(
1528                        self
1529                            .insertion_point
1530                            .get_or_insert_with(::buffa::alloc::string::String::new),
1531                        buf,
1532                    )?;
1533                }
1534                15u32 => {
1535                    ::buffa::encoding::check_wire_type(
1536                        tag,
1537                        ::buffa::encoding::WireType::LengthDelimited,
1538                    )?;
1539                    ::buffa::types::merge_string(
1540                        self
1541                            .content
1542                            .get_or_insert_with(::buffa::alloc::string::String::new),
1543                        buf,
1544                    )?;
1545                }
1546                16u32 => {
1547                    ::buffa::encoding::check_wire_type(
1548                        tag,
1549                        ::buffa::encoding::WireType::LengthDelimited,
1550                    )?;
1551                    ::buffa::Message::merge_length_delimited(
1552                        self.generated_code_info.get_or_insert_default(),
1553                        buf,
1554                        ctx,
1555                    )?;
1556                }
1557                _ => {
1558                    self.__buffa_unknown_fields
1559                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
1560                }
1561            }
1562            ::core::result::Result::Ok(())
1563        }
1564        fn clear(&mut self) {
1565            self.name = ::core::option::Option::None;
1566            self.insertion_point = ::core::option::Option::None;
1567            self.content = ::core::option::Option::None;
1568            self.generated_code_info = ::buffa::MessageField::none();
1569            self.__buffa_unknown_fields.clear();
1570        }
1571    }
1572    impl ::buffa::ExtensionSet for File {
1573        const PROTO_FQN: &'static str = "google.protobuf.compiler.CodeGeneratorResponse.File";
1574        fn unknown_fields(&self) -> &::buffa::UnknownFields {
1575            &self.__buffa_unknown_fields
1576        }
1577        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1578            &mut self.__buffa_unknown_fields
1579        }
1580    }
1581    #[cfg(feature = "text")]
1582    impl ::buffa::text::TextFormat for File {
1583        fn encode_text(
1584            &self,
1585            enc: &mut ::buffa::text::TextEncoder<'_>,
1586        ) -> ::core::fmt::Result {
1587            #[allow(unused_imports)]
1588            use ::buffa::Enumeration as _;
1589            if let ::core::option::Option::Some(ref __v) = self.name {
1590                enc.write_field_name("name")?;
1591                enc.write_string(__v)?;
1592            }
1593            if let ::core::option::Option::Some(ref __v) = self.insertion_point {
1594                enc.write_field_name("insertion_point")?;
1595                enc.write_string(__v)?;
1596            }
1597            if let ::core::option::Option::Some(ref __v) = self.content {
1598                enc.write_field_name("content")?;
1599                enc.write_string(__v)?;
1600            }
1601            if self.generated_code_info.is_set() {
1602                enc.write_field_name("generated_code_info")?;
1603                enc.write_message(&*self.generated_code_info)?;
1604            }
1605            enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
1606            ::core::result::Result::Ok(())
1607        }
1608        fn merge_text(
1609            &mut self,
1610            dec: &mut ::buffa::text::TextDecoder<'_>,
1611        ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
1612            #[allow(unused_imports)]
1613            use ::buffa::Enumeration as _;
1614            while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
1615                match __name {
1616                    "name" => {
1617                        self.name = ::core::option::Option::Some(
1618                            dec.read_string()?.into_owned(),
1619                        );
1620                    }
1621                    "insertion_point" => {
1622                        self.insertion_point = ::core::option::Option::Some(
1623                            dec.read_string()?.into_owned(),
1624                        );
1625                    }
1626                    "content" => {
1627                        self.content = ::core::option::Option::Some(
1628                            dec.read_string()?.into_owned(),
1629                        );
1630                    }
1631                    "generated_code_info" => {
1632                        dec.merge_message(
1633                            self.generated_code_info.get_or_insert_default(),
1634                        )?
1635                    }
1636                    _ => dec.skip_value()?,
1637                }
1638            }
1639            ::core::result::Result::Ok(())
1640        }
1641    }
1642    #[cfg(feature = "json")]
1643    impl ::buffa::json_helpers::ProtoElemJson for File {
1644        fn serialize_proto_json<S: ::serde::Serializer>(
1645            v: &Self,
1646            s: S,
1647        ) -> ::core::result::Result<S::Ok, S::Error> {
1648            ::serde::Serialize::serialize(v, s)
1649        }
1650        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1651            d: D,
1652        ) -> ::core::result::Result<Self, D::Error> {
1653            <Self as ::serde::Deserialize>::deserialize(d)
1654        }
1655    }
1656    #[cfg(feature = "json")]
1657    #[doc(hidden)]
1658    pub const __FILE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1659        type_url: "type.googleapis.com/google.protobuf.compiler.CodeGeneratorResponse.File",
1660        to_json: ::buffa::type_registry::any_to_json::<File>,
1661        from_json: ::buffa::type_registry::any_from_json::<File>,
1662        is_wkt: false,
1663    };
1664    #[cfg(feature = "text")]
1665    #[doc(hidden)]
1666    pub const __FILE_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
1667        type_url: "type.googleapis.com/google.protobuf.compiler.CodeGeneratorResponse.File",
1668        text_encode: ::buffa::type_registry::any_encode_text::<File>,
1669        text_merge: ::buffa::type_registry::any_merge_text::<File>,
1670    };
1671    #[cfg(feature = "views")]
1672    #[doc(inline)]
1673    pub use super::__buffa::view::code_generator_response::FileView;
1674    #[cfg(feature = "views")]
1675    #[doc(inline)]
1676    pub use super::__buffa::view::code_generator_response::FileOwnedView;
1677}
buffa_descriptor/generated/google.protobuf.compiler.plugin.rs

buffa_descriptor/generated/
google.protobuf.compiler.plugin.rs
