buffa-descriptor 0.8.1

// @generated by buffa-codegen. DO NOT EDIT.
// source: google/protobuf/compiler/plugin.proto

/// The version number of protocol compiler.
#[derive(Clone, Debug, Default)]
pub struct VersionView<'a> {
    /// Field 1: `major`
    pub major: ::core::option::Option<i32>,
    /// Field 2: `minor`
    pub minor: ::core::option::Option<i32>,
    /// Field 3: `patch`
    pub patch: ::core::option::Option<i32>,
    /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
    /// be empty for mainline stable releases.
    ///
    /// Field 4: `suffix`
    pub suffix: ::core::option::Option<&'a str>,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for VersionView<'a> {
    type Owned = super::super::Version;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.major = Some(::buffa::types::decode_int32(&mut cur)?);
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.minor = Some(::buffa::types::decode_int32(&mut cur)?);
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.patch = Some(::buffa::types::decode_int32(&mut cur)?);
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.suffix = Some(::buffa::types::borrow_str(&mut cur)?);
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<super::super::Version, ::buffa::DecodeError> {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<super::super::Version, ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::Version {
            major: self.major,
            minor: self.minor,
            patch: self.patch,
            suffix: self.suffix.map(|s| s.to_string()),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for VersionView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if let Some(v) = self.major {
            size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
        }
        if let Some(v) = self.minor {
            size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
        }
        if let Some(v) = self.patch {
            size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
        }
        if let Some(ref v) = self.suffix {
            size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(v) = self.major {
            ::buffa::types::put_int32_field(1u32, v, buf);
        }
        if let Some(v) = self.minor {
            ::buffa::types::put_int32_field(2u32, v, buf);
        }
        if let Some(v) = self.patch {
            ::buffa::types::put_int32_field(3u32, v, buf);
        }
        if let Some(ref v) = self.suffix {
            ::buffa::types::put_string_field(4u32, v, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
#[cfg(feature = "json")]
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for VersionView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if let ::core::option::Option::Some(__v) = self.major {
            __map.serialize_entry("major", &::buffa::json_helpers::ProtoJson(&__v))?;
        }
        if let ::core::option::Option::Some(__v) = self.minor {
            __map.serialize_entry("minor", &::buffa::json_helpers::ProtoJson(&__v))?;
        }
        if let ::core::option::Option::Some(__v) = self.patch {
            __map.serialize_entry("patch", &::buffa::json_helpers::ProtoJson(&__v))?;
        }
        if let ::core::option::Option::Some(__v) = self.suffix {
            __map.serialize_entry("suffix", __v)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for VersionView<'a> {
    const PACKAGE: &'static str = "google.protobuf.compiler";
    const NAME: &'static str = "Version";
    const FULL_NAME: &'static str = "google.protobuf.compiler.Version";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.compiler.Version";
}
::buffa::impl_default_view_instance!(VersionView);
::buffa::impl_view_reborrow!(VersionView);
/** Self-contained, `'static` owned view of a `Version` message.

 Wraps [`::buffa::OwnedView`]`<`[`VersionView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`VersionView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct VersionOwnedView(::buffa::OwnedView<VersionView<'static>>);
impl VersionOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(VersionOwnedView(::buffa::OwnedView::decode(bytes)?))
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            VersionOwnedView(::buffa::OwnedView::decode_with_options(bytes, opts)?),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::Version,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            VersionOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`VersionView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &VersionView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// # Errors
    ///
    /// Returns an error if re-materializing preserved unknown fields
    /// fails (e.g. the unknown-field limit is exceeded).
    pub fn to_owned_message(
        &self,
    ) -> ::core::result::Result<super::super::Version, ::buffa::DecodeError> {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Field 1: `major`
    #[must_use]
    pub fn major(&self) -> ::core::option::Option<i32> {
        self.0.reborrow().major
    }
    /// Field 2: `minor`
    #[must_use]
    pub fn minor(&self) -> ::core::option::Option<i32> {
        self.0.reborrow().minor
    }
    /// Field 3: `patch`
    #[must_use]
    pub fn patch(&self) -> ::core::option::Option<i32> {
        self.0.reborrow().patch
    }
    /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
    /// be empty for mainline stable releases.
    ///
    /// Field 4: `suffix`
    #[must_use]
    pub fn suffix(&self) -> ::core::option::Option<&'_ str> {
        self.0.reborrow().suffix
    }
}
impl ::core::convert::From<::buffa::OwnedView<VersionView<'static>>>
for VersionOwnedView {
    fn from(inner: ::buffa::OwnedView<VersionView<'static>>) -> Self {
        VersionOwnedView(inner)
    }
}
impl ::core::convert::From<VersionOwnedView>
for ::buffa::OwnedView<VersionView<'static>> {
    fn from(wrapper: VersionOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<VersionView<'static>>>
for VersionOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<VersionView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::Version {
    type View<'a> = VersionView<'a>;
    type ViewHandle = VersionOwnedView;
}
#[cfg(feature = "json")]
impl ::serde::Serialize for VersionOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// An encoded CodeGeneratorRequest is written to the plugin's stdin.
#[derive(Clone, Debug, Default)]
pub struct CodeGeneratorRequestView<'a> {
    /// The .proto files that were explicitly listed on the command-line.  The
    /// code generator should generate code only for these files.  Each file's
    /// descriptor will be included in proto_file, below.
    ///
    /// Field 1: `file_to_generate`
    pub file_to_generate: ::buffa::RepeatedView<'a, &'a str>,
    /// The generator parameter passed on the command-line.
    ///
    /// Field 2: `parameter`
    pub parameter: ::core::option::Option<&'a str>,
    /// FileDescriptorProtos for all files in files_to_generate and everything
    /// they import.  The files will appear in topological order, so each file
    /// appears before any file that imports it.
    ///
    /// Note: the files listed in files_to_generate will include runtime-retention
    /// options only, but all other files will include source-retention options.
    /// The source_file_descriptors field below is available in case you need
    /// source-retention options for files_to_generate.
    ///
    /// protoc guarantees that all proto_files will be written after
    /// the fields above, even though this is not technically guaranteed by the
    /// protobuf wire format.  This theoretically could allow a plugin to stream
    /// in the FileDescriptorProtos and handle them one by one rather than read
    /// the entire set into memory at once.  However, as of this writing, this
    /// is not similarly optimized on protoc's end -- it will store all fields in
    /// memory at once before sending them to the plugin.
    ///
    /// Type names of fields and extensions in the FileDescriptorProto are always
    /// fully qualified.
    ///
    /// Field 15: `proto_file`
    pub proto_file: ::buffa::RepeatedView<
        'a,
        super::super::super::__buffa::view::FileDescriptorProtoView<'a>,
    >,
    /// File descriptors with all options, including source-retention options.
    /// These descriptors are only provided for the files listed in
    /// files_to_generate.
    ///
    /// Field 17: `source_file_descriptors`
    pub source_file_descriptors: ::buffa::RepeatedView<
        'a,
        super::super::super::__buffa::view::FileDescriptorProtoView<'a>,
    >,
    /// The version number of protocol compiler.
    ///
    /// Field 3: `compiler_version`
    pub compiler_version: ::buffa::MessageFieldView<
        super::super::__buffa::view::VersionView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodeGeneratorRequestView<'a> {
    type Owned = super::super::CodeGeneratorRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.parameter = Some(::buffa::types::borrow_str(&mut cur)?);
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                match view.compiler_version.as_mut() {
                    Some(existing) => {
                        ::buffa::MessageView::merge_into_view(existing, sub, __sub_ctx)?
                    }
                    None => {
                        view.compiler_version = ::buffa::MessageFieldView::set(
                            <super::super::__buffa::view::VersionView as ::buffa::MessageView>::decode_view_ctx(
                                sub,
                                __sub_ctx,
                            )?,
                        );
                    }
                }
            }
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.file_to_generate.push(::buffa::types::borrow_str(&mut cur)?);
            }
            15u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                view.proto_file
                    .push(
                        <super::super::super::__buffa::view::FileDescriptorProtoView as ::buffa::MessageView>::decode_view_ctx(
                            sub,
                            __sub_ctx,
                        )?,
                    );
            }
            17u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                view.source_file_descriptors
                    .push(
                        <super::super::super::__buffa::view::FileDescriptorProtoView as ::buffa::MessageView>::decode_view_ctx(
                            sub,
                            __sub_ctx,
                        )?,
                    );
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodeGeneratorRequest,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodeGeneratorRequest,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodeGeneratorRequest {
            file_to_generate: self
                .file_to_generate
                .iter()
                .map(|s| s.to_string())
                .collect(),
            parameter: self.parameter.map(|s| s.to_string()),
            proto_file: self
                .proto_file
                .iter()
                .map(|v| v.to_owned_from_source(__buffa_src))
                .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
            source_file_descriptors: self
                .source_file_descriptors
                .iter()
                .map(|v| v.to_owned_from_source(__buffa_src))
                .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
            compiler_version: match self.compiler_version.as_option() {
                Some(v) => {
                    ::buffa::MessageField::<
                        super::super::Version,
                    >::some(v.to_owned_from_source(__buffa_src)?)
                }
                None => ::buffa::MessageField::none(),
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodeGeneratorRequestView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        for v in &self.file_to_generate {
            size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
        }
        if let Some(ref v) = self.parameter {
            size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
        }
        if self.compiler_version.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.compiler_version.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        for v in &self.proto_file {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        for v in &self.source_file_descriptors {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.file_to_generate {
            ::buffa::types::put_string_field(1u32, v, buf);
        }
        if let Some(ref v) = self.parameter {
            ::buffa::types::put_string_field(2u32, v, buf);
        }
        if self.compiler_version.is_set() {
            ::buffa::types::put_len_delimited_header(3u32, __cache.consume_next(), buf);
            self.compiler_version.write_to(__cache, buf);
        }
        for v in &self.proto_file {
            ::buffa::types::put_len_delimited_header(15u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        for v in &self.source_file_descriptors {
            ::buffa::types::put_len_delimited_header(17u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
#[cfg(feature = "json")]
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodeGeneratorRequestView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !self.file_to_generate.is_empty() {
            __map.serialize_entry("fileToGenerate", &*self.file_to_generate)?;
        }
        if let ::core::option::Option::Some(__v) = self.parameter {
            __map.serialize_entry("parameter", __v)?;
        }
        if !self.proto_file.is_empty() {
            __map.serialize_entry("protoFile", &*self.proto_file)?;
        }
        if !self.source_file_descriptors.is_empty() {
            __map
                .serialize_entry(
                    "sourceFileDescriptors",
                    &*self.source_file_descriptors,
                )?;
        }
        {
            if let ::core::option::Option::Some(__v) = self.compiler_version.as_option()
            {
                __map.serialize_entry("compilerVersion", __v)?;
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodeGeneratorRequestView<'a> {
    const PACKAGE: &'static str = "google.protobuf.compiler";
    const NAME: &'static str = "CodeGeneratorRequest";
    const FULL_NAME: &'static str = "google.protobuf.compiler.CodeGeneratorRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.compiler.CodeGeneratorRequest";
}
::buffa::impl_default_view_instance!(CodeGeneratorRequestView);
::buffa::impl_view_reborrow!(CodeGeneratorRequestView);
/** Self-contained, `'static` owned view of a `CodeGeneratorRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodeGeneratorRequestView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodeGeneratorRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodeGeneratorRequestOwnedView(
    ::buffa::OwnedView<CodeGeneratorRequestView<'static>>,
);
impl CodeGeneratorRequestOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodeGeneratorRequestOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodeGeneratorRequestOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodeGeneratorRequest,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodeGeneratorRequestOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodeGeneratorRequestView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodeGeneratorRequestView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// # Errors
    ///
    /// Returns an error if re-materializing preserved unknown fields
    /// fails (e.g. the unknown-field limit is exceeded).
    pub fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodeGeneratorRequest,
        ::buffa::DecodeError,
    > {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// The .proto files that were explicitly listed on the command-line.  The
    /// code generator should generate code only for these files.  Each file's
    /// descriptor will be included in proto_file, below.
    ///
    /// Field 1: `file_to_generate`
    #[must_use]
    pub fn file_to_generate(&self) -> &::buffa::RepeatedView<'_, &'_ str> {
        &self.0.reborrow().file_to_generate
    }
    /// The generator parameter passed on the command-line.
    ///
    /// Field 2: `parameter`
    #[must_use]
    pub fn parameter(&self) -> ::core::option::Option<&'_ str> {
        self.0.reborrow().parameter
    }
    /// FileDescriptorProtos for all files in files_to_generate and everything
    /// they import.  The files will appear in topological order, so each file
    /// appears before any file that imports it.
    ///
    /// Note: the files listed in files_to_generate will include runtime-retention
    /// options only, but all other files will include source-retention options.
    /// The source_file_descriptors field below is available in case you need
    /// source-retention options for files_to_generate.
    ///
    /// protoc guarantees that all proto_files will be written after
    /// the fields above, even though this is not technically guaranteed by the
    /// protobuf wire format.  This theoretically could allow a plugin to stream
    /// in the FileDescriptorProtos and handle them one by one rather than read
    /// the entire set into memory at once.  However, as of this writing, this
    /// is not similarly optimized on protoc's end -- it will store all fields in
    /// memory at once before sending them to the plugin.
    ///
    /// Type names of fields and extensions in the FileDescriptorProto are always
    /// fully qualified.
    ///
    /// Field 15: `proto_file`
    #[must_use]
    pub fn proto_file(
        &self,
    ) -> &::buffa::RepeatedView<
        '_,
        super::super::super::__buffa::view::FileDescriptorProtoView<'_>,
    > {
        &self.0.reborrow().proto_file
    }
    /// File descriptors with all options, including source-retention options.
    /// These descriptors are only provided for the files listed in
    /// files_to_generate.
    ///
    /// Field 17: `source_file_descriptors`
    #[must_use]
    pub fn source_file_descriptors(
        &self,
    ) -> &::buffa::RepeatedView<
        '_,
        super::super::super::__buffa::view::FileDescriptorProtoView<'_>,
    > {
        &self.0.reborrow().source_file_descriptors
    }
    /// The version number of protocol compiler.
    ///
    /// Field 3: `compiler_version`
    #[must_use]
    pub fn compiler_version(
        &self,
    ) -> &::buffa::MessageFieldView<super::super::__buffa::view::VersionView<'_>> {
        &self.0.reborrow().compiler_version
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodeGeneratorRequestView<'static>>>
for CodeGeneratorRequestOwnedView {
    fn from(inner: ::buffa::OwnedView<CodeGeneratorRequestView<'static>>) -> Self {
        CodeGeneratorRequestOwnedView(inner)
    }
}
impl ::core::convert::From<CodeGeneratorRequestOwnedView>
for ::buffa::OwnedView<CodeGeneratorRequestView<'static>> {
    fn from(wrapper: CodeGeneratorRequestOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodeGeneratorRequestView<'static>>>
for CodeGeneratorRequestOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodeGeneratorRequestView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodeGeneratorRequest {
    type View<'a> = CodeGeneratorRequestView<'a>;
    type ViewHandle = CodeGeneratorRequestOwnedView;
}
#[cfg(feature = "json")]
impl ::serde::Serialize for CodeGeneratorRequestOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// The plugin writes an encoded CodeGeneratorResponse to stdout.
#[derive(Clone, Debug, Default)]
pub struct CodeGeneratorResponseView<'a> {
    /// Error message.  If non-empty, code generation failed.  The plugin process
    /// should exit with status code zero even if it reports an error in this way.
    ///
    /// This should be used to indicate errors in .proto files which prevent the
    /// code generator from generating correct code.  Errors which indicate a
    /// problem in protoc itself -- such as the input CodeGeneratorRequest being
    /// unparseable -- should be reported by writing a message to stderr and
    /// exiting with a non-zero status code.
    ///
    /// Field 1: `error`
    pub error: ::core::option::Option<&'a str>,
    /// A bitmask of supported features that the code generator supports.
    /// This is a bitwise "or" of values from the Feature enum.
    ///
    /// Field 2: `supported_features`
    pub supported_features: ::core::option::Option<u64>,
    /// The minimum edition this plugin supports.  This will be treated as an
    /// Edition enum, but we want to allow unknown values.  It should be specified
    /// according the edition enum value, *not* the edition number.  Only takes
    /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.
    ///
    /// Field 3: `minimum_edition`
    pub minimum_edition: ::core::option::Option<i32>,
    /// The maximum edition this plugin supports.  This will be treated as an
    /// Edition enum, but we want to allow unknown values.  It should be specified
    /// according the edition enum value, *not* the edition number.  Only takes
    /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.
    ///
    /// Field 4: `maximum_edition`
    pub maximum_edition: ::core::option::Option<i32>,
    /// Field 15: `file`
    pub file: ::buffa::RepeatedView<
        'a,
        super::super::__buffa::view::code_generator_response::FileView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodeGeneratorResponseView<'a> {
    type Owned = super::super::CodeGeneratorResponse;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.error = Some(::buffa::types::borrow_str(&mut cur)?);
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.supported_features = Some(::buffa::types::decode_uint64(&mut cur)?);
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.minimum_edition = Some(::buffa::types::decode_int32(&mut cur)?);
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.maximum_edition = Some(::buffa::types::decode_int32(&mut cur)?);
            }
            15u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                view.file
                    .push(
                        <super::super::__buffa::view::code_generator_response::FileView as ::buffa::MessageView>::decode_view_ctx(
                            sub,
                            __sub_ctx,
                        )?,
                    );
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodeGeneratorResponse,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodeGeneratorResponse,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodeGeneratorResponse {
            error: self.error.map(|s| s.to_string()),
            supported_features: self.supported_features,
            minimum_edition: self.minimum_edition,
            maximum_edition: self.maximum_edition,
            file: self
                .file
                .iter()
                .map(|v| v.to_owned_from_source(__buffa_src))
                .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodeGeneratorResponseView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if let Some(ref v) = self.error {
            size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
        }
        if let Some(v) = self.supported_features {
            size += 1u32 + ::buffa::types::uint64_encoded_len(v) as u32;
        }
        if let Some(v) = self.minimum_edition {
            size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
        }
        if let Some(v) = self.maximum_edition {
            size += 1u32 + ::buffa::types::int32_encoded_len(v) as u32;
        }
        for v in &self.file {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(ref v) = self.error {
            ::buffa::types::put_string_field(1u32, v, buf);
        }
        if let Some(v) = self.supported_features {
            ::buffa::types::put_uint64_field(2u32, v, buf);
        }
        if let Some(v) = self.minimum_edition {
            ::buffa::types::put_int32_field(3u32, v, buf);
        }
        if let Some(v) = self.maximum_edition {
            ::buffa::types::put_int32_field(4u32, v, buf);
        }
        for v in &self.file {
            ::buffa::types::put_len_delimited_header(15u32, __cache.consume_next(), buf);
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
#[cfg(feature = "json")]
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodeGeneratorResponseView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if let ::core::option::Option::Some(__v) = self.error {
            __map.serialize_entry("error", __v)?;
        }
        if let ::core::option::Option::Some(__v) = self.supported_features {
            __map
                .serialize_entry(
                    "supportedFeatures",
                    &::buffa::json_helpers::ProtoJson(&__v),
                )?;
        }
        if let ::core::option::Option::Some(__v) = self.minimum_edition {
            __map
                .serialize_entry(
                    "minimumEdition",
                    &::buffa::json_helpers::ProtoJson(&__v),
                )?;
        }
        if let ::core::option::Option::Some(__v) = self.maximum_edition {
            __map
                .serialize_entry(
                    "maximumEdition",
                    &::buffa::json_helpers::ProtoJson(&__v),
                )?;
        }
        if !self.file.is_empty() {
            __map.serialize_entry("file", &*self.file)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodeGeneratorResponseView<'a> {
    const PACKAGE: &'static str = "google.protobuf.compiler";
    const NAME: &'static str = "CodeGeneratorResponse";
    const FULL_NAME: &'static str = "google.protobuf.compiler.CodeGeneratorResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.compiler.CodeGeneratorResponse";
}
::buffa::impl_default_view_instance!(CodeGeneratorResponseView);
::buffa::impl_view_reborrow!(CodeGeneratorResponseView);
/** Self-contained, `'static` owned view of a `CodeGeneratorResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodeGeneratorResponseView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodeGeneratorResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodeGeneratorResponseOwnedView(
    ::buffa::OwnedView<CodeGeneratorResponseView<'static>>,
);
impl CodeGeneratorResponseOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodeGeneratorResponseOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodeGeneratorResponseOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodeGeneratorResponse,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodeGeneratorResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodeGeneratorResponseView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodeGeneratorResponseView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// # Errors
    ///
    /// Returns an error if re-materializing preserved unknown fields
    /// fails (e.g. the unknown-field limit is exceeded).
    pub fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodeGeneratorResponse,
        ::buffa::DecodeError,
    > {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Error message.  If non-empty, code generation failed.  The plugin process
    /// should exit with status code zero even if it reports an error in this way.
    ///
    /// This should be used to indicate errors in .proto files which prevent the
    /// code generator from generating correct code.  Errors which indicate a
    /// problem in protoc itself -- such as the input CodeGeneratorRequest being
    /// unparseable -- should be reported by writing a message to stderr and
    /// exiting with a non-zero status code.
    ///
    /// Field 1: `error`
    #[must_use]
    pub fn error(&self) -> ::core::option::Option<&'_ str> {
        self.0.reborrow().error
    }
    /// A bitmask of supported features that the code generator supports.
    /// This is a bitwise "or" of values from the Feature enum.
    ///
    /// Field 2: `supported_features`
    #[must_use]
    pub fn supported_features(&self) -> ::core::option::Option<u64> {
        self.0.reborrow().supported_features
    }
    /// The minimum edition this plugin supports.  This will be treated as an
    /// Edition enum, but we want to allow unknown values.  It should be specified
    /// according the edition enum value, *not* the edition number.  Only takes
    /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.
    ///
    /// Field 3: `minimum_edition`
    #[must_use]
    pub fn minimum_edition(&self) -> ::core::option::Option<i32> {
        self.0.reborrow().minimum_edition
    }
    /// The maximum edition this plugin supports.  This will be treated as an
    /// Edition enum, but we want to allow unknown values.  It should be specified
    /// according the edition enum value, *not* the edition number.  Only takes
    /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set.
    ///
    /// Field 4: `maximum_edition`
    #[must_use]
    pub fn maximum_edition(&self) -> ::core::option::Option<i32> {
        self.0.reborrow().maximum_edition
    }
    /// Field 15: `file`
    #[must_use]
    pub fn file(
        &self,
    ) -> &::buffa::RepeatedView<
        '_,
        super::super::__buffa::view::code_generator_response::FileView<'_>,
    > {
        &self.0.reborrow().file
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodeGeneratorResponseView<'static>>>
for CodeGeneratorResponseOwnedView {
    fn from(inner: ::buffa::OwnedView<CodeGeneratorResponseView<'static>>) -> Self {
        CodeGeneratorResponseOwnedView(inner)
    }
}
impl ::core::convert::From<CodeGeneratorResponseOwnedView>
for ::buffa::OwnedView<CodeGeneratorResponseView<'static>> {
    fn from(wrapper: CodeGeneratorResponseOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodeGeneratorResponseView<'static>>>
for CodeGeneratorResponseOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodeGeneratorResponseView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodeGeneratorResponse {
    type View<'a> = CodeGeneratorResponseView<'a>;
    type ViewHandle = CodeGeneratorResponseOwnedView;
}
#[cfg(feature = "json")]
impl ::serde::Serialize for CodeGeneratorResponseOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
pub mod code_generator_response {
    #[allow(unused_imports)]
    use super::*;
    /// Represents a single generated file.
    #[derive(Clone, Debug, Default)]
    pub struct FileView<'a> {
        /// The file name, relative to the output directory.  The name must not
        /// contain "." or ".." components and must be relative, not be absolute (so,
        /// the file cannot lie outside the output directory).  "/" must be used as
        /// the path separator, not "\".
        ///
        /// If the name is omitted, the content will be appended to the previous
        /// file.  This allows the generator to break large files into small chunks,
        /// and allows the generated text to be streamed back to protoc so that large
        /// files need not reside completely in memory at one time.  Note that as of
        /// this writing protoc does not optimize for this -- it will read the entire
        /// CodeGeneratorResponse before writing files to disk.
        ///
        /// Field 1: `name`
        pub name: ::core::option::Option<&'a str>,
        /// If non-empty, indicates that the named file should already exist, and the
        /// content here is to be inserted into that file at a defined insertion
        /// point.  This feature allows a code generator to extend the output
        /// produced by another code generator.  The original generator may provide
        /// insertion points by placing special annotations in the file that look
        /// like:
        ///   @@protoc_insertion_point(NAME)
        /// The annotation can have arbitrary text before and after it on the line,
        /// which allows it to be placed in a comment.  NAME should be replaced with
        /// an identifier naming the point -- this is what other generators will use
        /// as the insertion_point.  Code inserted at this point will be placed
        /// immediately above the line containing the insertion point (thus multiple
        /// insertions to the same point will come out in the order they were added).
        /// The double-@ is intended to make it unlikely that the generated code
        /// could contain things that look like insertion points by accident.
        ///
        /// For example, the C++ code generator places the following line in the
        /// .pb.h files that it generates:
        ///   // @@protoc_insertion_point(namespace_scope)
        /// This line appears within the scope of the file's package namespace, but
        /// outside of any particular class.  Another plugin can then specify the
        /// insertion_point "namespace_scope" to generate additional classes or
        /// other declarations that should be placed in this scope.
        ///
        /// Note that if the line containing the insertion point begins with
        /// whitespace, the same whitespace will be added to every line of the
        /// inserted text.  This is useful for languages like Python, where
        /// indentation matters.  In these languages, the insertion point comment
        /// should be indented the same amount as any inserted code will need to be
        /// in order to work correctly in that context.
        ///
        /// The code generator that generates the initial file and the one which
        /// inserts into it must both run as part of a single invocation of protoc.
        /// Code generators are executed in the order in which they appear on the
        /// command line.
        ///
        /// If |insertion_point| is present, |name| must also be present.
        ///
        /// Field 2: `insertion_point`
        pub insertion_point: ::core::option::Option<&'a str>,
        /// The file contents.
        ///
        /// Field 15: `content`
        pub content: ::core::option::Option<&'a str>,
        /// Information describing the file content being inserted. If an insertion
        /// point is used, this information will be appropriately offset and inserted
        /// into the code generation metadata for the generated files.
        ///
        /// Field 16: `generated_code_info`
        pub generated_code_info: ::buffa::MessageFieldView<
            super::super::super::super::__buffa::view::GeneratedCodeInfoView<'a>,
        >,
        pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
    }
    impl<'a> ::buffa::MessageView<'a> for FileView<'a> {
        type Owned = super::super::super::code_generator_response::File;
        fn decode_view(
            buf: &'a [u8],
        ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
            let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
            <Self as ::buffa::MessageView>::decode_view_ctx(
                buf,
                ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit),
            )
        }
        fn decode_view_with_ctx(
            buf: &'a [u8],
            ctx: ::buffa::DecodeContext<'_>,
        ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
            <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
        }
        fn merge_view_field(
            &mut self,
            tag: ::buffa::encoding::Tag,
            cur: &'a [u8],
            before_tag: &'a [u8],
            ctx: ::buffa::DecodeContext<'_>,
        ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
            let _ = ctx;
            #[allow(unused_variables)]
            let view = self;
            let mut cur = cur;
            match tag.field_number() {
                1u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    view.name = Some(::buffa::types::borrow_str(&mut cur)?);
                }
                2u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    view.insertion_point = Some(::buffa::types::borrow_str(&mut cur)?);
                }
                15u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    view.content = Some(::buffa::types::borrow_str(&mut cur)?);
                }
                16u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    let __sub_ctx = ctx.descend()?;
                    let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                    match view.generated_code_info.as_mut() {
                        Some(existing) => {
                            ::buffa::MessageView::merge_into_view(
                                existing,
                                sub,
                                __sub_ctx,
                            )?
                        }
                        None => {
                            view.generated_code_info = ::buffa::MessageFieldView::set(
                                <super::super::super::super::__buffa::view::GeneratedCodeInfoView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            );
                        }
                    }
                }
                _ => {
                    ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                    let span_len = before_tag.len() - cur.len();
                    view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
                }
            }
            ::core::result::Result::Ok(cur)
        }
        fn to_owned_message(
            &self,
        ) -> ::core::result::Result<
            super::super::super::code_generator_response::File,
            ::buffa::DecodeError,
        > {
            self.to_owned_from_source(None)
        }
        #[allow(clippy::useless_conversion, clippy::needless_update)]
        fn to_owned_from_source(
            &self,
            __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
        ) -> ::core::result::Result<
            super::super::super::code_generator_response::File,
            ::buffa::DecodeError,
        > {
            #[allow(unused_imports)]
            use ::buffa::alloc::string::ToString as _;
            let _ = __buffa_src;
            ::core::result::Result::Ok(super::super::super::code_generator_response::File {
                name: self.name.map(|s| s.to_string()),
                insertion_point: self.insertion_point.map(|s| s.to_string()),
                content: self.content.map(|s| s.to_string()),
                generated_code_info: match self.generated_code_info.as_option() {
                    Some(v) => {
                        ::buffa::MessageField::<
                            super::super::super::super::GeneratedCodeInfo,
                        >::some(v.to_owned_from_source(__buffa_src)?)
                    }
                    None => ::buffa::MessageField::none(),
                },
                __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
                ..::core::default::Default::default()
            })
        }
    }
    impl<'a> ::buffa::ViewEncode<'a> for FileView<'a> {
        #[allow(clippy::needless_borrow, clippy::let_and_return)]
        fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            let mut size = 0u32;
            if let Some(ref v) = self.name {
                size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
            }
            if let Some(ref v) = self.insertion_point {
                size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
            }
            if let Some(ref v) = self.content {
                size += 1u32 + ::buffa::types::string_encoded_len(v) as u32;
            }
            if self.generated_code_info.is_set() {
                let __slot = __cache.reserve();
                let inner_size = self.generated_code_info.compute_size(__cache);
                __cache.set(__slot, inner_size);
                size
                    += 2u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                        + inner_size;
            }
            size += self.__buffa_unknown_fields.encoded_len() as u32;
            size
        }
        #[allow(clippy::needless_borrow)]
        fn write_to(
            &self,
            __cache: &mut ::buffa::SizeCache,
            buf: &mut impl ::buffa::bytes::BufMut,
        ) {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let Some(ref v) = self.name {
                ::buffa::types::put_string_field(1u32, v, buf);
            }
            if let Some(ref v) = self.insertion_point {
                ::buffa::types::put_string_field(2u32, v, buf);
            }
            if let Some(ref v) = self.content {
                ::buffa::types::put_string_field(15u32, v, buf);
            }
            if self.generated_code_info.is_set() {
                ::buffa::types::put_len_delimited_header(
                    16u32,
                    __cache.consume_next(),
                    buf,
                );
                self.generated_code_info.write_to(__cache, buf);
            }
            self.__buffa_unknown_fields.write_to(buf);
        }
    }
    #[cfg(feature = "json")]
    /// Serializes this view as protobuf JSON.
    ///
    /// Implicit-presence fields with default values are omitted, `required`
    /// fields are always emitted, explicit-presence (`optional`) fields are
    /// emitted only when set, bytes fields are base64-encoded, and enum
    /// values are their proto name strings.
    ///
    /// This impl uses `serialize_map(None)` because the number of emitted
    /// fields depends on default-omission rules; serializers that require
    /// known map lengths (e.g. `bincode`) will return a runtime error.
    /// Use the owned message type for those formats.
    impl<'__a> ::serde::Serialize for FileView<'__a> {
        fn serialize<__S: ::serde::Serializer>(
            &self,
            __s: __S,
        ) -> ::core::result::Result<__S::Ok, __S::Error> {
            use ::serde::ser::SerializeMap as _;
            let mut __map = __s.serialize_map(::core::option::Option::None)?;
            if let ::core::option::Option::Some(__v) = self.name {
                __map.serialize_entry("name", __v)?;
            }
            if let ::core::option::Option::Some(__v) = self.insertion_point {
                __map.serialize_entry("insertionPoint", __v)?;
            }
            if let ::core::option::Option::Some(__v) = self.content {
                __map.serialize_entry("content", __v)?;
            }
            {
                if let ::core::option::Option::Some(__v) = self
                    .generated_code_info
                    .as_option()
                {
                    __map.serialize_entry("generatedCodeInfo", __v)?;
                }
            }
            __map.end()
        }
    }
    impl<'a> ::buffa::MessageName for FileView<'a> {
        const PACKAGE: &'static str = "google.protobuf.compiler";
        const NAME: &'static str = "CodeGeneratorResponse.File";
        const FULL_NAME: &'static str = "google.protobuf.compiler.CodeGeneratorResponse.File";
        const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.compiler.CodeGeneratorResponse.File";
    }
    ::buffa::impl_default_view_instance!(FileView);
    ::buffa::impl_view_reborrow!(FileView);
    /** Self-contained, `'static` owned view of a `File` message.

 Wraps [`::buffa::OwnedView`]`<`[`FileView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`FileView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
    #[derive(Clone, Debug)]
    pub struct FileOwnedView(::buffa::OwnedView<FileView<'static>>);
    impl FileOwnedView {
        /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
        ///
        /// The view borrows directly from the buffer's data; the buffer is
        /// retained inside the returned handle.
        ///
        /// # Errors
        ///
        /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
        /// protobuf data.
        pub fn decode(
            bytes: ::buffa::bytes::Bytes,
        ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
            ::core::result::Result::Ok(FileOwnedView(::buffa::OwnedView::decode(bytes)?))
        }
        /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
        /// max message size).
        ///
        /// # Errors
        ///
        /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
        /// exceeds the configured limits.
        pub fn decode_with_options(
            bytes: ::buffa::bytes::Bytes,
            opts: &::buffa::DecodeOptions,
        ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
            ::core::result::Result::Ok(
                FileOwnedView(::buffa::OwnedView::decode_with_options(bytes, opts)?),
            )
        }
        /// Build from an owned message via an encode → decode round-trip.
        ///
        /// # Errors
        ///
        /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
        /// somehow invalid (should not happen for well-formed messages).
        pub fn from_owned(
            msg: &super::super::super::code_generator_response::File,
        ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
            ::core::result::Result::Ok(
                FileOwnedView(::buffa::OwnedView::from_owned(msg)?),
            )
        }
        /// Borrow the full [`FileView`] with its lifetime tied to `&self`.
        #[must_use]
        pub fn view(&self) -> &FileView<'_> {
            self.0.reborrow()
        }
        /// Convert to the owned message type.
        ///
        /// # Errors
        ///
        /// Returns an error if re-materializing preserved unknown fields
        /// fails (e.g. the unknown-field limit is exceeded).
        pub fn to_owned_message(
            &self,
        ) -> ::core::result::Result<
            super::super::super::code_generator_response::File,
            ::buffa::DecodeError,
        > {
            self.0.to_owned_message()
        }
        /// The underlying bytes buffer.
        #[must_use]
        pub fn bytes(&self) -> &::buffa::bytes::Bytes {
            self.0.bytes()
        }
        /// Consume the handle, returning the underlying bytes buffer.
        #[must_use]
        pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
            self.0.into_bytes()
        }
        /// The file name, relative to the output directory.  The name must not
        /// contain "." or ".." components and must be relative, not be absolute (so,
        /// the file cannot lie outside the output directory).  "/" must be used as
        /// the path separator, not "\".
        ///
        /// If the name is omitted, the content will be appended to the previous
        /// file.  This allows the generator to break large files into small chunks,
        /// and allows the generated text to be streamed back to protoc so that large
        /// files need not reside completely in memory at one time.  Note that as of
        /// this writing protoc does not optimize for this -- it will read the entire
        /// CodeGeneratorResponse before writing files to disk.
        ///
        /// Field 1: `name`
        #[must_use]
        pub fn name(&self) -> ::core::option::Option<&'_ str> {
            self.0.reborrow().name
        }
        /// If non-empty, indicates that the named file should already exist, and the
        /// content here is to be inserted into that file at a defined insertion
        /// point.  This feature allows a code generator to extend the output
        /// produced by another code generator.  The original generator may provide
        /// insertion points by placing special annotations in the file that look
        /// like:
        ///   @@protoc_insertion_point(NAME)
        /// The annotation can have arbitrary text before and after it on the line,
        /// which allows it to be placed in a comment.  NAME should be replaced with
        /// an identifier naming the point -- this is what other generators will use
        /// as the insertion_point.  Code inserted at this point will be placed
        /// immediately above the line containing the insertion point (thus multiple
        /// insertions to the same point will come out in the order they were added).
        /// The double-@ is intended to make it unlikely that the generated code
        /// could contain things that look like insertion points by accident.
        ///
        /// For example, the C++ code generator places the following line in the
        /// .pb.h files that it generates:
        ///   // @@protoc_insertion_point(namespace_scope)
        /// This line appears within the scope of the file's package namespace, but
        /// outside of any particular class.  Another plugin can then specify the
        /// insertion_point "namespace_scope" to generate additional classes or
        /// other declarations that should be placed in this scope.
        ///
        /// Note that if the line containing the insertion point begins with
        /// whitespace, the same whitespace will be added to every line of the
        /// inserted text.  This is useful for languages like Python, where
        /// indentation matters.  In these languages, the insertion point comment
        /// should be indented the same amount as any inserted code will need to be
        /// in order to work correctly in that context.
        ///
        /// The code generator that generates the initial file and the one which
        /// inserts into it must both run as part of a single invocation of protoc.
        /// Code generators are executed in the order in which they appear on the
        /// command line.
        ///
        /// If |insertion_point| is present, |name| must also be present.
        ///
        /// Field 2: `insertion_point`
        #[must_use]
        pub fn insertion_point(&self) -> ::core::option::Option<&'_ str> {
            self.0.reborrow().insertion_point
        }
        /// The file contents.
        ///
        /// Field 15: `content`
        #[must_use]
        pub fn content(&self) -> ::core::option::Option<&'_ str> {
            self.0.reborrow().content
        }
        /// Information describing the file content being inserted. If an insertion
        /// point is used, this information will be appropriately offset and inserted
        /// into the code generation metadata for the generated files.
        ///
        /// Field 16: `generated_code_info`
        #[must_use]
        pub fn generated_code_info(
            &self,
        ) -> &::buffa::MessageFieldView<
            super::super::super::super::__buffa::view::GeneratedCodeInfoView<'_>,
        > {
            &self.0.reborrow().generated_code_info
        }
    }
    impl ::core::convert::From<::buffa::OwnedView<FileView<'static>>> for FileOwnedView {
        fn from(inner: ::buffa::OwnedView<FileView<'static>>) -> Self {
            FileOwnedView(inner)
        }
    }
    impl ::core::convert::From<FileOwnedView> for ::buffa::OwnedView<FileView<'static>> {
        fn from(wrapper: FileOwnedView) -> Self {
            wrapper.0
        }
    }
    impl ::core::convert::AsRef<::buffa::OwnedView<FileView<'static>>>
    for FileOwnedView {
        fn as_ref(&self) -> &::buffa::OwnedView<FileView<'static>> {
            &self.0
        }
    }
    impl ::buffa::HasMessageView for super::super::super::code_generator_response::File {
        type View<'a> = FileView<'a>;
        type ViewHandle = FileOwnedView;
    }
    #[cfg(feature = "json")]
    impl ::serde::Serialize for FileOwnedView {
        fn serialize<__S: ::serde::Serializer>(
            &self,
            __s: __S,
        ) -> ::core::result::Result<__S::Ok, __S::Error> {
            ::serde::Serialize::serialize(&self.0, __s)
        }
    }
}