#![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 MalosEyeConfig {
pub camera_config: ::protobuf::SingularPtrField<CameraConfig>,
pub face_config: ::protobuf::SingularPtrField<FaceConfig>,
pub detection_server_config: ::protobuf::SingularPtrField<DetectionServerConfig>,
pub object_to_detect: ::std::vec::Vec<EnumMalosEyeDetectionType>,
pub action: EnumMalosAction,
pub models: ::protobuf::RepeatedField<super::entity::Entity>,
pub config: ::protobuf::SingularPtrField<super::entity::Entity>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MalosEyeConfig {
fn default() -> &'a MalosEyeConfig {
<MalosEyeConfig as ::protobuf::Message>::default_instance()
}
}
impl MalosEyeConfig {
pub fn new() -> MalosEyeConfig {
::std::default::Default::default()
}
pub fn get_camera_config(&self) -> &CameraConfig {
self.camera_config.as_ref().unwrap_or_else(|| <CameraConfig as ::protobuf::Message>::default_instance())
}
pub fn clear_camera_config(&mut self) {
self.camera_config.clear();
}
pub fn has_camera_config(&self) -> bool {
self.camera_config.is_some()
}
pub fn set_camera_config(&mut self, v: CameraConfig) {
self.camera_config = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_camera_config(&mut self) -> &mut CameraConfig {
if self.camera_config.is_none() {
self.camera_config.set_default();
}
self.camera_config.as_mut().unwrap()
}
pub fn take_camera_config(&mut self) -> CameraConfig {
self.camera_config.take().unwrap_or_else(|| CameraConfig::new())
}
pub fn get_face_config(&self) -> &FaceConfig {
self.face_config.as_ref().unwrap_or_else(|| <FaceConfig as ::protobuf::Message>::default_instance())
}
pub fn clear_face_config(&mut self) {
self.face_config.clear();
}
pub fn has_face_config(&self) -> bool {
self.face_config.is_some()
}
pub fn set_face_config(&mut self, v: FaceConfig) {
self.face_config = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_face_config(&mut self) -> &mut FaceConfig {
if self.face_config.is_none() {
self.face_config.set_default();
}
self.face_config.as_mut().unwrap()
}
pub fn take_face_config(&mut self) -> FaceConfig {
self.face_config.take().unwrap_or_else(|| FaceConfig::new())
}
pub fn get_detection_server_config(&self) -> &DetectionServerConfig {
self.detection_server_config.as_ref().unwrap_or_else(|| <DetectionServerConfig as ::protobuf::Message>::default_instance())
}
pub fn clear_detection_server_config(&mut self) {
self.detection_server_config.clear();
}
pub fn has_detection_server_config(&self) -> bool {
self.detection_server_config.is_some()
}
pub fn set_detection_server_config(&mut self, v: DetectionServerConfig) {
self.detection_server_config = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_detection_server_config(&mut self) -> &mut DetectionServerConfig {
if self.detection_server_config.is_none() {
self.detection_server_config.set_default();
}
self.detection_server_config.as_mut().unwrap()
}
pub fn take_detection_server_config(&mut self) -> DetectionServerConfig {
self.detection_server_config.take().unwrap_or_else(|| DetectionServerConfig::new())
}
pub fn get_object_to_detect(&self) -> &[EnumMalosEyeDetectionType] {
&self.object_to_detect
}
pub fn clear_object_to_detect(&mut self) {
self.object_to_detect.clear();
}
pub fn set_object_to_detect(&mut self, v: ::std::vec::Vec<EnumMalosEyeDetectionType>) {
self.object_to_detect = v;
}
pub fn mut_object_to_detect(&mut self) -> &mut ::std::vec::Vec<EnumMalosEyeDetectionType> {
&mut self.object_to_detect
}
pub fn take_object_to_detect(&mut self) -> ::std::vec::Vec<EnumMalosEyeDetectionType> {
::std::mem::replace(&mut self.object_to_detect, ::std::vec::Vec::new())
}
pub fn get_action(&self) -> EnumMalosAction {
self.action
}
pub fn clear_action(&mut self) {
self.action = EnumMalosAction::MALOS_ACTION_NOT_DEFINED;
}
pub fn set_action(&mut self, v: EnumMalosAction) {
self.action = v;
}
pub fn get_models(&self) -> &[super::entity::Entity] {
&self.models
}
pub fn clear_models(&mut self) {
self.models.clear();
}
pub fn set_models(&mut self, v: ::protobuf::RepeatedField<super::entity::Entity>) {
self.models = v;
}
pub fn mut_models(&mut self) -> &mut ::protobuf::RepeatedField<super::entity::Entity> {
&mut self.models
}
pub fn take_models(&mut self) -> ::protobuf::RepeatedField<super::entity::Entity> {
::std::mem::replace(&mut self.models, ::protobuf::RepeatedField::new())
}
pub fn get_config(&self) -> &super::entity::Entity {
self.config.as_ref().unwrap_or_else(|| <super::entity::Entity as ::protobuf::Message>::default_instance())
}
pub fn clear_config(&mut self) {
self.config.clear();
}
pub fn has_config(&self) -> bool {
self.config.is_some()
}
pub fn set_config(&mut self, v: super::entity::Entity) {
self.config = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_config(&mut self) -> &mut super::entity::Entity {
if self.config.is_none() {
self.config.set_default();
}
self.config.as_mut().unwrap()
}
pub fn take_config(&mut self) -> super::entity::Entity {
self.config.take().unwrap_or_else(|| super::entity::Entity::new())
}
}
impl ::protobuf::Message for MalosEyeConfig {
fn is_initialized(&self) -> bool {
for v in &self.camera_config {
if !v.is_initialized() {
return false;
}
};
for v in &self.face_config {
if !v.is_initialized() {
return false;
}
};
for v in &self.detection_server_config {
if !v.is_initialized() {
return false;
}
};
for v in &self.models {
if !v.is_initialized() {
return false;
}
};
for v in &self.config {
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.camera_config)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.face_config)?;
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.detection_server_config)?;
},
21 => {
::protobuf::rt::read_repeated_enum_with_unknown_fields_into(wire_type, is, &mut self.object_to_detect, 21, &mut self.unknown_fields)?
},
5 => {
::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.action, 5, &mut self.unknown_fields)?
},
6 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.models)?;
},
7 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.config)?;
},
_ => {
::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 let Some(ref v) = self.camera_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.face_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.detection_server_config.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.object_to_detect {
my_size += ::protobuf::rt::enum_size(21, *value);
};
if self.action != EnumMalosAction::MALOS_ACTION_NOT_DEFINED {
my_size += ::protobuf::rt::enum_size(5, self.action);
}
for value in &self.models {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if let Some(ref v) = self.config.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.camera_config.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.face_config.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.detection_server_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)?;
}
for v in &self.object_to_detect {
os.write_enum(21, ::protobuf::ProtobufEnum::value(v))?;
};
if self.action != EnumMalosAction::MALOS_ACTION_NOT_DEFINED {
os.write_enum(5, ::protobuf::ProtobufEnum::value(&self.action))?;
}
for v in &self.models {
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.config.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)?;
}
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() -> MalosEyeConfig {
MalosEyeConfig::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<CameraConfig>>(
"camera_config",
|m: &MalosEyeConfig| { &m.camera_config },
|m: &mut MalosEyeConfig| { &mut m.camera_config },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FaceConfig>>(
"face_config",
|m: &MalosEyeConfig| { &m.face_config },
|m: &mut MalosEyeConfig| { &mut m.face_config },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DetectionServerConfig>>(
"detection_server_config",
|m: &MalosEyeConfig| { &m.detection_server_config },
|m: &mut MalosEyeConfig| { &mut m.detection_server_config },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EnumMalosEyeDetectionType>>(
"object_to_detect",
|m: &MalosEyeConfig| { &m.object_to_detect },
|m: &mut MalosEyeConfig| { &mut m.object_to_detect },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<EnumMalosAction>>(
"action",
|m: &MalosEyeConfig| { &m.action },
|m: &mut MalosEyeConfig| { &mut m.action },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::entity::Entity>>(
"models",
|m: &MalosEyeConfig| { &m.models },
|m: &mut MalosEyeConfig| { &mut m.models },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::entity::Entity>>(
"config",
|m: &MalosEyeConfig| { &m.config },
|m: &mut MalosEyeConfig| { &mut m.config },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<MalosEyeConfig>(
"MalosEyeConfig",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static MalosEyeConfig {
static instance: ::protobuf::rt::LazyV2<MalosEyeConfig> = ::protobuf::rt::LazyV2::INIT;
instance.get(MalosEyeConfig::new)
}
}
impl ::protobuf::Clear for MalosEyeConfig {
fn clear(&mut self) {
self.camera_config.clear();
self.face_config.clear();
self.detection_server_config.clear();
self.object_to_detect.clear();
self.action = EnumMalosAction::MALOS_ACTION_NOT_DEFINED;
self.models.clear();
self.config.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for MalosEyeConfig {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for MalosEyeConfig {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CameraConfig {
pub source: ::std::string::String,
pub camera_id: i32,
pub width: i32,
pub height: i32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CameraConfig {
fn default() -> &'a CameraConfig {
<CameraConfig as ::protobuf::Message>::default_instance()
}
}
impl CameraConfig {
pub fn new() -> CameraConfig {
::std::default::Default::default()
}
pub fn get_source(&self) -> &str {
&self.source
}
pub fn clear_source(&mut self) {
self.source.clear();
}
pub fn set_source(&mut self, v: ::std::string::String) {
self.source = v;
}
pub fn mut_source(&mut self) -> &mut ::std::string::String {
&mut self.source
}
pub fn take_source(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.source, ::std::string::String::new())
}
pub fn get_camera_id(&self) -> i32 {
self.camera_id
}
pub fn clear_camera_id(&mut self) {
self.camera_id = 0;
}
pub fn set_camera_id(&mut self, v: i32) {
self.camera_id = v;
}
pub fn get_width(&self) -> i32 {
self.width
}
pub fn clear_width(&mut self) {
self.width = 0;
}
pub fn set_width(&mut self, v: i32) {
self.width = v;
}
pub fn get_height(&self) -> i32 {
self.height
}
pub fn clear_height(&mut self) {
self.height = 0;
}
pub fn set_height(&mut self, v: i32) {
self.height = v;
}
}
impl ::protobuf::Message for CameraConfig {
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 {
4 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.source)?;
},
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.camera_id = 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.width = 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.height = tmp;
},
_ => {
::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.source.is_empty() {
my_size += ::protobuf::rt::string_size(4, &self.source);
}
if self.camera_id != 0 {
my_size += ::protobuf::rt::value_size(1, self.camera_id, ::protobuf::wire_format::WireTypeVarint);
}
if self.width != 0 {
my_size += ::protobuf::rt::value_size(2, self.width, ::protobuf::wire_format::WireTypeVarint);
}
if self.height != 0 {
my_size += ::protobuf::rt::value_size(3, self.height, ::protobuf::wire_format::WireTypeVarint);
}
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.source.is_empty() {
os.write_string(4, &self.source)?;
}
if self.camera_id != 0 {
os.write_int32(1, self.camera_id)?;
}
if self.width != 0 {
os.write_int32(2, self.width)?;
}
if self.height != 0 {
os.write_int32(3, self.height)?;
}
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() -> CameraConfig {
CameraConfig::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>(
"source",
|m: &CameraConfig| { &m.source },
|m: &mut CameraConfig| { &mut m.source },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"camera_id",
|m: &CameraConfig| { &m.camera_id },
|m: &mut CameraConfig| { &mut m.camera_id },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"width",
|m: &CameraConfig| { &m.width },
|m: &mut CameraConfig| { &mut m.width },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"height",
|m: &CameraConfig| { &m.height },
|m: &mut CameraConfig| { &mut m.height },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CameraConfig>(
"CameraConfig",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CameraConfig {
static instance: ::protobuf::rt::LazyV2<CameraConfig> = ::protobuf::rt::LazyV2::INIT;
instance.get(CameraConfig::new)
}
}
impl ::protobuf::Clear for CameraConfig {
fn clear(&mut self) {
self.source.clear();
self.camera_id = 0;
self.width = 0;
self.height = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CameraConfig {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CameraConfig {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct DetectionServerConfig {
pub detection_server_address: ::std::string::String,
pub detection_server_timeout: i32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a DetectionServerConfig {
fn default() -> &'a DetectionServerConfig {
<DetectionServerConfig as ::protobuf::Message>::default_instance()
}
}
impl DetectionServerConfig {
pub fn new() -> DetectionServerConfig {
::std::default::Default::default()
}
pub fn get_detection_server_address(&self) -> &str {
&self.detection_server_address
}
pub fn clear_detection_server_address(&mut self) {
self.detection_server_address.clear();
}
pub fn set_detection_server_address(&mut self, v: ::std::string::String) {
self.detection_server_address = v;
}
pub fn mut_detection_server_address(&mut self) -> &mut ::std::string::String {
&mut self.detection_server_address
}
pub fn take_detection_server_address(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.detection_server_address, ::std::string::String::new())
}
pub fn get_detection_server_timeout(&self) -> i32 {
self.detection_server_timeout
}
pub fn clear_detection_server_timeout(&mut self) {
self.detection_server_timeout = 0;
}
pub fn set_detection_server_timeout(&mut self, v: i32) {
self.detection_server_timeout = v;
}
}
impl ::protobuf::Message for DetectionServerConfig {
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.detection_server_address)?;
},
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.detection_server_timeout = tmp;
},
_ => {
::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.detection_server_address.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.detection_server_address);
}
if self.detection_server_timeout != 0 {
my_size += ::protobuf::rt::value_size(2, self.detection_server_timeout, ::protobuf::wire_format::WireTypeVarint);
}
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.detection_server_address.is_empty() {
os.write_string(1, &self.detection_server_address)?;
}
if self.detection_server_timeout != 0 {
os.write_int32(2, self.detection_server_timeout)?;
}
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() -> DetectionServerConfig {
DetectionServerConfig::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>(
"detection_server_address",
|m: &DetectionServerConfig| { &m.detection_server_address },
|m: &mut DetectionServerConfig| { &mut m.detection_server_address },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"detection_server_timeout",
|m: &DetectionServerConfig| { &m.detection_server_timeout },
|m: &mut DetectionServerConfig| { &mut m.detection_server_timeout },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<DetectionServerConfig>(
"DetectionServerConfig",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static DetectionServerConfig {
static instance: ::protobuf::rt::LazyV2<DetectionServerConfig> = ::protobuf::rt::LazyV2::INIT;
instance.get(DetectionServerConfig::new)
}
}
impl ::protobuf::Clear for DetectionServerConfig {
fn clear(&mut self) {
self.detection_server_address.clear();
self.detection_server_timeout = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for DetectionServerConfig {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for DetectionServerConfig {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct FaceConfig {
pub models_path: ::std::string::String,
pub send_slow: bool,
pub send_text_proto: bool,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a FaceConfig {
fn default() -> &'a FaceConfig {
<FaceConfig as ::protobuf::Message>::default_instance()
}
}
impl FaceConfig {
pub fn new() -> FaceConfig {
::std::default::Default::default()
}
pub fn get_models_path(&self) -> &str {
&self.models_path
}
pub fn clear_models_path(&mut self) {
self.models_path.clear();
}
pub fn set_models_path(&mut self, v: ::std::string::String) {
self.models_path = v;
}
pub fn mut_models_path(&mut self) -> &mut ::std::string::String {
&mut self.models_path
}
pub fn take_models_path(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.models_path, ::std::string::String::new())
}
pub fn get_send_slow(&self) -> bool {
self.send_slow
}
pub fn clear_send_slow(&mut self) {
self.send_slow = false;
}
pub fn set_send_slow(&mut self, v: bool) {
self.send_slow = v;
}
pub fn get_send_text_proto(&self) -> bool {
self.send_text_proto
}
pub fn clear_send_text_proto(&mut self) {
self.send_text_proto = false;
}
pub fn set_send_text_proto(&mut self, v: bool) {
self.send_text_proto = v;
}
}
impl ::protobuf::Message for FaceConfig {
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.models_path)?;
},
2 => {
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.send_slow = 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.send_text_proto = tmp;
},
_ => {
::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.models_path.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.models_path);
}
if self.send_slow != false {
my_size += 2;
}
if self.send_text_proto != false {
my_size += 2;
}
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.models_path.is_empty() {
os.write_string(1, &self.models_path)?;
}
if self.send_slow != false {
os.write_bool(2, self.send_slow)?;
}
if self.send_text_proto != false {
os.write_bool(3, self.send_text_proto)?;
}
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() -> FaceConfig {
FaceConfig::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>(
"models_path",
|m: &FaceConfig| { &m.models_path },
|m: &mut FaceConfig| { &mut m.models_path },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"send_slow",
|m: &FaceConfig| { &m.send_slow },
|m: &mut FaceConfig| { &mut m.send_slow },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"send_text_proto",
|m: &FaceConfig| { &m.send_text_proto },
|m: &mut FaceConfig| { &mut m.send_text_proto },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<FaceConfig>(
"FaceConfig",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static FaceConfig {
static instance: ::protobuf::rt::LazyV2<FaceConfig> = ::protobuf::rt::LazyV2::INIT;
instance.get(FaceConfig::new)
}
}
impl ::protobuf::Clear for FaceConfig {
fn clear(&mut self) {
self.models_path.clear();
self.send_slow = false;
self.send_text_proto = false;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for FaceConfig {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for FaceConfig {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum EnumMalosAction {
MALOS_ACTION_NOT_DEFINED = 0,
START_DETECTION = 1,
STOP_DETECTION = 2,
RESTART_DETECTION = 3,
CAPTURE_PREVIEW = 4,
START_STREAMING = 5,
STOP_STREAMING = 6,
}
impl ::protobuf::ProtobufEnum for EnumMalosAction {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<EnumMalosAction> {
match value {
0 => ::std::option::Option::Some(EnumMalosAction::MALOS_ACTION_NOT_DEFINED),
1 => ::std::option::Option::Some(EnumMalosAction::START_DETECTION),
2 => ::std::option::Option::Some(EnumMalosAction::STOP_DETECTION),
3 => ::std::option::Option::Some(EnumMalosAction::RESTART_DETECTION),
4 => ::std::option::Option::Some(EnumMalosAction::CAPTURE_PREVIEW),
5 => ::std::option::Option::Some(EnumMalosAction::START_STREAMING),
6 => ::std::option::Option::Some(EnumMalosAction::STOP_STREAMING),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [EnumMalosAction] = &[
EnumMalosAction::MALOS_ACTION_NOT_DEFINED,
EnumMalosAction::START_DETECTION,
EnumMalosAction::STOP_DETECTION,
EnumMalosAction::RESTART_DETECTION,
EnumMalosAction::CAPTURE_PREVIEW,
EnumMalosAction::START_STREAMING,
EnumMalosAction::STOP_STREAMING,
];
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::<EnumMalosAction>("EnumMalosAction", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for EnumMalosAction {
}
impl ::std::default::Default for EnumMalosAction {
fn default() -> Self {
EnumMalosAction::MALOS_ACTION_NOT_DEFINED
}
}
impl ::protobuf::reflect::ProtobufValue for EnumMalosAction {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum EnumMalosEyeDetectionType {
MALOS_DETECTION_TYPE_NOT_DEFINED = 0,
STOP = 1,
FACE = 20,
FACE_DEMOGRAPHICS = 21,
FACE_DESCRIPTOR = 30,
HAND_THUMB_UP = 40,
HAND_PALM = 41,
HAND_PINCH = 42,
HAND_FIST = 43,
}
impl ::protobuf::ProtobufEnum for EnumMalosEyeDetectionType {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<EnumMalosEyeDetectionType> {
match value {
0 => ::std::option::Option::Some(EnumMalosEyeDetectionType::MALOS_DETECTION_TYPE_NOT_DEFINED),
1 => ::std::option::Option::Some(EnumMalosEyeDetectionType::STOP),
20 => ::std::option::Option::Some(EnumMalosEyeDetectionType::FACE),
21 => ::std::option::Option::Some(EnumMalosEyeDetectionType::FACE_DEMOGRAPHICS),
30 => ::std::option::Option::Some(EnumMalosEyeDetectionType::FACE_DESCRIPTOR),
40 => ::std::option::Option::Some(EnumMalosEyeDetectionType::HAND_THUMB_UP),
41 => ::std::option::Option::Some(EnumMalosEyeDetectionType::HAND_PALM),
42 => ::std::option::Option::Some(EnumMalosEyeDetectionType::HAND_PINCH),
43 => ::std::option::Option::Some(EnumMalosEyeDetectionType::HAND_FIST),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [EnumMalosEyeDetectionType] = &[
EnumMalosEyeDetectionType::MALOS_DETECTION_TYPE_NOT_DEFINED,
EnumMalosEyeDetectionType::STOP,
EnumMalosEyeDetectionType::FACE,
EnumMalosEyeDetectionType::FACE_DEMOGRAPHICS,
EnumMalosEyeDetectionType::FACE_DESCRIPTOR,
EnumMalosEyeDetectionType::HAND_THUMB_UP,
EnumMalosEyeDetectionType::HAND_PALM,
EnumMalosEyeDetectionType::HAND_PINCH,
EnumMalosEyeDetectionType::HAND_FIST,
];
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::<EnumMalosEyeDetectionType>("EnumMalosEyeDetectionType", file_descriptor_proto())
})
}
}
impl ::std::marker::Copy for EnumMalosEyeDetectionType {
}
impl ::std::default::Default for EnumMalosEyeDetectionType {
fn default() -> Self {
EnumMalosEyeDetectionType::MALOS_DETECTION_TYPE_NOT_DEFINED
}
}
impl ::protobuf::reflect::ProtobufValue for EnumMalosEyeDetectionType {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n!matrix_io/malos/v1/maloseye.proto\x12\x1bmatrix_io.malos.v1.maloseye\
\x1a\x1dmatrix_io/common/entity.proto\"\xb2\x04\n\x0eMalosEyeConfig\x12P\
\n\rcamera_config\x18\x01\x20\x01(\x0b2).matrix_io.malos.v1.maloseye.Cam\
eraConfigR\x0ccameraConfigB\0\x12J\n\x0bface_config\x18\x02\x20\x01(\x0b\
2'.matrix_io.malos.v1.maloseye.FaceConfigR\nfaceConfigB\0\x12l\n\x17dete\
ction_server_config\x18\x04\x20\x01(\x0b22.matrix_io.malos.v1.maloseye.D\
etectionServerConfigR\x15detectionServerConfigB\0\x12b\n\x10object_to_de\
tect\x18\x15\x20\x03(\x0e26.matrix_io.malos.v1.maloseye.EnumMalosEyeDete\
ctionTypeR\x0eobjectToDetectB\0\x12F\n\x06action\x18\x05\x20\x01(\x0e2,.\
matrix_io.malos.v1.maloseye.EnumMalosActionR\x06actionB\0\x122\n\x06mode\
ls\x18\x06\x20\x03(\x0b2\x18.matrix_io.common.EntityR\x06modelsB\0\x122\
\n\x06config\x18\x07\x20\x01(\x0b2\x18.matrix_io.common.EntityR\x06confi\
gB\0:\0\"{\n\x0cCameraConfig\x12\x18\n\x06source\x18\x04\x20\x01(\tR\x06\
sourceB\0\x12\x1d\n\tcamera_id\x18\x01\x20\x01(\x05R\x08cameraIdB\0\x12\
\x16\n\x05width\x18\x02\x20\x01(\x05R\x05widthB\0\x12\x18\n\x06height\
\x18\x03\x20\x01(\x05R\x06heightB\0:\0\"\x91\x01\n\x15DetectionServerCon\
fig\x12:\n\x18detection_server_address\x18\x01\x20\x01(\tR\x16detectionS\
erverAddressB\0\x12:\n\x18detection_server_timeout\x18\x02\x20\x01(\x05R\
\x16detectionServerTimeoutB\0:\0\"z\n\nFaceConfig\x12!\n\x0bmodels_path\
\x18\x01\x20\x01(\tR\nmodelsPathB\0\x12\x1d\n\tsend_slow\x18\x02\x20\x01\
(\x08R\x08sendSlowB\0\x12(\n\x0fsend_text_proto\x18\x03\x20\x01(\x08R\rs\
endTextProtoB\0:\0*\xaf\x01\n\x0fEnumMalosAction\x12\x1c\n\x18MALOS_ACTI\
ON_NOT_DEFINED\x10\0\x12\x13\n\x0fSTART_DETECTION\x10\x01\x12\x12\n\x0eS\
TOP_DETECTION\x10\x02\x12\x15\n\x11RESTART_DETECTION\x10\x03\x12\x13\n\
\x0fCAPTURE_PREVIEW\x10\x04\x12\x13\n\x0fSTART_STREAMING\x10\x05\x12\x12\
\n\x0eSTOP_STREAMING\x10\x06\x1a\0*\xc4\x01\n\x19EnumMalosEyeDetectionTy\
pe\x12$\n\x20MALOS_DETECTION_TYPE_NOT_DEFINED\x10\0\x12\x08\n\x04STOP\
\x10\x01\x12\x08\n\x04FACE\x10\x14\x12\x15\n\x11FACE_DEMOGRAPHICS\x10\
\x15\x12\x13\n\x0fFACE_DESCRIPTOR\x10\x1e\x12\x11\n\rHAND_THUMB_UP\x10(\
\x12\r\n\tHAND_PALM\x10)\x12\x0e\n\nHAND_PINCH\x10*\x12\r\n\tHAND_FIST\
\x10+\x1a\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()
})
}