werunplugged/unplugged-system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
06ee9615ad
unplugged-system/external/crosvm/metrics/out/event_details.rs

1676 lines
62 KiB
Rust
Raw Blame History

// 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()
})
}
Reference in New Issue View Git Blame Copy Permalink