metrics/out/event_details.rs

// This file is generated by rust-protobuf 2.27.1. Do not edit
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `event_details.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_27_1;

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct RecordDetails {
    // message fields
    pub emulator_child_process_exit_details: ::protobuf::SingularPtrField<EmulatorChildProcessExitDetails>,
    pub wave_format_details: ::protobuf::SingularPtrField<WaveFormatDetails>,
    pub emulator_dll_details: ::protobuf::SingularPtrField<EmulatorDllDetails>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a RecordDetails {
    fn default() -> &'a RecordDetails {
        <RecordDetails as ::protobuf::Message>::default_instance()
    }
}

impl RecordDetails {
    pub fn new() -> RecordDetails {
        ::std::default::Default::default()
    }

    // optional .EmulatorChildProcessExitDetails emulator_child_process_exit_details = 12;


    pub fn get_emulator_child_process_exit_details(&self) -> &EmulatorChildProcessExitDetails {
        self.emulator_child_process_exit_details.as_ref().unwrap_or_else(|| <EmulatorChildProcessExitDetails as ::protobuf::Message>::default_instance())
    }
    pub fn clear_emulator_child_process_exit_details(&mut self) {
        self.emulator_child_process_exit_details.clear();
    }

    pub fn has_emulator_child_process_exit_details(&self) -> bool {
        self.emulator_child_process_exit_details.is_some()
    }

    // Param is passed by value, moved
    pub fn set_emulator_child_process_exit_details(&mut self, v: EmulatorChildProcessExitDetails) {
        self.emulator_child_process_exit_details = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_emulator_child_process_exit_details(&mut self) -> &mut EmulatorChildProcessExitDetails {
        if self.emulator_child_process_exit_details.is_none() {
            self.emulator_child_process_exit_details.set_default();
        }
        self.emulator_child_process_exit_details.as_mut().unwrap()
    }

    // Take field
    pub fn take_emulator_child_process_exit_details(&mut self) -> EmulatorChildProcessExitDetails {
        self.emulator_child_process_exit_details.take().unwrap_or_else(|| EmulatorChildProcessExitDetails::new())
    }

    // optional .WaveFormatDetails wave_format_details = 13;


    pub fn get_wave_format_details(&self) -> &WaveFormatDetails {
        self.wave_format_details.as_ref().unwrap_or_else(|| <WaveFormatDetails as ::protobuf::Message>::default_instance())
    }
    pub fn clear_wave_format_details(&mut self) {
        self.wave_format_details.clear();
    }

    pub fn has_wave_format_details(&self) -> bool {
        self.wave_format_details.is_some()
    }

    // Param is passed by value, moved
    pub fn set_wave_format_details(&mut self, v: WaveFormatDetails) {
        self.wave_format_details = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_wave_format_details(&mut self) -> &mut WaveFormatDetails {
        if self.wave_format_details.is_none() {
            self.wave_format_details.set_default();
        }
        self.wave_format_details.as_mut().unwrap()
    }

    // Take field
    pub fn take_wave_format_details(&mut self) -> WaveFormatDetails {
        self.wave_format_details.take().unwrap_or_else(|| WaveFormatDetails::new())
    }

    // optional .EmulatorDllDetails emulator_dll_details = 19;


    pub fn get_emulator_dll_details(&self) -> &EmulatorDllDetails {
        self.emulator_dll_details.as_ref().unwrap_or_else(|| <EmulatorDllDetails as ::protobuf::Message>::default_instance())
    }
    pub fn clear_emulator_dll_details(&mut self) {
        self.emulator_dll_details.clear();
    }

    pub fn has_emulator_dll_details(&self) -> bool {
        self.emulator_dll_details.is_some()
    }

    // Param is passed by value, moved
    pub fn set_emulator_dll_details(&mut self, v: EmulatorDllDetails) {
        self.emulator_dll_details = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_emulator_dll_details(&mut self) -> &mut EmulatorDllDetails {
        if self.emulator_dll_details.is_none() {
            self.emulator_dll_details.set_default();
        }
        self.emulator_dll_details.as_mut().unwrap()
    }

    // Take field
    pub fn take_emulator_dll_details(&mut self) -> EmulatorDllDetails {
        self.emulator_dll_details.take().unwrap_or_else(|| EmulatorDllDetails::new())
    }
}

impl ::protobuf::Message for RecordDetails {
    fn is_initialized(&self) -> bool {
        for v in &self.emulator_child_process_exit_details {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.wave_format_details {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.emulator_dll_details {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                12 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.emulator_child_process_exit_details)?;
                },
                13 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.wave_format_details)?;
                },
                19 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.emulator_dll_details)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.emulator_child_process_exit_details.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.wave_format_details.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.emulator_dll_details.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.emulator_child_process_exit_details.as_ref() {
            os.write_tag(12, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.wave_format_details.as_ref() {
            os.write_tag(13, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.emulator_dll_details.as_ref() {
            os.write_tag(19, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> RecordDetails {
        RecordDetails::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EmulatorChildProcessExitDetails>>(
                "emulator_child_process_exit_details",
                |m: &RecordDetails| { &m.emulator_child_process_exit_details },
                |m: &mut RecordDetails| { &mut m.emulator_child_process_exit_details },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<WaveFormatDetails>>(
                "wave_format_details",
                |m: &RecordDetails| { &m.wave_format_details },
                |m: &mut RecordDetails| { &mut m.wave_format_details },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EmulatorDllDetails>>(
                "emulator_dll_details",
                |m: &RecordDetails| { &m.emulator_dll_details },
                |m: &mut RecordDetails| { &mut m.emulator_dll_details },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<RecordDetails>(
                "RecordDetails",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static RecordDetails {
        static instance: ::protobuf::rt::LazyV2<RecordDetails> = ::protobuf::rt::LazyV2::INIT;
        instance.get(RecordDetails::new)
    }
}

impl ::protobuf::Clear for RecordDetails {
    fn clear(&mut self) {
        self.emulator_child_process_exit_details.clear();
        self.wave_format_details.clear();
        self.emulator_dll_details.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for RecordDetails {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for RecordDetails {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct WaveFormatDetails {
    // message fields
    pub requested: ::protobuf::SingularPtrField<WaveFormat>,
    pub modified: ::protobuf::SingularPtrField<WaveFormat>,
    pub closest_matched: ::protobuf::SingularPtrField<WaveFormat>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a WaveFormatDetails {
    fn default() -> &'a WaveFormatDetails {
        <WaveFormatDetails as ::protobuf::Message>::default_instance()
    }
}

impl WaveFormatDetails {
    pub fn new() -> WaveFormatDetails {
        ::std::default::Default::default()
    }

    // optional .WaveFormat requested = 1;


    pub fn get_requested(&self) -> &WaveFormat {
        self.requested.as_ref().unwrap_or_else(|| <WaveFormat as ::protobuf::Message>::default_instance())
    }
    pub fn clear_requested(&mut self) {
        self.requested.clear();
    }

    pub fn has_requested(&self) -> bool {
        self.requested.is_some()
    }

    // Param is passed by value, moved
    pub fn set_requested(&mut self, v: WaveFormat) {
        self.requested = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_requested(&mut self) -> &mut WaveFormat {
        if self.requested.is_none() {
            self.requested.set_default();
        }
        self.requested.as_mut().unwrap()
    }

    // Take field
    pub fn take_requested(&mut self) -> WaveFormat {
        self.requested.take().unwrap_or_else(|| WaveFormat::new())
    }

    // optional .WaveFormat modified = 2;


    pub fn get_modified(&self) -> &WaveFormat {
        self.modified.as_ref().unwrap_or_else(|| <WaveFormat as ::protobuf::Message>::default_instance())
    }
    pub fn clear_modified(&mut self) {
        self.modified.clear();
    }

    pub fn has_modified(&self) -> bool {
        self.modified.is_some()
    }

    // Param is passed by value, moved
    pub fn set_modified(&mut self, v: WaveFormat) {
        self.modified = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_modified(&mut self) -> &mut WaveFormat {
        if self.modified.is_none() {
            self.modified.set_default();
        }
        self.modified.as_mut().unwrap()
    }

    // Take field
    pub fn take_modified(&mut self) -> WaveFormat {
        self.modified.take().unwrap_or_else(|| WaveFormat::new())
    }

    // optional .WaveFormat closest_matched = 3;


    pub fn get_closest_matched(&self) -> &WaveFormat {
        self.closest_matched.as_ref().unwrap_or_else(|| <WaveFormat as ::protobuf::Message>::default_instance())
    }
    pub fn clear_closest_matched(&mut self) {
        self.closest_matched.clear();
    }

    pub fn has_closest_matched(&self) -> bool {
        self.closest_matched.is_some()
    }

    // Param is passed by value, moved
    pub fn set_closest_matched(&mut self, v: WaveFormat) {
        self.closest_matched = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_closest_matched(&mut self) -> &mut WaveFormat {
        if self.closest_matched.is_none() {
            self.closest_matched.set_default();
        }
        self.closest_matched.as_mut().unwrap()
    }

    // Take field
    pub fn take_closest_matched(&mut self) -> WaveFormat {
        self.closest_matched.take().unwrap_or_else(|| WaveFormat::new())
    }
}

impl ::protobuf::Message for WaveFormatDetails {
    fn is_initialized(&self) -> bool {
        for v in &self.requested {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.modified {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.closest_matched {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.requested)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.modified)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.closest_matched)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.requested.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.modified.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.closest_matched.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.requested.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.modified.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.closest_matched.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> WaveFormatDetails {
        WaveFormatDetails::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<WaveFormat>>(
                "requested",
                |m: &WaveFormatDetails| { &m.requested },
                |m: &mut WaveFormatDetails| { &mut m.requested },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<WaveFormat>>(
                "modified",
                |m: &WaveFormatDetails| { &m.modified },
                |m: &mut WaveFormatDetails| { &mut m.modified },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<WaveFormat>>(
                "closest_matched",
                |m: &WaveFormatDetails| { &m.closest_matched },
                |m: &mut WaveFormatDetails| { &mut m.closest_matched },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<WaveFormatDetails>(
                "WaveFormatDetails",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static WaveFormatDetails {
        static instance: ::protobuf::rt::LazyV2<WaveFormatDetails> = ::protobuf::rt::LazyV2::INIT;
        instance.get(WaveFormatDetails::new)
    }
}

impl ::protobuf::Clear for WaveFormatDetails {
    fn clear(&mut self) {
        self.requested.clear();
        self.modified.clear();
        self.closest_matched.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for WaveFormatDetails {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for WaveFormatDetails {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct WaveFormat {
    // message fields
    format_tag: ::std::option::Option<i32>,
    channels: ::std::option::Option<i32>,
    samples_per_sec: ::std::option::Option<i32>,
    avg_bytes_per_sec: ::std::option::Option<i32>,
    block_align: ::std::option::Option<i32>,
    bits_per_sample: ::std::option::Option<i32>,
    size_bytes: ::std::option::Option<i32>,
    samples: ::std::option::Option<i32>,
    channel_mask: ::std::option::Option<i64>,
    sub_format: ::std::option::Option<WaveFormat_WaveFormatSubFormat>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a WaveFormat {
    fn default() -> &'a WaveFormat {
        <WaveFormat as ::protobuf::Message>::default_instance()
    }
}

impl WaveFormat {
    pub fn new() -> WaveFormat {
        ::std::default::Default::default()
    }

    // optional int32 format_tag = 1;


    pub fn get_format_tag(&self) -> i32 {
        self.format_tag.unwrap_or(0)
    }
    pub fn clear_format_tag(&mut self) {
        self.format_tag = ::std::option::Option::None;
    }

    pub fn has_format_tag(&self) -> bool {
        self.format_tag.is_some()
    }

    // Param is passed by value, moved
    pub fn set_format_tag(&mut self, v: i32) {
        self.format_tag = ::std::option::Option::Some(v);
    }

    // optional int32 channels = 2;


    pub fn get_channels(&self) -> i32 {
        self.channels.unwrap_or(0)
    }
    pub fn clear_channels(&mut self) {
        self.channels = ::std::option::Option::None;
    }

    pub fn has_channels(&self) -> bool {
        self.channels.is_some()
    }

    // Param is passed by value, moved
    pub fn set_channels(&mut self, v: i32) {
        self.channels = ::std::option::Option::Some(v);
    }

    // optional int32 samples_per_sec = 3;


    pub fn get_samples_per_sec(&self) -> i32 {
        self.samples_per_sec.unwrap_or(0)
    }
    pub fn clear_samples_per_sec(&mut self) {
        self.samples_per_sec = ::std::option::Option::None;
    }

    pub fn has_samples_per_sec(&self) -> bool {
        self.samples_per_sec.is_some()
    }

    // Param is passed by value, moved
    pub fn set_samples_per_sec(&mut self, v: i32) {
        self.samples_per_sec = ::std::option::Option::Some(v);
    }

    // optional int32 avg_bytes_per_sec = 4;


    pub fn get_avg_bytes_per_sec(&self) -> i32 {
        self.avg_bytes_per_sec.unwrap_or(0)
    }
    pub fn clear_avg_bytes_per_sec(&mut self) {
        self.avg_bytes_per_sec = ::std::option::Option::None;
    }

    pub fn has_avg_bytes_per_sec(&self) -> bool {
        self.avg_bytes_per_sec.is_some()
    }

    // Param is passed by value, moved
    pub fn set_avg_bytes_per_sec(&mut self, v: i32) {
        self.avg_bytes_per_sec = ::std::option::Option::Some(v);
    }

    // optional int32 block_align = 5;


    pub fn get_block_align(&self) -> i32 {
        self.block_align.unwrap_or(0)
    }
    pub fn clear_block_align(&mut self) {
        self.block_align = ::std::option::Option::None;
    }

    pub fn has_block_align(&self) -> bool {
        self.block_align.is_some()
    }

    // Param is passed by value, moved
    pub fn set_block_align(&mut self, v: i32) {
        self.block_align = ::std::option::Option::Some(v);
    }

    // optional int32 bits_per_sample = 6;


    pub fn get_bits_per_sample(&self) -> i32 {
        self.bits_per_sample.unwrap_or(0)
    }
    pub fn clear_bits_per_sample(&mut self) {
        self.bits_per_sample = ::std::option::Option::None;
    }

    pub fn has_bits_per_sample(&self) -> bool {
        self.bits_per_sample.is_some()
    }

    // Param is passed by value, moved
    pub fn set_bits_per_sample(&mut self, v: i32) {
        self.bits_per_sample = ::std::option::Option::Some(v);
    }

    // optional int32 size_bytes = 7;


    pub fn get_size_bytes(&self) -> i32 {
        self.size_bytes.unwrap_or(0)
    }
    pub fn clear_size_bytes(&mut self) {
        self.size_bytes = ::std::option::Option::None;
    }

    pub fn has_size_bytes(&self) -> bool {
        self.size_bytes.is_some()
    }

    // Param is passed by value, moved
    pub fn set_size_bytes(&mut self, v: i32) {
        self.size_bytes = ::std::option::Option::Some(v);
    }

    // optional int32 samples = 8;


    pub fn get_samples(&self) -> i32 {
        self.samples.unwrap_or(0)
    }
    pub fn clear_samples(&mut self) {
        self.samples = ::std::option::Option::None;
    }

    pub fn has_samples(&self) -> bool {
        self.samples.is_some()
    }

    // Param is passed by value, moved
    pub fn set_samples(&mut self, v: i32) {
        self.samples = ::std::option::Option::Some(v);
    }

    // optional int64 channel_mask = 9;


    pub fn get_channel_mask(&self) -> i64 {
        self.channel_mask.unwrap_or(0)
    }
    pub fn clear_channel_mask(&mut self) {
        self.channel_mask = ::std::option::Option::None;
    }

    pub fn has_channel_mask(&self) -> bool {
        self.channel_mask.is_some()
    }

    // Param is passed by value, moved
    pub fn set_channel_mask(&mut self, v: i64) {
        self.channel_mask = ::std::option::Option::Some(v);
    }

    // optional .WaveFormat.WaveFormatSubFormat sub_format = 10;


    pub fn get_sub_format(&self) -> WaveFormat_WaveFormatSubFormat {
        self.sub_format.unwrap_or(WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_INVALID)
    }
    pub fn clear_sub_format(&mut self) {
        self.sub_format = ::std::option::Option::None;
    }

    pub fn has_sub_format(&self) -> bool {
        self.sub_format.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sub_format(&mut self, v: WaveFormat_WaveFormatSubFormat) {
        self.sub_format = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for WaveFormat {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.format_tag = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.channels = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.samples_per_sec = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.avg_bytes_per_sec = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.block_align = ::std::option::Option::Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.bits_per_sample = ::std::option::Option::Some(tmp);
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.size_bytes = ::std::option::Option::Some(tmp);
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.samples = ::std::option::Option::Some(tmp);
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.channel_mask = ::std::option::Option::Some(tmp);
                },
                10 => {
                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.sub_format, 10, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.format_tag {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.channels {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.samples_per_sec {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.avg_bytes_per_sec {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.block_align {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.bits_per_sample {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.size_bytes {
            my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.samples {
            my_size += ::protobuf::rt::value_size(8, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.channel_mask {
            my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.sub_format {
            my_size += ::protobuf::rt::enum_size(10, v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.format_tag {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.channels {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.samples_per_sec {
            os.write_int32(3, v)?;
        }
        if let Some(v) = self.avg_bytes_per_sec {
            os.write_int32(4, v)?;
        }
        if let Some(v) = self.block_align {
            os.write_int32(5, v)?;
        }
        if let Some(v) = self.bits_per_sample {
            os.write_int32(6, v)?;
        }
        if let Some(v) = self.size_bytes {
            os.write_int32(7, v)?;
        }
        if let Some(v) = self.samples {
            os.write_int32(8, v)?;
        }
        if let Some(v) = self.channel_mask {
            os.write_int64(9, v)?;
        }
        if let Some(v) = self.sub_format {
            os.write_enum(10, ::protobuf::ProtobufEnum::value(&v))?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> WaveFormat {
        WaveFormat::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "format_tag",
                |m: &WaveFormat| { &m.format_tag },
                |m: &mut WaveFormat| { &mut m.format_tag },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "channels",
                |m: &WaveFormat| { &m.channels },
                |m: &mut WaveFormat| { &mut m.channels },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "samples_per_sec",
                |m: &WaveFormat| { &m.samples_per_sec },
                |m: &mut WaveFormat| { &mut m.samples_per_sec },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "avg_bytes_per_sec",
                |m: &WaveFormat| { &m.avg_bytes_per_sec },
                |m: &mut WaveFormat| { &mut m.avg_bytes_per_sec },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "block_align",
                |m: &WaveFormat| { &m.block_align },
                |m: &mut WaveFormat| { &mut m.block_align },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "bits_per_sample",
                |m: &WaveFormat| { &m.bits_per_sample },
                |m: &mut WaveFormat| { &mut m.bits_per_sample },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "size_bytes",
                |m: &WaveFormat| { &m.size_bytes },
                |m: &mut WaveFormat| { &mut m.size_bytes },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "samples",
                |m: &WaveFormat| { &m.samples },
                |m: &mut WaveFormat| { &mut m.samples },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "channel_mask",
                |m: &WaveFormat| { &m.channel_mask },
                |m: &mut WaveFormat| { &mut m.channel_mask },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<WaveFormat_WaveFormatSubFormat>>(
                "sub_format",
                |m: &WaveFormat| { &m.sub_format },
                |m: &mut WaveFormat| { &mut m.sub_format },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<WaveFormat>(
                "WaveFormat",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static WaveFormat {
        static instance: ::protobuf::rt::LazyV2<WaveFormat> = ::protobuf::rt::LazyV2::INIT;
        instance.get(WaveFormat::new)
    }
}

impl ::protobuf::Clear for WaveFormat {
    fn clear(&mut self) {
        self.format_tag = ::std::option::Option::None;
        self.channels = ::std::option::Option::None;
        self.samples_per_sec = ::std::option::Option::None;
        self.avg_bytes_per_sec = ::std::option::Option::None;
        self.block_align = ::std::option::Option::None;
        self.bits_per_sample = ::std::option::Option::None;
        self.size_bytes = ::std::option::Option::None;
        self.samples = ::std::option::Option::None;
        self.channel_mask = ::std::option::Option::None;
        self.sub_format = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for WaveFormat {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for WaveFormat {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub enum WaveFormat_WaveFormatSubFormat {
    KSDATAFORMAT_SUBTYPE_INVALID = 0,
    KSDATAFORMAT_SUBTYPE_ANALOG = 1,
    KSDATAFORMAT_SUBTYPE_PCM = 2,
    KSDATAFORMAT_SUBTYPE_IEEE_FLOAT = 3,
    KSDATAFORMAT_SUBTYPE_DRM = 4,
    KSDATAFORMAT_SUBTYPE_ALAW = 5,
    KSDATAFORMAT_SUBTYPE_MULAW = 6,
    KSDATAFORMAT_SUBTYPE_ADPCM = 7,
    KSDATAFORMAT_SUBTYPE_MPEG = 8,
}

impl ::protobuf::ProtobufEnum for WaveFormat_WaveFormatSubFormat {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<WaveFormat_WaveFormatSubFormat> {
        match value {
            0 => ::std::option::Option::Some(WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_INVALID),
            1 => ::std::option::Option::Some(WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_ANALOG),
            2 => ::std::option::Option::Some(WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_PCM),
            3 => ::std::option::Option::Some(WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_IEEE_FLOAT),
            4 => ::std::option::Option::Some(WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_DRM),
            5 => ::std::option::Option::Some(WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_ALAW),
            6 => ::std::option::Option::Some(WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_MULAW),
            7 => ::std::option::Option::Some(WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_ADPCM),
            8 => ::std::option::Option::Some(WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_MPEG),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [WaveFormat_WaveFormatSubFormat] = &[
            WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_INVALID,
            WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_ANALOG,
            WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_PCM,
            WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_IEEE_FLOAT,
            WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_DRM,
            WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_ALAW,
            WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_MULAW,
            WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_ADPCM,
            WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_MPEG,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<WaveFormat_WaveFormatSubFormat>("WaveFormat.WaveFormatSubFormat", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for WaveFormat_WaveFormatSubFormat {
}

impl ::std::default::Default for WaveFormat_WaveFormatSubFormat {
    fn default() -> Self {
        WaveFormat_WaveFormatSubFormat::KSDATAFORMAT_SUBTYPE_INVALID
    }
}

impl ::protobuf::reflect::ProtobufValue for WaveFormat_WaveFormatSubFormat {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct EmulatorChildProcessExitDetails {
    // message fields
    exit_code: ::std::option::Option<u32>,
    process_type: ::std::option::Option<EmulatorProcessType>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a EmulatorChildProcessExitDetails {
    fn default() -> &'a EmulatorChildProcessExitDetails {
        <EmulatorChildProcessExitDetails as ::protobuf::Message>::default_instance()
    }
}

impl EmulatorChildProcessExitDetails {
    pub fn new() -> EmulatorChildProcessExitDetails {
        ::std::default::Default::default()
    }

    // optional uint32 exit_code = 1;


    pub fn get_exit_code(&self) -> u32 {
        self.exit_code.unwrap_or(0)
    }
    pub fn clear_exit_code(&mut self) {
        self.exit_code = ::std::option::Option::None;
    }

    pub fn has_exit_code(&self) -> bool {
        self.exit_code.is_some()
    }

    // Param is passed by value, moved
    pub fn set_exit_code(&mut self, v: u32) {
        self.exit_code = ::std::option::Option::Some(v);
    }

    // optional .EmulatorProcessType process_type = 2;


    pub fn get_process_type(&self) -> EmulatorProcessType {
        self.process_type.unwrap_or(EmulatorProcessType::PROCESS_TYPE_UNKNOWN)
    }
    pub fn clear_process_type(&mut self) {
        self.process_type = ::std::option::Option::None;
    }

    pub fn has_process_type(&self) -> bool {
        self.process_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_process_type(&mut self, v: EmulatorProcessType) {
        self.process_type = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for EmulatorChildProcessExitDetails {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.exit_code = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.process_type, 2, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.exit_code {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.process_type {
            my_size += ::protobuf::rt::enum_size(2, v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.exit_code {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.process_type {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&v))?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> EmulatorChildProcessExitDetails {
        EmulatorChildProcessExitDetails::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "exit_code",
                |m: &EmulatorChildProcessExitDetails| { &m.exit_code },
                |m: &mut EmulatorChildProcessExitDetails| { &mut m.exit_code },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EmulatorProcessType>>(
                "process_type",
                |m: &EmulatorChildProcessExitDetails| { &m.process_type },
                |m: &mut EmulatorChildProcessExitDetails| { &mut m.process_type },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<EmulatorChildProcessExitDetails>(
                "EmulatorChildProcessExitDetails",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static EmulatorChildProcessExitDetails {
        static instance: ::protobuf::rt::LazyV2<EmulatorChildProcessExitDetails> = ::protobuf::rt::LazyV2::INIT;
        instance.get(EmulatorChildProcessExitDetails::new)
    }
}

impl ::protobuf::Clear for EmulatorChildProcessExitDetails {
    fn clear(&mut self) {
        self.exit_code = ::std::option::Option::None;
        self.process_type = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for EmulatorChildProcessExitDetails {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for EmulatorChildProcessExitDetails {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub struct EmulatorDllDetails {
    // message fields
    dll_base_name: ::protobuf::SingularField<::std::string::String>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a EmulatorDllDetails {
    fn default() -> &'a EmulatorDllDetails {
        <EmulatorDllDetails as ::protobuf::Message>::default_instance()
    }
}

impl EmulatorDllDetails {
    pub fn new() -> EmulatorDllDetails {
        ::std::default::Default::default()
    }

    // optional string dll_base_name = 1;


    pub fn get_dll_base_name(&self) -> &str {
        match self.dll_base_name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_dll_base_name(&mut self) {
        self.dll_base_name.clear();
    }

    pub fn has_dll_base_name(&self) -> bool {
        self.dll_base_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_dll_base_name(&mut self, v: ::std::string::String) {
        self.dll_base_name = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_dll_base_name(&mut self) -> &mut ::std::string::String {
        if self.dll_base_name.is_none() {
            self.dll_base_name.set_default();
        }
        self.dll_base_name.as_mut().unwrap()
    }

    // Take field
    pub fn take_dll_base_name(&mut self) -> ::std::string::String {
        self.dll_base_name.take().unwrap_or_else(|| ::std::string::String::new())
    }
}

impl ::protobuf::Message for EmulatorDllDetails {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.dll_base_name)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.dll_base_name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.dll_base_name.as_ref() {
            os.write_string(1, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> EmulatorDllDetails {
        EmulatorDllDetails::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "dll_base_name",
                |m: &EmulatorDllDetails| { &m.dll_base_name },
                |m: &mut EmulatorDllDetails| { &mut m.dll_base_name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<EmulatorDllDetails>(
                "EmulatorDllDetails",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static EmulatorDllDetails {
        static instance: ::protobuf::rt::LazyV2<EmulatorDllDetails> = ::protobuf::rt::LazyV2::INIT;
        instance.get(EmulatorDllDetails::new)
    }
}

impl ::protobuf::Clear for EmulatorDllDetails {
    fn clear(&mut self) {
        self.dll_base_name.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for EmulatorDllDetails {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for EmulatorDllDetails {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
#[cfg_attr(feature = "with-serde", derive(::serde::Serialize, ::serde::Deserialize))]
pub enum EmulatorProcessType {
    PROCESS_TYPE_UNKNOWN = 0,
    PROCESS_TYPE_MAIN = 1,
    PROCESS_TYPE_BLOCK = 2,
    PROCESS_TYPE_METRICS = 3,
    PROCESS_TYPE_NET = 4,
    PROCESS_TYPE_SLIRP = 5,
    PROCESS_TYPE_GPU = 6,
    PROCESS_TYPE_SOUND = 7,
    PROCESS_TYPE_BROKER = 8,
    PROCESS_TYPE_SPU = 9,
}

impl ::protobuf::ProtobufEnum for EmulatorProcessType {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<EmulatorProcessType> {
        match value {
            0 => ::std::option::Option::Some(EmulatorProcessType::PROCESS_TYPE_UNKNOWN),
            1 => ::std::option::Option::Some(EmulatorProcessType::PROCESS_TYPE_MAIN),
            2 => ::std::option::Option::Some(EmulatorProcessType::PROCESS_TYPE_BLOCK),
            3 => ::std::option::Option::Some(EmulatorProcessType::PROCESS_TYPE_METRICS),
            4 => ::std::option::Option::Some(EmulatorProcessType::PROCESS_TYPE_NET),
            5 => ::std::option::Option::Some(EmulatorProcessType::PROCESS_TYPE_SLIRP),
            6 => ::std::option::Option::Some(EmulatorProcessType::PROCESS_TYPE_GPU),
            7 => ::std::option::Option::Some(EmulatorProcessType::PROCESS_TYPE_SOUND),
            8 => ::std::option::Option::Some(EmulatorProcessType::PROCESS_TYPE_BROKER),
            9 => ::std::option::Option::Some(EmulatorProcessType::PROCESS_TYPE_SPU),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [EmulatorProcessType] = &[
            EmulatorProcessType::PROCESS_TYPE_UNKNOWN,
            EmulatorProcessType::PROCESS_TYPE_MAIN,
            EmulatorProcessType::PROCESS_TYPE_BLOCK,
            EmulatorProcessType::PROCESS_TYPE_METRICS,
            EmulatorProcessType::PROCESS_TYPE_NET,
            EmulatorProcessType::PROCESS_TYPE_SLIRP,
            EmulatorProcessType::PROCESS_TYPE_GPU,
            EmulatorProcessType::PROCESS_TYPE_SOUND,
            EmulatorProcessType::PROCESS_TYPE_BROKER,
            EmulatorProcessType::PROCESS_TYPE_SPU,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<EmulatorProcessType>("EmulatorProcessType", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for EmulatorProcessType {
}

impl ::std::default::Default for EmulatorProcessType {
    fn default() -> Self {
        EmulatorProcessType::PROCESS_TYPE_UNKNOWN
    }
}

impl ::protobuf::reflect::ProtobufValue for EmulatorProcessType {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x13event_details.proto\"\x96\x02\n\rRecordDetails\x12n\n#emulator_chi\
    ld_process_exit_details\x18\x0c\x20\x01(\x0b2\x20.EmulatorChildProcessEx\
    itDetailsR\x1femulatorChildProcessExitDetails\x12B\n\x13wave_format_deta\
    ils\x18\r\x20\x01(\x0b2\x12.WaveFormatDetailsR\x11waveFormatDetails\x12E\
    \n\x14emulator_dll_details\x18\x13\x20\x01(\x0b2\x13.EmulatorDllDetailsR\
    \x12emulatorDllDetailsJ\x04\x08\x01\x10\x0cJ\x04\x08\x0e\x10\x13\"\x9d\
    \x01\n\x11WaveFormatDetails\x12)\n\trequested\x18\x01\x20\x01(\x0b2\x0b.\
    WaveFormatR\trequested\x12'\n\x08modified\x18\x02\x20\x01(\x0b2\x0b.Wave\
    FormatR\x08modified\x124\n\x0fclosest_matched\x18\x03\x20\x01(\x0b2\x0b.\
    WaveFormatR\x0eclosestMatched\"\xb9\x05\n\nWaveFormat\x12\x1d\n\nformat_\
    tag\x18\x01\x20\x01(\x05R\tformatTag\x12\x1a\n\x08channels\x18\x02\x20\
    \x01(\x05R\x08channels\x12&\n\x0fsamples_per_sec\x18\x03\x20\x01(\x05R\r\
    samplesPerSec\x12)\n\x11avg_bytes_per_sec\x18\x04\x20\x01(\x05R\x0eavgBy\
    tesPerSec\x12\x1f\n\x0bblock_align\x18\x05\x20\x01(\x05R\nblockAlign\x12\
    &\n\x0fbits_per_sample\x18\x06\x20\x01(\x05R\rbitsPerSample\x12\x1d\n\ns\
    ize_bytes\x18\x07\x20\x01(\x05R\tsizeBytes\x12\x18\n\x07samples\x18\x08\
    \x20\x01(\x05R\x07samples\x12!\n\x0cchannel_mask\x18\t\x20\x01(\x03R\x0b\
    channelMask\x12>\n\nsub_format\x18\n\x20\x01(\x0e2\x1f.WaveFormat.WaveFo\
    rmatSubFormatR\tsubFormat\"\xb7\x02\n\x13WaveFormatSubFormat\x12\x20\n\
    \x1cKSDATAFORMAT_SUBTYPE_INVALID\x10\0\x12\x1f\n\x1bKSDATAFORMAT_SUBTYPE\
    _ANALOG\x10\x01\x12\x1c\n\x18KSDATAFORMAT_SUBTYPE_PCM\x10\x02\x12#\n\x1f\
    KSDATAFORMAT_SUBTYPE_IEEE_FLOAT\x10\x03\x12\x1c\n\x18KSDATAFORMAT_SUBTYP\
    E_DRM\x10\x04\x12\x1d\n\x19KSDATAFORMAT_SUBTYPE_ALAW\x10\x05\x12\x1e\n\
    \x1aKSDATAFORMAT_SUBTYPE_MULAW\x10\x06\x12\x1e\n\x1aKSDATAFORMAT_SUBTYPE\
    _ADPCM\x10\x07\x12\x1d\n\x19KSDATAFORMAT_SUBTYPE_MPEG\x10\x08\"w\n\x1fEm\
    ulatorChildProcessExitDetails\x12\x1b\n\texit_code\x18\x01\x20\x01(\rR\
    \x08exitCode\x127\n\x0cprocess_type\x18\x02\x20\x01(\x0e2\x14.EmulatorPr\
    ocessTypeR\x0bprocessType\"8\n\x12EmulatorDllDetails\x12\"\n\rdll_base_n\
    ame\x18\x01\x20\x01(\tR\x0bdllBaseName*\x83\x02\n\x13EmulatorProcessType\
    \x12\x18\n\x14PROCESS_TYPE_UNKNOWN\x10\0\x12\x15\n\x11PROCESS_TYPE_MAIN\
    \x10\x01\x12\x16\n\x12PROCESS_TYPE_BLOCK\x10\x02\x12\x18\n\x14PROCESS_TY\
    PE_METRICS\x10\x03\x12\x14\n\x10PROCESS_TYPE_NET\x10\x04\x12\x16\n\x12PR\
    OCESS_TYPE_SLIRP\x10\x05\x12\x14\n\x10PROCESS_TYPE_GPU\x10\x06\x12\x16\n\
    \x12PROCESS_TYPE_SOUND\x10\x07\x12\x17\n\x13PROCESS_TYPE_BROKER\x10\x08\
    \x12\x14\n\x10PROCESS_TYPE_SPU\x10\t\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}