#![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_results)]
#![allow(unused_mut)]
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_2_0;
#[derive(PartialEq,Clone,Default,Debug)]
pub struct VirtioBalloonResize {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a VirtioBalloonResize {
fn default() -> &'a VirtioBalloonResize {
<VirtioBalloonResize as ::protobuf::Message>::default_instance()
}
}
impl VirtioBalloonResize {
pub fn new() -> VirtioBalloonResize {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(0);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<VirtioBalloonResize>(
"VirtioBalloonResize",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for VirtioBalloonResize {
const NAME: &'static str = "VirtioBalloonResize";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> VirtioBalloonResize {
VirtioBalloonResize::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static VirtioBalloonResize {
static instance: VirtioBalloonResize = VirtioBalloonResize {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for VirtioBalloonResize {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("VirtioBalloonResize").unwrap()).clone()
}
}
impl ::std::fmt::Display for VirtioBalloonResize {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for VirtioBalloonResize {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct VirtioBalloonOOMDeflation {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a VirtioBalloonOOMDeflation {
fn default() -> &'a VirtioBalloonOOMDeflation {
<VirtioBalloonOOMDeflation as ::protobuf::Message>::default_instance()
}
}
impl VirtioBalloonOOMDeflation {
pub fn new() -> VirtioBalloonOOMDeflation {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(0);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<VirtioBalloonOOMDeflation>(
"VirtioBalloonOOMDeflation",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for VirtioBalloonOOMDeflation {
const NAME: &'static str = "VirtioBalloonOOMDeflation";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> VirtioBalloonOOMDeflation {
VirtioBalloonOOMDeflation::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static VirtioBalloonOOMDeflation {
static instance: VirtioBalloonOOMDeflation = VirtioBalloonOOMDeflation {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for VirtioBalloonOOMDeflation {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("VirtioBalloonOOMDeflation").unwrap()).clone()
}
}
impl ::std::fmt::Display for VirtioBalloonOOMDeflation {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for VirtioBalloonOOMDeflation {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct VirtioWsBucket {
pub age: u64,
pub file_bytes: u64,
pub anon_bytes: u64,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a VirtioWsBucket {
fn default() -> &'a VirtioWsBucket {
<VirtioWsBucket as ::protobuf::Message>::default_instance()
}
}
impl VirtioWsBucket {
pub fn new() -> VirtioWsBucket {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"age",
|m: &VirtioWsBucket| { &m.age },
|m: &mut VirtioWsBucket| { &mut m.age },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"file_bytes",
|m: &VirtioWsBucket| { &m.file_bytes },
|m: &mut VirtioWsBucket| { &mut m.file_bytes },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"anon_bytes",
|m: &VirtioWsBucket| { &m.anon_bytes },
|m: &mut VirtioWsBucket| { &mut m.anon_bytes },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<VirtioWsBucket>(
"VirtioWsBucket",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for VirtioWsBucket {
const NAME: &'static str = "VirtioWsBucket";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.age = is.read_uint64()?;
},
16 => {
self.file_bytes = is.read_uint64()?;
},
24 => {
self.anon_bytes = is.read_uint64()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if self.age != 0 {
my_size += ::protobuf::rt::uint64_size(1, self.age);
}
if self.file_bytes != 0 {
my_size += ::protobuf::rt::uint64_size(2, self.file_bytes);
}
if self.anon_bytes != 0 {
my_size += ::protobuf::rt::uint64_size(3, self.anon_bytes);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if self.age != 0 {
os.write_uint64(1, self.age)?;
}
if self.file_bytes != 0 {
os.write_uint64(2, self.file_bytes)?;
}
if self.anon_bytes != 0 {
os.write_uint64(3, self.anon_bytes)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> VirtioWsBucket {
VirtioWsBucket::new()
}
fn clear(&mut self) {
self.age = 0;
self.file_bytes = 0;
self.anon_bytes = 0;
self.special_fields.clear();
}
fn default_instance() -> &'static VirtioWsBucket {
static instance: VirtioWsBucket = VirtioWsBucket {
age: 0,
file_bytes: 0,
anon_bytes: 0,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for VirtioWsBucket {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("VirtioWsBucket").unwrap()).clone()
}
}
impl ::std::fmt::Display for VirtioWsBucket {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for VirtioWsBucket {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct VirtioBalloonWsReport {
pub ws_buckets: ::std::vec::Vec<VirtioWsBucket>,
pub balloon_actual: u64,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a VirtioBalloonWsReport {
fn default() -> &'a VirtioBalloonWsReport {
<VirtioBalloonWsReport as ::protobuf::Message>::default_instance()
}
}
impl VirtioBalloonWsReport {
pub fn new() -> VirtioBalloonWsReport {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(2);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"ws_buckets",
|m: &VirtioBalloonWsReport| { &m.ws_buckets },
|m: &mut VirtioBalloonWsReport| { &mut m.ws_buckets },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"balloon_actual",
|m: &VirtioBalloonWsReport| { &m.balloon_actual },
|m: &mut VirtioBalloonWsReport| { &mut m.balloon_actual },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<VirtioBalloonWsReport>(
"VirtioBalloonWsReport",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for VirtioBalloonWsReport {
const NAME: &'static str = "VirtioBalloonWsReport";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.ws_buckets.push(is.read_message()?);
},
16 => {
self.balloon_actual = is.read_uint64()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
for value in &self.ws_buckets {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
if self.balloon_actual != 0 {
my_size += ::protobuf::rt::uint64_size(2, self.balloon_actual);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
for v in &self.ws_buckets {
::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
};
if self.balloon_actual != 0 {
os.write_uint64(2, self.balloon_actual)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> VirtioBalloonWsReport {
VirtioBalloonWsReport::new()
}
fn clear(&mut self) {
self.ws_buckets.clear();
self.balloon_actual = 0;
self.special_fields.clear();
}
fn default_instance() -> &'static VirtioBalloonWsReport {
static instance: VirtioBalloonWsReport = VirtioBalloonWsReport {
ws_buckets: ::std::vec::Vec::new(),
balloon_actual: 0,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for VirtioBalloonWsReport {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("VirtioBalloonWsReport").unwrap()).clone()
}
}
impl ::std::fmt::Display for VirtioBalloonWsReport {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for VirtioBalloonWsReport {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct RegisteredEvent {
pub Event: ::std::option::Option<registered_event::Event>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a RegisteredEvent {
fn default() -> &'a RegisteredEvent {
<RegisteredEvent as ::protobuf::Message>::default_instance()
}
}
impl RegisteredEvent {
pub fn new() -> RegisteredEvent {
::std::default::Default::default()
}
pub fn resize(&self) -> &VirtioBalloonResize {
match self.Event {
::std::option::Option::Some(registered_event::Event::Resize(ref v)) => v,
_ => <VirtioBalloonResize as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_resize(&mut self) {
self.Event = ::std::option::Option::None;
}
pub fn has_resize(&self) -> bool {
match self.Event {
::std::option::Option::Some(registered_event::Event::Resize(..)) => true,
_ => false,
}
}
pub fn set_resize(&mut self, v: VirtioBalloonResize) {
self.Event = ::std::option::Option::Some(registered_event::Event::Resize(v))
}
pub fn mut_resize(&mut self) -> &mut VirtioBalloonResize {
if let ::std::option::Option::Some(registered_event::Event::Resize(_)) = self.Event {
} else {
self.Event = ::std::option::Option::Some(registered_event::Event::Resize(VirtioBalloonResize::new()));
}
match self.Event {
::std::option::Option::Some(registered_event::Event::Resize(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_resize(&mut self) -> VirtioBalloonResize {
if self.has_resize() {
match self.Event.take() {
::std::option::Option::Some(registered_event::Event::Resize(v)) => v,
_ => panic!(),
}
} else {
VirtioBalloonResize::new()
}
}
pub fn oom_deflation(&self) -> &VirtioBalloonOOMDeflation {
match self.Event {
::std::option::Option::Some(registered_event::Event::OomDeflation(ref v)) => v,
_ => <VirtioBalloonOOMDeflation as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_oom_deflation(&mut self) {
self.Event = ::std::option::Option::None;
}
pub fn has_oom_deflation(&self) -> bool {
match self.Event {
::std::option::Option::Some(registered_event::Event::OomDeflation(..)) => true,
_ => false,
}
}
pub fn set_oom_deflation(&mut self, v: VirtioBalloonOOMDeflation) {
self.Event = ::std::option::Option::Some(registered_event::Event::OomDeflation(v))
}
pub fn mut_oom_deflation(&mut self) -> &mut VirtioBalloonOOMDeflation {
if let ::std::option::Option::Some(registered_event::Event::OomDeflation(_)) = self.Event {
} else {
self.Event = ::std::option::Option::Some(registered_event::Event::OomDeflation(VirtioBalloonOOMDeflation::new()));
}
match self.Event {
::std::option::Option::Some(registered_event::Event::OomDeflation(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_oom_deflation(&mut self) -> VirtioBalloonOOMDeflation {
if self.has_oom_deflation() {
match self.Event.take() {
::std::option::Option::Some(registered_event::Event::OomDeflation(v)) => v,
_ => panic!(),
}
} else {
VirtioBalloonOOMDeflation::new()
}
}
pub fn ws_report(&self) -> &VirtioBalloonWsReport {
match self.Event {
::std::option::Option::Some(registered_event::Event::WsReport(ref v)) => v,
_ => <VirtioBalloonWsReport as ::protobuf::Message>::default_instance(),
}
}
pub fn clear_ws_report(&mut self) {
self.Event = ::std::option::Option::None;
}
pub fn has_ws_report(&self) -> bool {
match self.Event {
::std::option::Option::Some(registered_event::Event::WsReport(..)) => true,
_ => false,
}
}
pub fn set_ws_report(&mut self, v: VirtioBalloonWsReport) {
self.Event = ::std::option::Option::Some(registered_event::Event::WsReport(v))
}
pub fn mut_ws_report(&mut self) -> &mut VirtioBalloonWsReport {
if let ::std::option::Option::Some(registered_event::Event::WsReport(_)) = self.Event {
} else {
self.Event = ::std::option::Option::Some(registered_event::Event::WsReport(VirtioBalloonWsReport::new()));
}
match self.Event {
::std::option::Option::Some(registered_event::Event::WsReport(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_ws_report(&mut self) -> VirtioBalloonWsReport {
if self.has_ws_report() {
match self.Event.take() {
::std::option::Option::Some(registered_event::Event::WsReport(v)) => v,
_ => panic!(),
}
} else {
VirtioBalloonWsReport::new()
}
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(1);
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, VirtioBalloonResize>(
"resize",
RegisteredEvent::has_resize,
RegisteredEvent::resize,
RegisteredEvent::mut_resize,
RegisteredEvent::set_resize,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, VirtioBalloonOOMDeflation>(
"oom_deflation",
RegisteredEvent::has_oom_deflation,
RegisteredEvent::oom_deflation,
RegisteredEvent::mut_oom_deflation,
RegisteredEvent::set_oom_deflation,
));
fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, VirtioBalloonWsReport>(
"ws_report",
RegisteredEvent::has_ws_report,
RegisteredEvent::ws_report,
RegisteredEvent::mut_ws_report,
RegisteredEvent::set_ws_report,
));
oneofs.push(registered_event::Event::generated_oneof_descriptor_data());
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RegisteredEvent>(
"RegisteredEvent",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for RegisteredEvent {
const NAME: &'static str = "RegisteredEvent";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.Event = ::std::option::Option::Some(registered_event::Event::Resize(is.read_message()?));
},
18 => {
self.Event = ::std::option::Option::Some(registered_event::Event::OomDeflation(is.read_message()?));
},
26 => {
self.Event = ::std::option::Option::Some(registered_event::Event::WsReport(is.read_message()?));
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let ::std::option::Option::Some(ref v) = self.Event {
match v {
®istered_event::Event::Resize(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
®istered_event::Event::OomDeflation(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
®istered_event::Event::WsReport(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
},
};
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let ::std::option::Option::Some(ref v) = self.Event {
match v {
®istered_event::Event::Resize(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
},
®istered_event::Event::OomDeflation(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
},
®istered_event::Event::WsReport(ref v) => {
::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
},
};
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> RegisteredEvent {
RegisteredEvent::new()
}
fn clear(&mut self) {
self.Event = ::std::option::Option::None;
self.Event = ::std::option::Option::None;
self.Event = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static RegisteredEvent {
static instance: RegisteredEvent = RegisteredEvent {
Event: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for RegisteredEvent {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("RegisteredEvent").unwrap()).clone()
}
}
impl ::std::fmt::Display for RegisteredEvent {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for RegisteredEvent {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
pub mod registered_event {
#[derive(Clone,PartialEq,Debug)]
#[non_exhaustive]
pub enum Event {
Resize(super::VirtioBalloonResize),
OomDeflation(super::VirtioBalloonOOMDeflation),
WsReport(super::VirtioBalloonWsReport),
}
impl ::protobuf::Oneof for Event {
}
impl ::protobuf::OneofFull for Event {
fn descriptor() -> ::protobuf::reflect::OneofDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| <super::RegisteredEvent as ::protobuf::MessageFull>::descriptor().oneof_by_name("Event").unwrap()).clone()
}
}
impl Event {
pub(in super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData {
::protobuf::reflect::GeneratedOneofDescriptorData::new::<Event>("Event")
}
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x17registered_events.proto\"\x15\n\x13VirtioBalloonResize\"\x1b\n\x19\
VirtioBalloonOOMDeflation\"`\n\x0eVirtioWsBucket\x12\x10\n\x03age\x18\
\x01\x20\x01(\x04R\x03age\x12\x1d\n\nfile_bytes\x18\x02\x20\x01(\x04R\tf\
ileBytes\x12\x1d\n\nanon_bytes\x18\x03\x20\x01(\x04R\tanonBytes\"n\n\x15\
VirtioBalloonWsReport\x12.\n\nws_buckets\x18\x01\x20\x03(\x0b2\x0f.Virti\
oWsBucketR\twsBuckets\x12%\n\x0eballoon_actual\x18\x02\x20\x01(\x04R\rba\
lloonActual\"\xc4\x01\n\x0fRegisteredEvent\x12.\n\x06resize\x18\x01\x20\
\x01(\x0b2\x14.VirtioBalloonResizeH\0R\x06resize\x12A\n\room_deflation\
\x18\x02\x20\x01(\x0b2\x1a.VirtioBalloonOOMDeflationH\0R\x0coomDeflation\
\x125\n\tws_report\x18\x03\x20\x01(\x0b2\x16.VirtioBalloonWsReportH\0R\
\x08wsReportB\x07\n\x05Eventb\x06proto3\
";
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
file_descriptor_proto_lazy.get(|| {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
})
}
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
file_descriptor.get(|| {
let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
let mut deps = ::std::vec::Vec::with_capacity(0);
let mut messages = ::std::vec::Vec::with_capacity(5);
messages.push(VirtioBalloonResize::generated_message_descriptor_data());
messages.push(VirtioBalloonOOMDeflation::generated_message_descriptor_data());
messages.push(VirtioWsBucket::generated_message_descriptor_data());
messages.push(VirtioBalloonWsReport::generated_message_descriptor_data());
messages.push(RegisteredEvent::generated_message_descriptor_data());
let mut enums = ::std::vec::Vec::with_capacity(0);
::protobuf::reflect::GeneratedFileDescriptor::new_generated(
file_descriptor_proto(),
deps,
messages,
enums,
)
});
::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
})
}