// 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, pub wave_format_details: ::protobuf::SingularPtrField, pub emulator_dll_details: ::protobuf::SingularPtrField, // 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 { ::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(|| ::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(|| ::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(|| ::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) -> ::std::boxed::Box { 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>( "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>( "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>( "emulator_dll_details", |m: &RecordDetails| { &m.emulator_dll_details }, |m: &mut RecordDetails| { &mut m.emulator_dll_details }, )); ::protobuf::reflect::MessageDescriptor::new_pb_name::( "RecordDetails", fields, file_descriptor_proto() ) }) } fn default_instance() -> &'static RecordDetails { static instance: ::protobuf::rt::LazyV2 = ::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, pub modified: ::protobuf::SingularPtrField, pub closest_matched: ::protobuf::SingularPtrField, // 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 { ::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(|| ::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(|| ::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(|| ::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) -> ::std::boxed::Box { 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>( "requested", |m: &WaveFormatDetails| { &m.requested }, |m: &mut WaveFormatDetails| { &mut m.requested }, )); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "modified", |m: &WaveFormatDetails| { &m.modified }, |m: &mut WaveFormatDetails| { &mut m.modified }, )); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "closest_matched", |m: &WaveFormatDetails| { &m.closest_matched }, |m: &mut WaveFormatDetails| { &mut m.closest_matched }, )); ::protobuf::reflect::MessageDescriptor::new_pb_name::( "WaveFormatDetails", fields, file_descriptor_proto() ) }) } fn default_instance() -> &'static WaveFormatDetails { static instance: ::protobuf::rt::LazyV2 = ::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, channels: ::std::option::Option, samples_per_sec: ::std::option::Option, avg_bytes_per_sec: ::std::option::Option, block_align: ::std::option::Option, bits_per_sample: ::std::option::Option, size_bytes: ::std::option::Option, samples: ::std::option::Option, channel_mask: ::std::option::Option, sub_format: ::std::option::Option, // 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 { ::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) -> ::std::boxed::Box { 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>( "sub_format", |m: &WaveFormat| { &m.sub_format }, |m: &mut WaveFormat| { &mut m.sub_format }, )); ::protobuf::reflect::MessageDescriptor::new_pb_name::( "WaveFormat", fields, file_descriptor_proto() ) }) } fn default_instance() -> &'static WaveFormat { static instance: ::protobuf::rt::LazyV2 = ::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 { 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", 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, process_type: ::std::option::Option, // 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 { ::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) -> ::std::boxed::Box { 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>( "process_type", |m: &EmulatorChildProcessExitDetails| { &m.process_type }, |m: &mut EmulatorChildProcessExitDetails| { &mut m.process_type }, )); ::protobuf::reflect::MessageDescriptor::new_pb_name::( "EmulatorChildProcessExitDetails", fields, file_descriptor_proto() ) }) } fn default_instance() -> &'static EmulatorChildProcessExitDetails { static instance: ::protobuf::rt::LazyV2 = ::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 { ::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) -> ::std::boxed::Box { 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", fields, file_descriptor_proto() ) }) } fn default_instance() -> &'static EmulatorDllDetails { static instance: ::protobuf::rt::LazyV2 = ::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 { 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", 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() }) }