#![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)]
#[derive(PartialEq,Clone,Default)]
pub struct DriverConfig {
pub delay_between_updates: f32,
pub timeout_after_last_ping: f32,
pub image: ::protobuf::SingularPtrField<super::io::EverloopImage>,
pub malos_eye_config: ::protobuf::SingularPtrField<super::maloseye::MalosEyeConfig>,
pub zigbee_message: ::protobuf::SingularPtrField<super::comm::ZigBeeMsg>,
pub lirc: ::protobuf::SingularPtrField<super::comm::LircParams>,
pub servo: ::protobuf::SingularPtrField<super::io::ServoParams>,
pub gpio: ::protobuf::SingularPtrField<super::io::GpioParams>,
pub humidity: ::protobuf::SingularPtrField<super::sense::HumidityParams>,
pub micarray: ::protobuf::SingularPtrField<super::io::MicArrayParams>,
pub zwave: ::protobuf::SingularPtrField<super::comm::ZWaveMsg>,
pub wakeword: ::protobuf::SingularPtrField<super::io::WakeWordParams>,
pub matrix_device: ::protobuf::SingularPtrField<super::io::MatrixDeviceParams>,
pub uuid: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a DriverConfig {
fn default() -> &'a DriverConfig {
<DriverConfig as ::protobuf::Message>::default_instance()
}
}
impl DriverConfig {
pub fn new() -> DriverConfig {
::std::default::Default::default()
}
pub fn get_delay_between_updates(&self) -> f32 {
self.delay_between_updates
}
pub fn clear_delay_between_updates(&mut self) {
self.delay_between_updates = 0.;
}
pub fn set_delay_between_updates(&mut self, v: f32) {
self.delay_between_updates = v;
}
pub fn get_timeout_after_last_ping(&self) -> f32 {
self.timeout_after_last_ping
}
pub fn clear_timeout_after_last_ping(&mut self) {
self.timeout_after_last_ping = 0.;
}
pub fn set_timeout_after_last_ping(&mut self, v: f32) {
self.timeout_after_last_ping = v;
}
pub fn get_image(&self) -> &super::io::EverloopImage {
self.image.as_ref().unwrap_or_else(|| <super::io::EverloopImage as ::protobuf::Message>::default_instance())
}
pub fn clear_image(&mut self) {
self.image.clear();
}
pub fn has_image(&self) -> bool {
self.image.is_some()
}
pub fn set_image(&mut self, v: super::io::EverloopImage) {
self.image = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_image(&mut self) -> &mut super::io::EverloopImage {
if self.image.is_none() {
self.image.set_default();
}
self.image.as_mut().unwrap()
}
pub fn take_image(&mut self) -> super::io::EverloopImage {
self.image.take().unwrap_or_else(|| super::io::EverloopImage::new())
}
pub fn get_malos_eye_config(&self) -> &super::maloseye::MalosEyeConfig {
self.malos_eye_config.as_ref().unwrap_or_else(|| <super::maloseye::MalosEyeConfig as ::protobuf::Message>::default_instance())
}
pub fn clear_malos_eye_config(&mut self) {
self.malos_eye_config.clear();
}
pub fn has_malos_eye_config(&self) -> bool {
self.malos_eye_config.is_some()
}
pub fn set_malos_eye_config(&mut self, v: super::maloseye::MalosEyeConfig) {
self.malos_eye_config = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_malos_eye_config(&mut self) -> &mut super::maloseye::MalosEyeConfig {
if self.malos_eye_config.is_none() {
self.malos_eye_config.set_default();
}
self.malos_eye_config.as_mut().unwrap()
}
pub fn take_malos_eye_config(&mut self) -> super::maloseye::MalosEyeConfig {
self.malos_eye_config.take().unwrap_or_else(|| super::maloseye::MalosEyeConfig::new())
}
pub fn get_zigbee_message(&self) -> &super::comm::ZigBeeMsg {
self.zigbee_message.as_ref().unwrap_or_else(|| <super::comm::ZigBeeMsg as ::protobuf::Message>::default_instance())
}
pub fn clear_zigbee_message(&mut self) {
self.zigbee_message.clear();
}
pub fn has_zigbee_message(&self) -> bool {
self.zigbee_message.is_some()
}
pub fn set_zigbee_message(&mut self, v: super::comm::ZigBeeMsg) {
self.zigbee_message = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_zigbee_message(&mut self) -> &mut super::comm::ZigBeeMsg {
if self.zigbee_message.is_none() {
self.zigbee_message.set_default();
}
self.zigbee_message.as_mut().unwrap()
}
pub fn take_zigbee_message(&mut self) -> super::comm::ZigBeeMsg {
self.zigbee_message.take().unwrap_or_else(|| super::comm::ZigBeeMsg::new())
}
pub fn get_lirc(&self) -> &super::comm::LircParams {
self.lirc.as_ref().unwrap_or_else(|| <super::comm::LircParams as ::protobuf::Message>::default_instance())
}
pub fn clear_lirc(&mut self) {
self.lirc.clear();
}
pub fn has_lirc(&self) -> bool {
self.lirc.is_some()
}
pub fn set_lirc(&mut self, v: super::comm::LircParams) {
self.lirc = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_lirc(&mut self) -> &mut super::comm::LircParams {
if self.lirc.is_none() {
self.lirc.set_default();
}
self.lirc.as_mut().unwrap()
}
pub fn take_lirc(&mut self) -> super::comm::LircParams {
self.lirc.take().unwrap_or_else(|| super::comm::LircParams::new())
}
pub fn get_servo(&self) -> &super::io::ServoParams {
self.servo.as_ref().unwrap_or_else(|| <super::io::ServoParams as ::protobuf::Message>::default_instance())
}
pub fn clear_servo(&mut self) {
self.servo.clear();
}
pub fn has_servo(&self) -> bool {
self.servo.is_some()
}
pub fn set_servo(&mut self, v: super::io::ServoParams) {
self.servo = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_servo(&mut self) -> &mut super::io::ServoParams {
if self.servo.is_none() {
self.servo.set_default();
}
self.servo.as_mut().unwrap()
}
pub fn take_servo(&mut self) -> super::io::ServoParams {
self.servo.take().unwrap_or_else(|| super::io::ServoParams::new())
}
pub fn get_gpio(&self) -> &super::io::GpioParams {
self.gpio.as_ref().unwrap_or_else(|| <super::io::GpioParams as ::protobuf::Message>::default_instance())
}
pub fn clear_gpio(&mut self) {
self.gpio.clear();
}
pub fn has_gpio(&self) -> bool {
self.gpio.is_some()
}
pub fn set_gpio(&mut self, v: super::io::GpioParams) {
self.gpio = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_gpio(&mut self) -> &mut super::io::GpioParams {
if self.gpio.is_none() {
self.gpio.set_default();
}
self.gpio.as_mut().unwrap()
}
pub fn take_gpio(&mut self) -> super::io::GpioParams {
self.gpio.take().unwrap_or_else(|| super::io::GpioParams::new())
}
pub fn get_humidity(&self) -> &super::sense::HumidityParams {
self.humidity.as_ref().unwrap_or_else(|| <super::sense::HumidityParams as ::protobuf::Message>::default_instance())
}
pub fn clear_humidity(&mut self) {
self.humidity.clear();
}
pub fn has_humidity(&self) -> bool {
self.humidity.is_some()
}
pub fn set_humidity(&mut self, v: super::sense::HumidityParams) {
self.humidity = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_humidity(&mut self) -> &mut super::sense::HumidityParams {
if self.humidity.is_none() {
self.humidity.set_default();
}
self.humidity.as_mut().unwrap()
}
pub fn take_humidity(&mut self) -> super::sense::HumidityParams {
self.humidity.take().unwrap_or_else(|| super::sense::HumidityParams::new())
}
pub fn get_micarray(&self) -> &super::io::MicArrayParams {
self.micarray.as_ref().unwrap_or_else(|| <super::io::MicArrayParams as ::protobuf::Message>::default_instance())
}
pub fn clear_micarray(&mut self) {
self.micarray.clear();
}
pub fn has_micarray(&self) -> bool {
self.micarray.is_some()
}
pub fn set_micarray(&mut self, v: super::io::MicArrayParams) {
self.micarray = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_micarray(&mut self) -> &mut super::io::MicArrayParams {
if self.micarray.is_none() {
self.micarray.set_default();
}
self.micarray.as_mut().unwrap()
}
pub fn take_micarray(&mut self) -> super::io::MicArrayParams {
self.micarray.take().unwrap_or_else(|| super::io::MicArrayParams::new())
}
pub fn get_zwave(&self) -> &super::comm::ZWaveMsg {
self.zwave.as_ref().unwrap_or_else(|| <super::comm::ZWaveMsg as ::protobuf::Message>::default_instance())
}
pub fn clear_zwave(&mut self) {
self.zwave.clear();
}
pub fn has_zwave(&self) -> bool {
self.zwave.is_some()
}
pub fn set_zwave(&mut self, v: super::comm::ZWaveMsg) {
self.zwave = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_zwave(&mut self) -> &mut super::comm::ZWaveMsg {
if self.zwave.is_none() {
self.zwave.set_default();
}
self.zwave.as_mut().unwrap()
}
pub fn take_zwave(&mut self) -> super::comm::ZWaveMsg {
self.zwave.take().unwrap_or_else(|| super::comm::ZWaveMsg::new())
}
pub fn get_wakeword(&self) -> &super::io::WakeWordParams {
self.wakeword.as_ref().unwrap_or_else(|| <super::io::WakeWordParams as ::protobuf::Message>::default_instance())
}
pub fn clear_wakeword(&mut self) {
self.wakeword.clear();
}
pub fn has_wakeword(&self) -> bool {
self.wakeword.is_some()
}
pub fn set_wakeword(&mut self, v: super::io::WakeWordParams) {
self.wakeword = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_wakeword(&mut self) -> &mut super::io::WakeWordParams {
if self.wakeword.is_none() {
self.wakeword.set_default();
}
self.wakeword.as_mut().unwrap()
}
pub fn take_wakeword(&mut self) -> super::io::WakeWordParams {
self.wakeword.take().unwrap_or_else(|| super::io::WakeWordParams::new())
}
pub fn get_matrix_device(&self) -> &super::io::MatrixDeviceParams {
self.matrix_device.as_ref().unwrap_or_else(|| <super::io::MatrixDeviceParams as ::protobuf::Message>::default_instance())
}
pub fn clear_matrix_device(&mut self) {
self.matrix_device.clear();
}
pub fn has_matrix_device(&self) -> bool {
self.matrix_device.is_some()
}
pub fn set_matrix_device(&mut self, v: super::io::MatrixDeviceParams) {
self.matrix_device = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_matrix_device(&mut self) -> &mut super::io::MatrixDeviceParams {
if self.matrix_device.is_none() {
self.matrix_device.set_default();
}
self.matrix_device.as_mut().unwrap()
}
pub fn take_matrix_device(&mut self) -> super::io::MatrixDeviceParams {
self.matrix_device.take().unwrap_or_else(|| super::io::MatrixDeviceParams::new())
}
pub fn get_uuid(&self) -> &str {
&self.uuid
}
pub fn clear_uuid(&mut self) {
self.uuid.clear();
}
pub fn set_uuid(&mut self, v: ::std::string::String) {
self.uuid = v;
}
pub fn mut_uuid(&mut self) -> &mut ::std::string::String {
&mut self.uuid
}
pub fn take_uuid(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.uuid, ::std::string::String::new())
}
}
impl ::protobuf::Message for DriverConfig {
fn is_initialized(&self) -> bool {
for v in &self.image {
if !v.is_initialized() {
return false;
}
};
for v in &self.malos_eye_config {
if !v.is_initialized() {
return false;
}
};
for v in &self.zigbee_message {
if !v.is_initialized() {
return false;
}
};
for v in &self.lirc {
if !v.is_initialized() {
return false;
}
};
for v in &self.servo {
if !v.is_initialized() {
return false;
}
};
for v in &self.gpio {
if !v.is_initialized() {
return false;
}
};
for v in &self.humidity {
if !v.is_initialized() {
return false;
}
};
for v in &self.micarray {
if !v.is_initialized() {
return false;
}
};
for v in &self.zwave {
if !v.is_initialized() {
return false;
}
};
for v in &self.wakeword {
if !v.is_initialized() {
return false;
}
};
for v in &self.matrix_device {
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 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.delay_between_updates = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_float()?;
self.timeout_after_last_ping = tmp;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.image)?;
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.malos_eye_config)?;
},
5 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.zigbee_message)?;
},
6 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.lirc)?;
},
7 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.servo)?;
},
8 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.gpio)?;
},
9 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.humidity)?;
},
10 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.micarray)?;
},
11 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.zwave)?;
},
12 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.wakeword)?;
},
13 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.matrix_device)?;
},
14 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.uuid)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.delay_between_updates != 0. {
my_size += 5;
}
if self.timeout_after_last_ping != 0. {
my_size += 5;
}
if let Some(ref v) = self.image.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.malos_eye_config.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.zigbee_message.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.lirc.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.servo.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.gpio.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.humidity.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.micarray.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.zwave.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.wakeword.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.matrix_device.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if !self.uuid.is_empty() {
my_size += ::protobuf::rt::string_size(14, &self.uuid);
}
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 self.delay_between_updates != 0. {
os.write_float(1, self.delay_between_updates)?;
}
if self.timeout_after_last_ping != 0. {
os.write_float(2, self.timeout_after_last_ping)?;
}
if let Some(ref v) = self.image.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)?;
}
if let Some(ref v) = self.malos_eye_config.as_ref() {
os.write_tag(4, ::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.zigbee_message.as_ref() {
os.write_tag(5, ::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.lirc.as_ref() {
os.write_tag(6, ::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.servo.as_ref() {
os.write_tag(7, ::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.gpio.as_ref() {
os.write_tag(8, ::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.humidity.as_ref() {
os.write_tag(9, ::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.micarray.as_ref() {
os.write_tag(10, ::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.zwave.as_ref() {
os.write_tag(11, ::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.wakeword.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.matrix_device.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 !self.uuid.is_empty() {
os.write_string(14, &self.uuid)?;
}
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() -> DriverConfig {
DriverConfig::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_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"delay_between_updates",
|m: &DriverConfig| { &m.delay_between_updates },
|m: &mut DriverConfig| { &mut m.delay_between_updates },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
"timeout_after_last_ping",
|m: &DriverConfig| { &m.timeout_after_last_ping },
|m: &mut DriverConfig| { &mut m.timeout_after_last_ping },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::io::EverloopImage>>(
"image",
|m: &DriverConfig| { &m.image },
|m: &mut DriverConfig| { &mut m.image },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::maloseye::MalosEyeConfig>>(
"malos_eye_config",
|m: &DriverConfig| { &m.malos_eye_config },
|m: &mut DriverConfig| { &mut m.malos_eye_config },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::comm::ZigBeeMsg>>(
"zigbee_message",
|m: &DriverConfig| { &m.zigbee_message },
|m: &mut DriverConfig| { &mut m.zigbee_message },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::comm::LircParams>>(
"lirc",
|m: &DriverConfig| { &m.lirc },
|m: &mut DriverConfig| { &mut m.lirc },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::io::ServoParams>>(
"servo",
|m: &DriverConfig| { &m.servo },
|m: &mut DriverConfig| { &mut m.servo },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::io::GpioParams>>(
"gpio",
|m: &DriverConfig| { &m.gpio },
|m: &mut DriverConfig| { &mut m.gpio },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::sense::HumidityParams>>(
"humidity",
|m: &DriverConfig| { &m.humidity },
|m: &mut DriverConfig| { &mut m.humidity },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::io::MicArrayParams>>(
"micarray",
|m: &DriverConfig| { &m.micarray },
|m: &mut DriverConfig| { &mut m.micarray },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::comm::ZWaveMsg>>(
"zwave",
|m: &DriverConfig| { &m.zwave },
|m: &mut DriverConfig| { &mut m.zwave },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::io::WakeWordParams>>(
"wakeword",
|m: &DriverConfig| { &m.wakeword },
|m: &mut DriverConfig| { &mut m.wakeword },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::io::MatrixDeviceParams>>(
"matrix_device",
|m: &DriverConfig| { &m.matrix_device },
|m: &mut DriverConfig| { &mut m.matrix_device },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"uuid",
|m: &DriverConfig| { &m.uuid },
|m: &mut DriverConfig| { &mut m.uuid },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<DriverConfig>(
"DriverConfig",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static DriverConfig {
static instance: ::protobuf::rt::LazyV2<DriverConfig> = ::protobuf::rt::LazyV2::INIT;
instance.get(DriverConfig::new)
}
}
impl ::protobuf::Clear for DriverConfig {
fn clear(&mut self) {
self.delay_between_updates = 0.;
self.timeout_after_last_ping = 0.;
self.image.clear();
self.malos_eye_config.clear();
self.zigbee_message.clear();
self.lirc.clear();
self.servo.clear();
self.gpio.clear();
self.humidity.clear();
self.micarray.clear();
self.zwave.clear();
self.wakeword.clear();
self.matrix_device.clear();
self.uuid.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for DriverConfig {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for DriverConfig {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct DriverInfo {
pub driver_name: ::std::string::String,
pub base_port: i32,
pub provides_updates: bool,
pub delay_between_updates: i32,
pub needs_pings: bool,
pub timeout_after_last_ping: i32,
pub notes_for_human: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a DriverInfo {
fn default() -> &'a DriverInfo {
<DriverInfo as ::protobuf::Message>::default_instance()
}
}
impl DriverInfo {
pub fn new() -> DriverInfo {
::std::default::Default::default()
}
pub fn get_driver_name(&self) -> &str {
&self.driver_name
}
pub fn clear_driver_name(&mut self) {
self.driver_name.clear();
}
pub fn set_driver_name(&mut self, v: ::std::string::String) {
self.driver_name = v;
}
pub fn mut_driver_name(&mut self) -> &mut ::std::string::String {
&mut self.driver_name
}
pub fn take_driver_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.driver_name, ::std::string::String::new())
}
pub fn get_base_port(&self) -> i32 {
self.base_port
}
pub fn clear_base_port(&mut self) {
self.base_port = 0;
}
pub fn set_base_port(&mut self, v: i32) {
self.base_port = v;
}
pub fn get_provides_updates(&self) -> bool {
self.provides_updates
}
pub fn clear_provides_updates(&mut self) {
self.provides_updates = false;
}
pub fn set_provides_updates(&mut self, v: bool) {
self.provides_updates = v;
}
pub fn get_delay_between_updates(&self) -> i32 {
self.delay_between_updates
}
pub fn clear_delay_between_updates(&mut self) {
self.delay_between_updates = 0;
}
pub fn set_delay_between_updates(&mut self, v: i32) {
self.delay_between_updates = v;
}
pub fn get_needs_pings(&self) -> bool {
self.needs_pings
}
pub fn clear_needs_pings(&mut self) {
self.needs_pings = false;
}
pub fn set_needs_pings(&mut self, v: bool) {
self.needs_pings = v;
}
pub fn get_timeout_after_last_ping(&self) -> i32 {
self.timeout_after_last_ping
}
pub fn clear_timeout_after_last_ping(&mut self) {
self.timeout_after_last_ping = 0;
}
pub fn set_timeout_after_last_ping(&mut self, v: i32) {
self.timeout_after_last_ping = v;
}
pub fn get_notes_for_human(&self) -> &str {
&self.notes_for_human
}
pub fn clear_notes_for_human(&mut self) {
self.notes_for_human.clear();
}
pub fn set_notes_for_human(&mut self, v: ::std::string::String) {
self.notes_for_human = v;
}
pub fn mut_notes_for_human(&mut self) -> &mut ::std::string::String {
&mut self.notes_for_human
}
pub fn take_notes_for_human(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.notes_for_human, ::std::string::String::new())
}
}
impl ::protobuf::Message for DriverInfo {
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_proto3_string_into(wire_type, is, &mut self.driver_name)?;
},
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.base_port = 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_bool()?;
self.provides_updates = 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.delay_between_updates = 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_bool()?;
self.needs_pings = 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.timeout_after_last_ping = tmp;
},
7 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.notes_for_human)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.driver_name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.driver_name);
}
if self.base_port != 0 {
my_size += ::protobuf::rt::value_size(2, self.base_port, ::protobuf::wire_format::WireTypeVarint);
}
if self.provides_updates != false {
my_size += 2;
}
if self.delay_between_updates != 0 {
my_size += ::protobuf::rt::value_size(4, self.delay_between_updates, ::protobuf::wire_format::WireTypeVarint);
}
if self.needs_pings != false {
my_size += 2;
}
if self.timeout_after_last_ping != 0 {
my_size += ::protobuf::rt::value_size(6, self.timeout_after_last_ping, ::protobuf::wire_format::WireTypeVarint);
}
if !self.notes_for_human.is_empty() {
my_size += ::protobuf::rt::string_size(7, &self.notes_for_human);
}
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 !self.driver_name.is_empty() {
os.write_string(1, &self.driver_name)?;
}
if self.base_port != 0 {
os.write_int32(2, self.base_port)?;
}
if self.provides_updates != false {
os.write_bool(3, self.provides_updates)?;
}
if self.delay_between_updates != 0 {
os.write_int32(4, self.delay_between_updates)?;
}
if self.needs_pings != false {
os.write_bool(5, self.needs_pings)?;
}
if self.timeout_after_last_ping != 0 {
os.write_int32(6, self.timeout_after_last_ping)?;
}
if !self.notes_for_human.is_empty() {
os.write_string(7, &self.notes_for_human)?;
}
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() -> DriverInfo {
DriverInfo::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_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"driver_name",
|m: &DriverInfo| { &m.driver_name },
|m: &mut DriverInfo| { &mut m.driver_name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"base_port",
|m: &DriverInfo| { &m.base_port },
|m: &mut DriverInfo| { &mut m.base_port },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"provides_updates",
|m: &DriverInfo| { &m.provides_updates },
|m: &mut DriverInfo| { &mut m.provides_updates },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"delay_between_updates",
|m: &DriverInfo| { &m.delay_between_updates },
|m: &mut DriverInfo| { &mut m.delay_between_updates },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"needs_pings",
|m: &DriverInfo| { &m.needs_pings },
|m: &mut DriverInfo| { &mut m.needs_pings },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"timeout_after_last_ping",
|m: &DriverInfo| { &m.timeout_after_last_ping },
|m: &mut DriverInfo| { &mut m.timeout_after_last_ping },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"notes_for_human",
|m: &DriverInfo| { &m.notes_for_human },
|m: &mut DriverInfo| { &mut m.notes_for_human },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<DriverInfo>(
"DriverInfo",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static DriverInfo {
static instance: ::protobuf::rt::LazyV2<DriverInfo> = ::protobuf::rt::LazyV2::INIT;
instance.get(DriverInfo::new)
}
}
impl ::protobuf::Clear for DriverInfo {
fn clear(&mut self) {
self.driver_name.clear();
self.base_port = 0;
self.provides_updates = false;
self.delay_between_updates = 0;
self.needs_pings = false;
self.timeout_after_last_ping = 0;
self.notes_for_human.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for DriverInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for DriverInfo {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MalosDriverInfo {
pub info: ::protobuf::RepeatedField<DriverInfo>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MalosDriverInfo {
fn default() -> &'a MalosDriverInfo {
<MalosDriverInfo as ::protobuf::Message>::default_instance()
}
}
impl MalosDriverInfo {
pub fn new() -> MalosDriverInfo {
::std::default::Default::default()
}
pub fn get_info(&self) -> &[DriverInfo] {
&self.info
}
pub fn clear_info(&mut self) {
self.info.clear();
}
pub fn set_info(&mut self, v: ::protobuf::RepeatedField<DriverInfo>) {
self.info = v;
}
pub fn mut_info(&mut self) -> &mut ::protobuf::RepeatedField<DriverInfo> {
&mut self.info
}
pub fn take_info(&mut self) -> ::protobuf::RepeatedField<DriverInfo> {
::std::mem::replace(&mut self.info, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for MalosDriverInfo {
fn is_initialized(&self) -> bool {
for v in &self.info {
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_repeated_message_into(wire_type, is, &mut self.info)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
for value in &self.info {
let len = value.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<()> {
for v in &self.info {
os.write_tag(1, ::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() -> MalosDriverInfo {
MalosDriverInfo::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_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DriverInfo>>(
"info",
|m: &MalosDriverInfo| { &m.info },
|m: &mut MalosDriverInfo| { &mut m.info },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<MalosDriverInfo>(
"MalosDriverInfo",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static MalosDriverInfo {
static instance: ::protobuf::rt::LazyV2<MalosDriverInfo> = ::protobuf::rt::LazyV2::INIT;
instance.get(MalosDriverInfo::new)
}
}
impl ::protobuf::Clear for MalosDriverInfo {
fn clear(&mut self) {
self.info.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for MalosDriverInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for MalosDriverInfo {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Status {
pub field_type: Status_MessageType,
pub uuid: ::std::string::String,
pub message: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Status {
fn default() -> &'a Status {
<Status as ::protobuf::Message>::default_instance()
}
}
impl Status {
pub fn new() -> Status {
::std::default::Default::default()
}
pub fn get_field_type(&self) -> Status_MessageType {
self.field_type
}
pub fn clear_field_type(&mut self) {
self.field_type = Status_MessageType::MESSAGE_TYPE_NOT_DEFINED;
}
pub fn set_field_type(&mut self, v: Status_MessageType) {
self.field_type = v;
}
pub fn get_uuid(&self) -> &str {
&self.uuid
}
pub fn clear_uuid(&mut self) {
self.uuid.clear();
}
pub fn set_uuid(&mut self, v: ::std::string::String) {
self.uuid = v;
}
pub fn mut_uuid(&mut self) -> &mut ::std::string::String {
&mut self.uuid
}
pub fn take_uuid(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.uuid, ::std::string::String::new())
}
pub fn get_message(&self) -> &str {
&self.message
}
pub fn clear_message(&mut self) {
self.message.clear();
}
pub fn set_message(&mut self, v: ::std::string::String) {
self.message = v;
}
pub fn mut_message(&mut self) -> &mut ::std::string::String {
&mut self.message
}
pub fn take_message(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.message, ::std::string::String::new())
}
}
impl ::protobuf::Message for Status {
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_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 1, &mut self.unknown_fields)?
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.uuid)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.message)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.field_type != Status_MessageType::MESSAGE_TYPE_NOT_DEFINED {
my_size += ::protobuf::rt::enum_size(1, self.field_type);
}
if !self.uuid.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.uuid);
}
if !self.message.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.message);
}
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 self.field_type != Status_MessageType::MESSAGE_TYPE_NOT_DEFINED {
os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.field_type))?;
}
if !self.uuid.is_empty() {
os.write_string(2, &self.uuid)?;
}
if !self.message.is_empty() {
os.write_string(3, &self.message)?;
}
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() -> Status {
Status::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_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Status_MessageType>>(
"type",
|m: &Status| { &m.field_type },
|m: &mut Status| { &mut m.field_type },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"uuid",
|m: &Status| { &m.uuid },
|m: &mut Status| { &mut m.uuid },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"message",
|m: &Status| { &m.message },
|m: &mut Status| { &mut m.message },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<Status>(
"Status",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static Status {
static instance: ::protobuf::rt::LazyV2<Status> = ::protobuf::rt::LazyV2::INIT;
instance.get(Status::new)
}
}
impl ::protobuf::Clear for Status {
fn clear(&mut self) {
self.field_type = Status_MessageType::MESSAGE_TYPE_NOT_DEFINED;
self.uuid.clear();
self.message.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Status {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Status {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Status_MessageType {
MESSAGE_TYPE_NOT_DEFINED = 0,
STARTED = 1,
STOPPED = 2,
CONFIG_RECEIVED = 3,
COMMAND_EXECUTED = 4,
STATUS_CRITICAL = 5,
STATUS_ERROR = 6,
STATUS_WARNING = 7,
STATUS_INFO = 8,
STATUS_DEBUG = 9,
}
impl ::protobuf::ProtobufEnum for Status_MessageType {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<Status_MessageType> {
match value {
0 => ::std::option::Option::Some(Status_MessageType::MESSAGE_TYPE_NOT_DEFINED),
1 => ::std::option::Option::Some(Status_MessageType::STARTED),
2 => ::std::option::Option::Some(Status_MessageType::STOPPED),
3 => ::std::option::Option::Some(Status_MessageType::CONFIG_RECEIVED),
4 => ::std::option::Option::Some(Status_MessageType::COMMAND_EXECUTED),
5 => ::std::option::Option::Some(Status_MessageType::STATUS_CRITICAL),
6 => ::std::option::Option::Some(Status_MessageType::STATUS_ERROR),
7 => ::std::option::Option::Some(Status_MessageType::STATUS_WARNING),
8 => ::std::option::Option::Some(Status_MessageType::STATUS_INFO),
9 => ::std::option::Option::Some(Status_MessageType::STATUS_DEBUG),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [Status_MessageType] = &[
Status_MessageType::MESSAGE_TYPE_NOT_DEFINED,
Status_MessageType::STARTED,
Status_MessageType::STOPPED,
Status_MessageType::CONFIG_RECEIVED,
Status_MessageType::COMMAND_EXECUTED,
Status_MessageType::STATUS_CRITICAL,
Status_MessageType::STATUS_ERROR,
Status_MessageType::STATUS_WARNING,
Status_MessageType::STATUS_INFO,
Status_MessageType::STATUS_DEBUG,
];
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::<Status_MessageType>("Status.MessageType", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for Status_MessageType {
}
impl ::std::default::Default for Status_MessageType {
fn default() -> Self {
Status_MessageType::MESSAGE_TYPE_NOT_DEFINED
}
}
impl ::protobuf::reflect::ProtobufValue for Status_MessageType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x1fmatrix_io/malos/v1/driver.proto\x12\x19matrix_io.malos.v1.driver\
\x1a\x1dmatrix_io/malos/v1/comm.proto\x1a\x1bmatrix_io/malos/v1/io.proto\
\x1a!matrix_io/malos/v1/maloseye.proto\x1a\x1ematrix_io/malos/v1/sense.p\
roto\"\x88\x07\n\x0cDriverConfig\x124\n\x15delay_between_updates\x18\x01\
\x20\x01(\x02R\x13delayBetweenUpdatesB\0\x127\n\x17timeout_after_last_pi\
ng\x18\x02\x20\x01(\x02R\x14timeoutAfterLastPingB\0\x12<\n\x05image\x18\
\x03\x20\x01(\x0b2$.matrix_io.malos.v1.io.EverloopImageR\x05imageB\0\x12\
W\n\x10malos_eye_config\x18\x04\x20\x01(\x0b2+.matrix_io.malos.v1.malose\
ye.MalosEyeConfigR\x0emalosEyeConfigB\0\x12K\n\x0ezigbee_message\x18\x05\
\x20\x01(\x0b2\".matrix_io.malos.v1.comm.ZigBeeMsgR\rzigbeeMessageB\0\
\x129\n\x04lirc\x18\x06\x20\x01(\x0b2#.matrix_io.malos.v1.comm.LircParam\
sR\x04lircB\0\x12:\n\x05servo\x18\x07\x20\x01(\x0b2\".matrix_io.malos.v1\
.io.ServoParamsR\x05servoB\0\x127\n\x04gpio\x18\x08\x20\x01(\x0b2!.matri\
x_io.malos.v1.io.GpioParamsR\x04gpioB\0\x12F\n\x08humidity\x18\t\x20\x01\
(\x0b2(.matrix_io.malos.v1.sense.HumidityParamsR\x08humidityB\0\x12C\n\
\x08micarray\x18\n\x20\x01(\x0b2%.matrix_io.malos.v1.io.MicArrayParamsR\
\x08micarrayB\0\x129\n\x05zwave\x18\x0b\x20\x01(\x0b2!.matrix_io.malos.v\
1.comm.ZWaveMsgR\x05zwaveB\0\x12C\n\x08wakeword\x18\x0c\x20\x01(\x0b2%.m\
atrix_io.malos.v1.io.WakeWordParamsR\x08wakewordB\0\x12P\n\rmatrix_devic\
e\x18\r\x20\x01(\x0b2).matrix_io.malos.v1.io.MatrixDeviceParamsR\x0cmatr\
ixDeviceB\0\x12\x14\n\x04uuid\x18\x0e\x20\x01(\tR\x04uuidB\0:\0\"\xb9\
\x02\n\nDriverInfo\x12!\n\x0bdriver_name\x18\x01\x20\x01(\tR\ndriverName\
B\0\x12\x1d\n\tbase_port\x18\x02\x20\x01(\x05R\x08basePortB\0\x12+\n\x10\
provides_updates\x18\x03\x20\x01(\x08R\x0fprovidesUpdatesB\0\x124\n\x15d\
elay_between_updates\x18\x04\x20\x01(\x05R\x13delayBetweenUpdatesB\0\x12\
!\n\x0bneeds_pings\x18\x05\x20\x01(\x08R\nneedsPingsB\0\x127\n\x17timeou\
t_after_last_ping\x18\x06\x20\x01(\x05R\x14timeoutAfterLastPingB\0\x12(\
\n\x0fnotes_for_human\x18\x07\x20\x01(\tR\rnotesForHumanB\0:\0\"P\n\x0fM\
alosDriverInfo\x12;\n\x04info\x18\x01\x20\x03(\x0b2%.matrix_io.malos.v1.\
driver.DriverInfoR\x04infoB\0:\0\"\xd4\x02\n\x06Status\x12C\n\x04type\
\x18\x01\x20\x01(\x0e2-.matrix_io.malos.v1.driver.Status.MessageTypeR\
\x04typeB\0\x12\x14\n\x04uuid\x18\x02\x20\x01(\tR\x04uuidB\0\x12\x1a\n\
\x07message\x18\x03\x20\x01(\tR\x07messageB\0\"\xd0\x01\n\x0bMessageType\
\x12\x1c\n\x18MESSAGE_TYPE_NOT_DEFINED\x10\0\x12\x0b\n\x07STARTED\x10\
\x01\x12\x0b\n\x07STOPPED\x10\x02\x12\x13\n\x0fCONFIG_RECEIVED\x10\x03\
\x12\x14\n\x10COMMAND_EXECUTED\x10\x04\x12\x13\n\x0fSTATUS_CRITICAL\x10\
\x05\x12\x10\n\x0cSTATUS_ERROR\x10\x06\x12\x12\n\x0eSTATUS_WARNING\x10\
\x07\x12\x0f\n\x0bSTATUS_INFO\x10\x08\x12\x10\n\x0cSTATUS_DEBUG\x10\t\
\x1a\0:\0B\0b\x06proto3\
";
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()
})
}