| // This file is generated by rust-protobuf 3.2.0. Do not edit |
| // .proto file is parsed by protoc 3.21.12 |
| // @generated |
| |
| // https://github.com/rust-lang/rust-clippy/issues/702 |
| #![allow(unknown_lints)] |
| #![allow(clippy::all)] |
| |
| #![allow(unused_attributes)] |
| #![cfg_attr(rustfmt, rustfmt::skip)] |
| |
| #![allow(box_pointers)] |
| #![allow(dead_code)] |
| #![allow(missing_docs)] |
| #![allow(non_camel_case_types)] |
| #![allow(non_snake_case)] |
| #![allow(non_upper_case_globals)] |
| #![allow(trivial_casts)] |
| #![allow(unused_results)] |
| #![allow(unused_mut)] |
| |
| //! Generated file from `model.proto` |
| |
| /// Generated files are compatible only with the same version |
| /// of protobuf runtime. |
| const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_2_0; |
| |
| #[derive(PartialEq,Clone,Default,Debug)] |
| // @@protoc_insertion_point(message:netsim.model.Position) |
| pub struct Position { |
| // message fields |
| // @@protoc_insertion_point(field:netsim.model.Position.x) |
| pub x: f32, |
| // @@protoc_insertion_point(field:netsim.model.Position.y) |
| pub y: f32, |
| // @@protoc_insertion_point(field:netsim.model.Position.z) |
| pub z: f32, |
| // special fields |
| // @@protoc_insertion_point(special_field:netsim.model.Position.special_fields) |
| pub special_fields: ::protobuf::SpecialFields, |
| } |
| |
| impl<'a> ::std::default::Default for &'a Position { |
| fn default() -> &'a Position { |
| <Position as ::protobuf::Message>::default_instance() |
| } |
| } |
| |
| impl Position { |
| pub fn new() -> Position { |
| ::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::<_, _>( |
| "x", |
| |m: &Position| { &m.x }, |
| |m: &mut Position| { &mut m.x }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "y", |
| |m: &Position| { &m.y }, |
| |m: &mut Position| { &mut m.y }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "z", |
| |m: &Position| { &m.z }, |
| |m: &mut Position| { &mut m.z }, |
| )); |
| ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Position>( |
| "Position", |
| fields, |
| oneofs, |
| ) |
| } |
| } |
| |
| impl ::protobuf::Message for Position { |
| const NAME: &'static str = "Position"; |
| |
| 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 { |
| 13 => { |
| self.x = is.read_float()?; |
| }, |
| 21 => { |
| self.y = is.read_float()?; |
| }, |
| 29 => { |
| self.z = is.read_float()?; |
| }, |
| tag => { |
| ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; |
| }, |
| }; |
| } |
| ::std::result::Result::Ok(()) |
| } |
| |
| // Compute sizes of nested messages |
| #[allow(unused_variables)] |
| fn compute_size(&self) -> u64 { |
| let mut my_size = 0; |
| if self.x != 0. { |
| my_size += 1 + 4; |
| } |
| if self.y != 0. { |
| my_size += 1 + 4; |
| } |
| if self.z != 0. { |
| my_size += 1 + 4; |
| } |
| 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.x != 0. { |
| os.write_float(1, self.x)?; |
| } |
| if self.y != 0. { |
| os.write_float(2, self.y)?; |
| } |
| if self.z != 0. { |
| os.write_float(3, self.z)?; |
| } |
| 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() -> Position { |
| Position::new() |
| } |
| |
| fn clear(&mut self) { |
| self.x = 0.; |
| self.y = 0.; |
| self.z = 0.; |
| self.special_fields.clear(); |
| } |
| |
| fn default_instance() -> &'static Position { |
| static instance: Position = Position { |
| x: 0., |
| y: 0., |
| z: 0., |
| special_fields: ::protobuf::SpecialFields::new(), |
| }; |
| &instance |
| } |
| } |
| |
| impl ::protobuf::MessageFull for Position { |
| 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("Position").unwrap()).clone() |
| } |
| } |
| |
| impl ::std::fmt::Display for Position { |
| fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { |
| ::protobuf::text_format::fmt(self, f) |
| } |
| } |
| |
| impl ::protobuf::reflect::ProtobufValue for Position { |
| type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>; |
| } |
| |
| #[derive(PartialEq,Clone,Default,Debug)] |
| // @@protoc_insertion_point(message:netsim.model.Orientation) |
| pub struct Orientation { |
| // message fields |
| // @@protoc_insertion_point(field:netsim.model.Orientation.yaw) |
| pub yaw: f32, |
| // @@protoc_insertion_point(field:netsim.model.Orientation.pitch) |
| pub pitch: f32, |
| // @@protoc_insertion_point(field:netsim.model.Orientation.roll) |
| pub roll: f32, |
| // special fields |
| // @@protoc_insertion_point(special_field:netsim.model.Orientation.special_fields) |
| pub special_fields: ::protobuf::SpecialFields, |
| } |
| |
| impl<'a> ::std::default::Default for &'a Orientation { |
| fn default() -> &'a Orientation { |
| <Orientation as ::protobuf::Message>::default_instance() |
| } |
| } |
| |
| impl Orientation { |
| pub fn new() -> Orientation { |
| ::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::<_, _>( |
| "yaw", |
| |m: &Orientation| { &m.yaw }, |
| |m: &mut Orientation| { &mut m.yaw }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "pitch", |
| |m: &Orientation| { &m.pitch }, |
| |m: &mut Orientation| { &mut m.pitch }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "roll", |
| |m: &Orientation| { &m.roll }, |
| |m: &mut Orientation| { &mut m.roll }, |
| )); |
| ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Orientation>( |
| "Orientation", |
| fields, |
| oneofs, |
| ) |
| } |
| } |
| |
| impl ::protobuf::Message for Orientation { |
| const NAME: &'static str = "Orientation"; |
| |
| 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 { |
| 13 => { |
| self.yaw = is.read_float()?; |
| }, |
| 21 => { |
| self.pitch = is.read_float()?; |
| }, |
| 29 => { |
| self.roll = is.read_float()?; |
| }, |
| tag => { |
| ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; |
| }, |
| }; |
| } |
| ::std::result::Result::Ok(()) |
| } |
| |
| // Compute sizes of nested messages |
| #[allow(unused_variables)] |
| fn compute_size(&self) -> u64 { |
| let mut my_size = 0; |
| if self.yaw != 0. { |
| my_size += 1 + 4; |
| } |
| if self.pitch != 0. { |
| my_size += 1 + 4; |
| } |
| if self.roll != 0. { |
| my_size += 1 + 4; |
| } |
| 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.yaw != 0. { |
| os.write_float(1, self.yaw)?; |
| } |
| if self.pitch != 0. { |
| os.write_float(2, self.pitch)?; |
| } |
| if self.roll != 0. { |
| os.write_float(3, self.roll)?; |
| } |
| 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() -> Orientation { |
| Orientation::new() |
| } |
| |
| fn clear(&mut self) { |
| self.yaw = 0.; |
| self.pitch = 0.; |
| self.roll = 0.; |
| self.special_fields.clear(); |
| } |
| |
| fn default_instance() -> &'static Orientation { |
| static instance: Orientation = Orientation { |
| yaw: 0., |
| pitch: 0., |
| roll: 0., |
| special_fields: ::protobuf::SpecialFields::new(), |
| }; |
| &instance |
| } |
| } |
| |
| impl ::protobuf::MessageFull for Orientation { |
| 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("Orientation").unwrap()).clone() |
| } |
| } |
| |
| impl ::std::fmt::Display for Orientation { |
| fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { |
| ::protobuf::text_format::fmt(self, f) |
| } |
| } |
| |
| impl ::protobuf::reflect::ProtobufValue for Orientation { |
| type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>; |
| } |
| |
| #[derive(PartialEq,Clone,Default,Debug)] |
| // @@protoc_insertion_point(message:netsim.model.Chip) |
| pub struct Chip { |
| // message fields |
| // @@protoc_insertion_point(field:netsim.model.Chip.kind) |
| pub kind: ::protobuf::EnumOrUnknown<super::common::ChipKind>, |
| // @@protoc_insertion_point(field:netsim.model.Chip.id) |
| pub id: i32, |
| // @@protoc_insertion_point(field:netsim.model.Chip.name) |
| pub name: ::std::string::String, |
| // @@protoc_insertion_point(field:netsim.model.Chip.manufacturer) |
| pub manufacturer: ::std::string::String, |
| // @@protoc_insertion_point(field:netsim.model.Chip.product_name) |
| pub product_name: ::std::string::String, |
| // message oneof groups |
| pub chip: ::std::option::Option<chip::Chip>, |
| // special fields |
| // @@protoc_insertion_point(special_field:netsim.model.Chip.special_fields) |
| pub special_fields: ::protobuf::SpecialFields, |
| } |
| |
| impl<'a> ::std::default::Default for &'a Chip { |
| fn default() -> &'a Chip { |
| <Chip as ::protobuf::Message>::default_instance() |
| } |
| } |
| |
| impl Chip { |
| pub fn new() -> Chip { |
| ::std::default::Default::default() |
| } |
| |
| // .netsim.model.Chip.Bluetooth bt = 6; |
| |
| pub fn bt(&self) -> &chip::Bluetooth { |
| match self.chip { |
| ::std::option::Option::Some(chip::Chip::Bt(ref v)) => v, |
| _ => <chip::Bluetooth as ::protobuf::Message>::default_instance(), |
| } |
| } |
| |
| pub fn clear_bt(&mut self) { |
| self.chip = ::std::option::Option::None; |
| } |
| |
| pub fn has_bt(&self) -> bool { |
| match self.chip { |
| ::std::option::Option::Some(chip::Chip::Bt(..)) => true, |
| _ => false, |
| } |
| } |
| |
| // Param is passed by value, moved |
| pub fn set_bt(&mut self, v: chip::Bluetooth) { |
| self.chip = ::std::option::Option::Some(chip::Chip::Bt(v)) |
| } |
| |
| // Mutable pointer to the field. |
| pub fn mut_bt(&mut self) -> &mut chip::Bluetooth { |
| if let ::std::option::Option::Some(chip::Chip::Bt(_)) = self.chip { |
| } else { |
| self.chip = ::std::option::Option::Some(chip::Chip::Bt(chip::Bluetooth::new())); |
| } |
| match self.chip { |
| ::std::option::Option::Some(chip::Chip::Bt(ref mut v)) => v, |
| _ => panic!(), |
| } |
| } |
| |
| // Take field |
| pub fn take_bt(&mut self) -> chip::Bluetooth { |
| if self.has_bt() { |
| match self.chip.take() { |
| ::std::option::Option::Some(chip::Chip::Bt(v)) => v, |
| _ => panic!(), |
| } |
| } else { |
| chip::Bluetooth::new() |
| } |
| } |
| |
| // .netsim.model.Chip.Radio uwb = 7; |
| |
| pub fn uwb(&self) -> &chip::Radio { |
| match self.chip { |
| ::std::option::Option::Some(chip::Chip::Uwb(ref v)) => v, |
| _ => <chip::Radio as ::protobuf::Message>::default_instance(), |
| } |
| } |
| |
| pub fn clear_uwb(&mut self) { |
| self.chip = ::std::option::Option::None; |
| } |
| |
| pub fn has_uwb(&self) -> bool { |
| match self.chip { |
| ::std::option::Option::Some(chip::Chip::Uwb(..)) => true, |
| _ => false, |
| } |
| } |
| |
| // Param is passed by value, moved |
| pub fn set_uwb(&mut self, v: chip::Radio) { |
| self.chip = ::std::option::Option::Some(chip::Chip::Uwb(v)) |
| } |
| |
| // Mutable pointer to the field. |
| pub fn mut_uwb(&mut self) -> &mut chip::Radio { |
| if let ::std::option::Option::Some(chip::Chip::Uwb(_)) = self.chip { |
| } else { |
| self.chip = ::std::option::Option::Some(chip::Chip::Uwb(chip::Radio::new())); |
| } |
| match self.chip { |
| ::std::option::Option::Some(chip::Chip::Uwb(ref mut v)) => v, |
| _ => panic!(), |
| } |
| } |
| |
| // Take field |
| pub fn take_uwb(&mut self) -> chip::Radio { |
| if self.has_uwb() { |
| match self.chip.take() { |
| ::std::option::Option::Some(chip::Chip::Uwb(v)) => v, |
| _ => panic!(), |
| } |
| } else { |
| chip::Radio::new() |
| } |
| } |
| |
| // .netsim.model.Chip.Radio wifi = 8; |
| |
| pub fn wifi(&self) -> &chip::Radio { |
| match self.chip { |
| ::std::option::Option::Some(chip::Chip::Wifi(ref v)) => v, |
| _ => <chip::Radio as ::protobuf::Message>::default_instance(), |
| } |
| } |
| |
| pub fn clear_wifi(&mut self) { |
| self.chip = ::std::option::Option::None; |
| } |
| |
| pub fn has_wifi(&self) -> bool { |
| match self.chip { |
| ::std::option::Option::Some(chip::Chip::Wifi(..)) => true, |
| _ => false, |
| } |
| } |
| |
| // Param is passed by value, moved |
| pub fn set_wifi(&mut self, v: chip::Radio) { |
| self.chip = ::std::option::Option::Some(chip::Chip::Wifi(v)) |
| } |
| |
| // Mutable pointer to the field. |
| pub fn mut_wifi(&mut self) -> &mut chip::Radio { |
| if let ::std::option::Option::Some(chip::Chip::Wifi(_)) = self.chip { |
| } else { |
| self.chip = ::std::option::Option::Some(chip::Chip::Wifi(chip::Radio::new())); |
| } |
| match self.chip { |
| ::std::option::Option::Some(chip::Chip::Wifi(ref mut v)) => v, |
| _ => panic!(), |
| } |
| } |
| |
| // Take field |
| pub fn take_wifi(&mut self) -> chip::Radio { |
| if self.has_wifi() { |
| match self.chip.take() { |
| ::std::option::Option::Some(chip::Chip::Wifi(v)) => v, |
| _ => panic!(), |
| } |
| } else { |
| chip::Radio::new() |
| } |
| } |
| |
| fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { |
| let mut fields = ::std::vec::Vec::with_capacity(8); |
| let mut oneofs = ::std::vec::Vec::with_capacity(1); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "kind", |
| |m: &Chip| { &m.kind }, |
| |m: &mut Chip| { &mut m.kind }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "id", |
| |m: &Chip| { &m.id }, |
| |m: &mut Chip| { &mut m.id }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "name", |
| |m: &Chip| { &m.name }, |
| |m: &mut Chip| { &mut m.name }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "manufacturer", |
| |m: &Chip| { &m.manufacturer }, |
| |m: &mut Chip| { &mut m.manufacturer }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "product_name", |
| |m: &Chip| { &m.product_name }, |
| |m: &mut Chip| { &mut m.product_name }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, chip::Bluetooth>( |
| "bt", |
| Chip::has_bt, |
| Chip::bt, |
| Chip::mut_bt, |
| Chip::set_bt, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, chip::Radio>( |
| "uwb", |
| Chip::has_uwb, |
| Chip::uwb, |
| Chip::mut_uwb, |
| Chip::set_uwb, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_oneof_message_has_get_mut_set_accessor::<_, chip::Radio>( |
| "wifi", |
| Chip::has_wifi, |
| Chip::wifi, |
| Chip::mut_wifi, |
| Chip::set_wifi, |
| )); |
| oneofs.push(chip::Chip::generated_oneof_descriptor_data()); |
| ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Chip>( |
| "Chip", |
| fields, |
| oneofs, |
| ) |
| } |
| } |
| |
| impl ::protobuf::Message for Chip { |
| const NAME: &'static str = "Chip"; |
| |
| 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.kind = is.read_enum_or_unknown()?; |
| }, |
| 16 => { |
| self.id = is.read_int32()?; |
| }, |
| 26 => { |
| self.name = is.read_string()?; |
| }, |
| 34 => { |
| self.manufacturer = is.read_string()?; |
| }, |
| 42 => { |
| self.product_name = is.read_string()?; |
| }, |
| 50 => { |
| self.chip = ::std::option::Option::Some(chip::Chip::Bt(is.read_message()?)); |
| }, |
| 58 => { |
| self.chip = ::std::option::Option::Some(chip::Chip::Uwb(is.read_message()?)); |
| }, |
| 66 => { |
| self.chip = ::std::option::Option::Some(chip::Chip::Wifi(is.read_message()?)); |
| }, |
| tag => { |
| ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; |
| }, |
| }; |
| } |
| ::std::result::Result::Ok(()) |
| } |
| |
| // Compute sizes of nested messages |
| #[allow(unused_variables)] |
| fn compute_size(&self) -> u64 { |
| let mut my_size = 0; |
| if self.kind != ::protobuf::EnumOrUnknown::new(super::common::ChipKind::UNSPECIFIED) { |
| my_size += ::protobuf::rt::int32_size(1, self.kind.value()); |
| } |
| if self.id != 0 { |
| my_size += ::protobuf::rt::int32_size(2, self.id); |
| } |
| if !self.name.is_empty() { |
| my_size += ::protobuf::rt::string_size(3, &self.name); |
| } |
| if !self.manufacturer.is_empty() { |
| my_size += ::protobuf::rt::string_size(4, &self.manufacturer); |
| } |
| if !self.product_name.is_empty() { |
| my_size += ::protobuf::rt::string_size(5, &self.product_name); |
| } |
| if let ::std::option::Option::Some(ref v) = self.chip { |
| match v { |
| &chip::Chip::Bt(ref v) => { |
| let len = v.compute_size(); |
| my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; |
| }, |
| &chip::Chip::Uwb(ref v) => { |
| let len = v.compute_size(); |
| my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; |
| }, |
| &chip::Chip::Wifi(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 self.kind != ::protobuf::EnumOrUnknown::new(super::common::ChipKind::UNSPECIFIED) { |
| os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.kind))?; |
| } |
| if self.id != 0 { |
| os.write_int32(2, self.id)?; |
| } |
| if !self.name.is_empty() { |
| os.write_string(3, &self.name)?; |
| } |
| if !self.manufacturer.is_empty() { |
| os.write_string(4, &self.manufacturer)?; |
| } |
| if !self.product_name.is_empty() { |
| os.write_string(5, &self.product_name)?; |
| } |
| if let ::std::option::Option::Some(ref v) = self.chip { |
| match v { |
| &chip::Chip::Bt(ref v) => { |
| ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?; |
| }, |
| &chip::Chip::Uwb(ref v) => { |
| ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?; |
| }, |
| &chip::Chip::Wifi(ref v) => { |
| ::protobuf::rt::write_message_field_with_cached_size(8, 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() -> Chip { |
| Chip::new() |
| } |
| |
| fn clear(&mut self) { |
| self.kind = ::protobuf::EnumOrUnknown::new(super::common::ChipKind::UNSPECIFIED); |
| self.id = 0; |
| self.name.clear(); |
| self.manufacturer.clear(); |
| self.product_name.clear(); |
| self.chip = ::std::option::Option::None; |
| self.chip = ::std::option::Option::None; |
| self.chip = ::std::option::Option::None; |
| self.special_fields.clear(); |
| } |
| |
| fn default_instance() -> &'static Chip { |
| static instance: Chip = Chip { |
| kind: ::protobuf::EnumOrUnknown::from_i32(0), |
| id: 0, |
| name: ::std::string::String::new(), |
| manufacturer: ::std::string::String::new(), |
| product_name: ::std::string::String::new(), |
| chip: ::std::option::Option::None, |
| special_fields: ::protobuf::SpecialFields::new(), |
| }; |
| &instance |
| } |
| } |
| |
| impl ::protobuf::MessageFull for Chip { |
| 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("Chip").unwrap()).clone() |
| } |
| } |
| |
| impl ::std::fmt::Display for Chip { |
| fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { |
| ::protobuf::text_format::fmt(self, f) |
| } |
| } |
| |
| impl ::protobuf::reflect::ProtobufValue for Chip { |
| type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>; |
| } |
| |
| /// Nested message and enums of message `Chip` |
| pub mod chip { |
| |
| #[derive(Clone,PartialEq,Debug)] |
| #[non_exhaustive] |
| // @@protoc_insertion_point(oneof:netsim.model.Chip.chip) |
| pub enum Chip { |
| // @@protoc_insertion_point(oneof_field:netsim.model.Chip.bt) |
| Bt(Bluetooth), |
| // @@protoc_insertion_point(oneof_field:netsim.model.Chip.uwb) |
| Uwb(Radio), |
| // @@protoc_insertion_point(oneof_field:netsim.model.Chip.wifi) |
| Wifi(Radio), |
| } |
| |
| impl ::protobuf::Oneof for Chip { |
| } |
| |
| impl ::protobuf::OneofFull for Chip { |
| fn descriptor() -> ::protobuf::reflect::OneofDescriptor { |
| static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::OneofDescriptor> = ::protobuf::rt::Lazy::new(); |
| descriptor.get(|| <super::Chip as ::protobuf::MessageFull>::descriptor().oneof_by_name("chip").unwrap()).clone() |
| } |
| } |
| |
| impl Chip { |
| pub(in super) fn generated_oneof_descriptor_data() -> ::protobuf::reflect::GeneratedOneofDescriptorData { |
| ::protobuf::reflect::GeneratedOneofDescriptorData::new::<Chip>("chip") |
| } |
| } |
| #[derive(PartialEq,Clone,Default,Debug)] |
| // @@protoc_insertion_point(message:netsim.model.Chip.Radio) |
| pub struct Radio { |
| // message fields |
| // @@protoc_insertion_point(field:netsim.model.Chip.Radio.state) |
| pub state: ::protobuf::EnumOrUnknown<super::State>, |
| // @@protoc_insertion_point(field:netsim.model.Chip.Radio.range) |
| pub range: f32, |
| // @@protoc_insertion_point(field:netsim.model.Chip.Radio.tx_count) |
| pub tx_count: i32, |
| // @@protoc_insertion_point(field:netsim.model.Chip.Radio.rx_count) |
| pub rx_count: i32, |
| // special fields |
| // @@protoc_insertion_point(special_field:netsim.model.Chip.Radio.special_fields) |
| pub special_fields: ::protobuf::SpecialFields, |
| } |
| |
| impl<'a> ::std::default::Default for &'a Radio { |
| fn default() -> &'a Radio { |
| <Radio as ::protobuf::Message>::default_instance() |
| } |
| } |
| |
| impl Radio { |
| pub fn new() -> Radio { |
| ::std::default::Default::default() |
| } |
| |
| pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { |
| let mut fields = ::std::vec::Vec::with_capacity(4); |
| let mut oneofs = ::std::vec::Vec::with_capacity(0); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "state", |
| |m: &Radio| { &m.state }, |
| |m: &mut Radio| { &mut m.state }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "range", |
| |m: &Radio| { &m.range }, |
| |m: &mut Radio| { &mut m.range }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "tx_count", |
| |m: &Radio| { &m.tx_count }, |
| |m: &mut Radio| { &mut m.tx_count }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "rx_count", |
| |m: &Radio| { &m.rx_count }, |
| |m: &mut Radio| { &mut m.rx_count }, |
| )); |
| ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Radio>( |
| "Chip.Radio", |
| fields, |
| oneofs, |
| ) |
| } |
| } |
| |
| impl ::protobuf::Message for Radio { |
| const NAME: &'static str = "Radio"; |
| |
| 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.state = is.read_enum_or_unknown()?; |
| }, |
| 21 => { |
| self.range = is.read_float()?; |
| }, |
| 24 => { |
| self.tx_count = is.read_int32()?; |
| }, |
| 32 => { |
| self.rx_count = is.read_int32()?; |
| }, |
| tag => { |
| ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; |
| }, |
| }; |
| } |
| ::std::result::Result::Ok(()) |
| } |
| |
| // Compute sizes of nested messages |
| #[allow(unused_variables)] |
| fn compute_size(&self) -> u64 { |
| let mut my_size = 0; |
| if self.state != ::protobuf::EnumOrUnknown::new(super::State::UNKNOWN) { |
| my_size += ::protobuf::rt::int32_size(1, self.state.value()); |
| } |
| if self.range != 0. { |
| my_size += 1 + 4; |
| } |
| if self.tx_count != 0 { |
| my_size += ::protobuf::rt::int32_size(3, self.tx_count); |
| } |
| if self.rx_count != 0 { |
| my_size += ::protobuf::rt::int32_size(4, self.rx_count); |
| } |
| 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.state != ::protobuf::EnumOrUnknown::new(super::State::UNKNOWN) { |
| os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.state))?; |
| } |
| if self.range != 0. { |
| os.write_float(2, self.range)?; |
| } |
| if self.tx_count != 0 { |
| os.write_int32(3, self.tx_count)?; |
| } |
| if self.rx_count != 0 { |
| os.write_int32(4, self.rx_count)?; |
| } |
| 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() -> Radio { |
| Radio::new() |
| } |
| |
| fn clear(&mut self) { |
| self.state = ::protobuf::EnumOrUnknown::new(super::State::UNKNOWN); |
| self.range = 0.; |
| self.tx_count = 0; |
| self.rx_count = 0; |
| self.special_fields.clear(); |
| } |
| |
| fn default_instance() -> &'static Radio { |
| static instance: Radio = Radio { |
| state: ::protobuf::EnumOrUnknown::from_i32(0), |
| range: 0., |
| tx_count: 0, |
| rx_count: 0, |
| special_fields: ::protobuf::SpecialFields::new(), |
| }; |
| &instance |
| } |
| } |
| |
| impl ::protobuf::MessageFull for Radio { |
| fn descriptor() -> ::protobuf::reflect::MessageDescriptor { |
| static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); |
| descriptor.get(|| super::file_descriptor().message_by_package_relative_name("Chip.Radio").unwrap()).clone() |
| } |
| } |
| |
| impl ::std::fmt::Display for Radio { |
| fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { |
| ::protobuf::text_format::fmt(self, f) |
| } |
| } |
| |
| impl ::protobuf::reflect::ProtobufValue for Radio { |
| type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>; |
| } |
| |
| #[derive(PartialEq,Clone,Default,Debug)] |
| // @@protoc_insertion_point(message:netsim.model.Chip.Bluetooth) |
| pub struct Bluetooth { |
| // message fields |
| // @@protoc_insertion_point(field:netsim.model.Chip.Bluetooth.low_energy) |
| pub low_energy: ::protobuf::MessageField<Radio>, |
| // @@protoc_insertion_point(field:netsim.model.Chip.Bluetooth.classic) |
| pub classic: ::protobuf::MessageField<Radio>, |
| // special fields |
| // @@protoc_insertion_point(special_field:netsim.model.Chip.Bluetooth.special_fields) |
| pub special_fields: ::protobuf::SpecialFields, |
| } |
| |
| impl<'a> ::std::default::Default for &'a Bluetooth { |
| fn default() -> &'a Bluetooth { |
| <Bluetooth as ::protobuf::Message>::default_instance() |
| } |
| } |
| |
| impl Bluetooth { |
| pub fn new() -> Bluetooth { |
| ::std::default::Default::default() |
| } |
| |
| pub(in super) 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_message_field_accessor::<_, Radio>( |
| "low_energy", |
| |m: &Bluetooth| { &m.low_energy }, |
| |m: &mut Bluetooth| { &mut m.low_energy }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Radio>( |
| "classic", |
| |m: &Bluetooth| { &m.classic }, |
| |m: &mut Bluetooth| { &mut m.classic }, |
| )); |
| ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Bluetooth>( |
| "Chip.Bluetooth", |
| fields, |
| oneofs, |
| ) |
| } |
| } |
| |
| impl ::protobuf::Message for Bluetooth { |
| const NAME: &'static str = "Bluetooth"; |
| |
| 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 => { |
| ::protobuf::rt::read_singular_message_into_field(is, &mut self.low_energy)?; |
| }, |
| 18 => { |
| ::protobuf::rt::read_singular_message_into_field(is, &mut self.classic)?; |
| }, |
| tag => { |
| ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; |
| }, |
| }; |
| } |
| ::std::result::Result::Ok(()) |
| } |
| |
| // Compute sizes of nested messages |
| #[allow(unused_variables)] |
| fn compute_size(&self) -> u64 { |
| let mut my_size = 0; |
| if let Some(v) = self.low_energy.as_ref() { |
| let len = v.compute_size(); |
| my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; |
| } |
| if let Some(v) = self.classic.as_ref() { |
| 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 Some(v) = self.low_energy.as_ref() { |
| ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?; |
| } |
| if let Some(v) = self.classic.as_ref() { |
| ::protobuf::rt::write_message_field_with_cached_size(2, 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() -> Bluetooth { |
| Bluetooth::new() |
| } |
| |
| fn clear(&mut self) { |
| self.low_energy.clear(); |
| self.classic.clear(); |
| self.special_fields.clear(); |
| } |
| |
| fn default_instance() -> &'static Bluetooth { |
| static instance: Bluetooth = Bluetooth { |
| low_energy: ::protobuf::MessageField::none(), |
| classic: ::protobuf::MessageField::none(), |
| special_fields: ::protobuf::SpecialFields::new(), |
| }; |
| &instance |
| } |
| } |
| |
| impl ::protobuf::MessageFull for Bluetooth { |
| fn descriptor() -> ::protobuf::reflect::MessageDescriptor { |
| static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); |
| descriptor.get(|| super::file_descriptor().message_by_package_relative_name("Chip.Bluetooth").unwrap()).clone() |
| } |
| } |
| |
| impl ::std::fmt::Display for Bluetooth { |
| fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { |
| ::protobuf::text_format::fmt(self, f) |
| } |
| } |
| |
| impl ::protobuf::reflect::ProtobufValue for Bluetooth { |
| type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>; |
| } |
| } |
| |
| #[derive(PartialEq,Clone,Default,Debug)] |
| // @@protoc_insertion_point(message:netsim.model.Device) |
| pub struct Device { |
| // message fields |
| // @@protoc_insertion_point(field:netsim.model.Device.id) |
| pub id: i32, |
| // @@protoc_insertion_point(field:netsim.model.Device.name) |
| pub name: ::std::string::String, |
| // @@protoc_insertion_point(field:netsim.model.Device.visible) |
| pub visible: bool, |
| // @@protoc_insertion_point(field:netsim.model.Device.position) |
| pub position: ::protobuf::MessageField<Position>, |
| // @@protoc_insertion_point(field:netsim.model.Device.orientation) |
| pub orientation: ::protobuf::MessageField<Orientation>, |
| // @@protoc_insertion_point(field:netsim.model.Device.chips) |
| pub chips: ::std::vec::Vec<Chip>, |
| // special fields |
| // @@protoc_insertion_point(special_field:netsim.model.Device.special_fields) |
| pub special_fields: ::protobuf::SpecialFields, |
| } |
| |
| impl<'a> ::std::default::Default for &'a Device { |
| fn default() -> &'a Device { |
| <Device as ::protobuf::Message>::default_instance() |
| } |
| } |
| |
| impl Device { |
| pub fn new() -> Device { |
| ::std::default::Default::default() |
| } |
| |
| fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { |
| let mut fields = ::std::vec::Vec::with_capacity(6); |
| let mut oneofs = ::std::vec::Vec::with_capacity(0); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "id", |
| |m: &Device| { &m.id }, |
| |m: &mut Device| { &mut m.id }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "name", |
| |m: &Device| { &m.name }, |
| |m: &mut Device| { &mut m.name }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "visible", |
| |m: &Device| { &m.visible }, |
| |m: &mut Device| { &mut m.visible }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Position>( |
| "position", |
| |m: &Device| { &m.position }, |
| |m: &mut Device| { &mut m.position }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Orientation>( |
| "orientation", |
| |m: &Device| { &m.orientation }, |
| |m: &mut Device| { &mut m.orientation }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( |
| "chips", |
| |m: &Device| { &m.chips }, |
| |m: &mut Device| { &mut m.chips }, |
| )); |
| ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Device>( |
| "Device", |
| fields, |
| oneofs, |
| ) |
| } |
| } |
| |
| impl ::protobuf::Message for Device { |
| const NAME: &'static str = "Device"; |
| |
| 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.id = is.read_int32()?; |
| }, |
| 18 => { |
| self.name = is.read_string()?; |
| }, |
| 24 => { |
| self.visible = is.read_bool()?; |
| }, |
| 34 => { |
| ::protobuf::rt::read_singular_message_into_field(is, &mut self.position)?; |
| }, |
| 42 => { |
| ::protobuf::rt::read_singular_message_into_field(is, &mut self.orientation)?; |
| }, |
| 50 => { |
| self.chips.push(is.read_message()?); |
| }, |
| tag => { |
| ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; |
| }, |
| }; |
| } |
| ::std::result::Result::Ok(()) |
| } |
| |
| // Compute sizes of nested messages |
| #[allow(unused_variables)] |
| fn compute_size(&self) -> u64 { |
| let mut my_size = 0; |
| if self.id != 0 { |
| my_size += ::protobuf::rt::int32_size(1, self.id); |
| } |
| if !self.name.is_empty() { |
| my_size += ::protobuf::rt::string_size(2, &self.name); |
| } |
| if self.visible != false { |
| my_size += 1 + 1; |
| } |
| if let Some(v) = self.position.as_ref() { |
| let len = v.compute_size(); |
| my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; |
| } |
| if let Some(v) = self.orientation.as_ref() { |
| let len = v.compute_size(); |
| my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; |
| } |
| for value in &self.chips { |
| let len = value.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 self.id != 0 { |
| os.write_int32(1, self.id)?; |
| } |
| if !self.name.is_empty() { |
| os.write_string(2, &self.name)?; |
| } |
| if self.visible != false { |
| os.write_bool(3, self.visible)?; |
| } |
| if let Some(v) = self.position.as_ref() { |
| ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?; |
| } |
| if let Some(v) = self.orientation.as_ref() { |
| ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?; |
| } |
| for v in &self.chips { |
| ::protobuf::rt::write_message_field_with_cached_size(6, 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() -> Device { |
| Device::new() |
| } |
| |
| fn clear(&mut self) { |
| self.id = 0; |
| self.name.clear(); |
| self.visible = false; |
| self.position.clear(); |
| self.orientation.clear(); |
| self.chips.clear(); |
| self.special_fields.clear(); |
| } |
| |
| fn default_instance() -> &'static Device { |
| static instance: Device = Device { |
| id: 0, |
| name: ::std::string::String::new(), |
| visible: false, |
| position: ::protobuf::MessageField::none(), |
| orientation: ::protobuf::MessageField::none(), |
| chips: ::std::vec::Vec::new(), |
| special_fields: ::protobuf::SpecialFields::new(), |
| }; |
| &instance |
| } |
| } |
| |
| impl ::protobuf::MessageFull for Device { |
| 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("Device").unwrap()).clone() |
| } |
| } |
| |
| impl ::std::fmt::Display for Device { |
| fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { |
| ::protobuf::text_format::fmt(self, f) |
| } |
| } |
| |
| impl ::protobuf::reflect::ProtobufValue for Device { |
| type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>; |
| } |
| |
| #[derive(PartialEq,Clone,Default,Debug)] |
| // @@protoc_insertion_point(message:netsim.model.Scene) |
| pub struct Scene { |
| // message fields |
| // @@protoc_insertion_point(field:netsim.model.Scene.devices) |
| pub devices: ::std::vec::Vec<Device>, |
| // special fields |
| // @@protoc_insertion_point(special_field:netsim.model.Scene.special_fields) |
| pub special_fields: ::protobuf::SpecialFields, |
| } |
| |
| impl<'a> ::std::default::Default for &'a Scene { |
| fn default() -> &'a Scene { |
| <Scene as ::protobuf::Message>::default_instance() |
| } |
| } |
| |
| impl Scene { |
| pub fn new() -> Scene { |
| ::std::default::Default::default() |
| } |
| |
| fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { |
| let mut fields = ::std::vec::Vec::with_capacity(1); |
| let mut oneofs = ::std::vec::Vec::with_capacity(0); |
| fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( |
| "devices", |
| |m: &Scene| { &m.devices }, |
| |m: &mut Scene| { &mut m.devices }, |
| )); |
| ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Scene>( |
| "Scene", |
| fields, |
| oneofs, |
| ) |
| } |
| } |
| |
| impl ::protobuf::Message for Scene { |
| const NAME: &'static str = "Scene"; |
| |
| 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.devices.push(is.read_message()?); |
| }, |
| tag => { |
| ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; |
| }, |
| }; |
| } |
| ::std::result::Result::Ok(()) |
| } |
| |
| // Compute sizes of nested messages |
| #[allow(unused_variables)] |
| fn compute_size(&self) -> u64 { |
| let mut my_size = 0; |
| for value in &self.devices { |
| let len = value.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<()> { |
| for v in &self.devices { |
| ::protobuf::rt::write_message_field_with_cached_size(1, 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() -> Scene { |
| Scene::new() |
| } |
| |
| fn clear(&mut self) { |
| self.devices.clear(); |
| self.special_fields.clear(); |
| } |
| |
| fn default_instance() -> &'static Scene { |
| static instance: Scene = Scene { |
| devices: ::std::vec::Vec::new(), |
| special_fields: ::protobuf::SpecialFields::new(), |
| }; |
| &instance |
| } |
| } |
| |
| impl ::protobuf::MessageFull for Scene { |
| 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("Scene").unwrap()).clone() |
| } |
| } |
| |
| impl ::std::fmt::Display for Scene { |
| fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { |
| ::protobuf::text_format::fmt(self, f) |
| } |
| } |
| |
| impl ::protobuf::reflect::ProtobufValue for Scene { |
| type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>; |
| } |
| |
| #[derive(PartialEq,Clone,Default,Debug)] |
| // @@protoc_insertion_point(message:netsim.model.Capture) |
| pub struct Capture { |
| // message fields |
| // @@protoc_insertion_point(field:netsim.model.Capture.id) |
| pub id: i32, |
| // @@protoc_insertion_point(field:netsim.model.Capture.chip_kind) |
| pub chip_kind: ::protobuf::EnumOrUnknown<super::common::ChipKind>, |
| // @@protoc_insertion_point(field:netsim.model.Capture.device_name) |
| pub device_name: ::std::string::String, |
| // @@protoc_insertion_point(field:netsim.model.Capture.state) |
| pub state: ::protobuf::EnumOrUnknown<State>, |
| // @@protoc_insertion_point(field:netsim.model.Capture.size) |
| pub size: i32, |
| // @@protoc_insertion_point(field:netsim.model.Capture.records) |
| pub records: i32, |
| // @@protoc_insertion_point(field:netsim.model.Capture.timestamp) |
| pub timestamp: ::protobuf::MessageField<::protobuf::well_known_types::timestamp::Timestamp>, |
| // @@protoc_insertion_point(field:netsim.model.Capture.valid) |
| pub valid: bool, |
| // special fields |
| // @@protoc_insertion_point(special_field:netsim.model.Capture.special_fields) |
| pub special_fields: ::protobuf::SpecialFields, |
| } |
| |
| impl<'a> ::std::default::Default for &'a Capture { |
| fn default() -> &'a Capture { |
| <Capture as ::protobuf::Message>::default_instance() |
| } |
| } |
| |
| impl Capture { |
| pub fn new() -> Capture { |
| ::std::default::Default::default() |
| } |
| |
| fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { |
| let mut fields = ::std::vec::Vec::with_capacity(8); |
| let mut oneofs = ::std::vec::Vec::with_capacity(0); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "id", |
| |m: &Capture| { &m.id }, |
| |m: &mut Capture| { &mut m.id }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "chip_kind", |
| |m: &Capture| { &m.chip_kind }, |
| |m: &mut Capture| { &mut m.chip_kind }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "device_name", |
| |m: &Capture| { &m.device_name }, |
| |m: &mut Capture| { &mut m.device_name }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "state", |
| |m: &Capture| { &m.state }, |
| |m: &mut Capture| { &mut m.state }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "size", |
| |m: &Capture| { &m.size }, |
| |m: &mut Capture| { &mut m.size }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "records", |
| |m: &Capture| { &m.records }, |
| |m: &mut Capture| { &mut m.records }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, ::protobuf::well_known_types::timestamp::Timestamp>( |
| "timestamp", |
| |m: &Capture| { &m.timestamp }, |
| |m: &mut Capture| { &mut m.timestamp }, |
| )); |
| fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>( |
| "valid", |
| |m: &Capture| { &m.valid }, |
| |m: &mut Capture| { &mut m.valid }, |
| )); |
| ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Capture>( |
| "Capture", |
| fields, |
| oneofs, |
| ) |
| } |
| } |
| |
| impl ::protobuf::Message for Capture { |
| const NAME: &'static str = "Capture"; |
| |
| 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.id = is.read_int32()?; |
| }, |
| 16 => { |
| self.chip_kind = is.read_enum_or_unknown()?; |
| }, |
| 26 => { |
| self.device_name = is.read_string()?; |
| }, |
| 32 => { |
| self.state = is.read_enum_or_unknown()?; |
| }, |
| 40 => { |
| self.size = is.read_int32()?; |
| }, |
| 48 => { |
| self.records = is.read_int32()?; |
| }, |
| 58 => { |
| ::protobuf::rt::read_singular_message_into_field(is, &mut self.timestamp)?; |
| }, |
| 64 => { |
| self.valid = is.read_bool()?; |
| }, |
| tag => { |
| ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; |
| }, |
| }; |
| } |
| ::std::result::Result::Ok(()) |
| } |
| |
| // Compute sizes of nested messages |
| #[allow(unused_variables)] |
| fn compute_size(&self) -> u64 { |
| let mut my_size = 0; |
| if self.id != 0 { |
| my_size += ::protobuf::rt::int32_size(1, self.id); |
| } |
| if self.chip_kind != ::protobuf::EnumOrUnknown::new(super::common::ChipKind::UNSPECIFIED) { |
| my_size += ::protobuf::rt::int32_size(2, self.chip_kind.value()); |
| } |
| if !self.device_name.is_empty() { |
| my_size += ::protobuf::rt::string_size(3, &self.device_name); |
| } |
| if self.state != ::protobuf::EnumOrUnknown::new(State::UNKNOWN) { |
| my_size += ::protobuf::rt::int32_size(4, self.state.value()); |
| } |
| if self.size != 0 { |
| my_size += ::protobuf::rt::int32_size(5, self.size); |
| } |
| if self.records != 0 { |
| my_size += ::protobuf::rt::int32_size(6, self.records); |
| } |
| if let Some(v) = self.timestamp.as_ref() { |
| let len = v.compute_size(); |
| my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; |
| } |
| if self.valid != false { |
| my_size += 1 + 1; |
| } |
| 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.id != 0 { |
| os.write_int32(1, self.id)?; |
| } |
| if self.chip_kind != ::protobuf::EnumOrUnknown::new(super::common::ChipKind::UNSPECIFIED) { |
| os.write_enum(2, ::protobuf::EnumOrUnknown::value(&self.chip_kind))?; |
| } |
| if !self.device_name.is_empty() { |
| os.write_string(3, &self.device_name)?; |
| } |
| if self.state != ::protobuf::EnumOrUnknown::new(State::UNKNOWN) { |
| os.write_enum(4, ::protobuf::EnumOrUnknown::value(&self.state))?; |
| } |
| if self.size != 0 { |
| os.write_int32(5, self.size)?; |
| } |
| if self.records != 0 { |
| os.write_int32(6, self.records)?; |
| } |
| if let Some(v) = self.timestamp.as_ref() { |
| ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?; |
| } |
| if self.valid != false { |
| os.write_bool(8, self.valid)?; |
| } |
| 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() -> Capture { |
| Capture::new() |
| } |
| |
| fn clear(&mut self) { |
| self.id = 0; |
| self.chip_kind = ::protobuf::EnumOrUnknown::new(super::common::ChipKind::UNSPECIFIED); |
| self.device_name.clear(); |
| self.state = ::protobuf::EnumOrUnknown::new(State::UNKNOWN); |
| self.size = 0; |
| self.records = 0; |
| self.timestamp.clear(); |
| self.valid = false; |
| self.special_fields.clear(); |
| } |
| |
| fn default_instance() -> &'static Capture { |
| static instance: Capture = Capture { |
| id: 0, |
| chip_kind: ::protobuf::EnumOrUnknown::from_i32(0), |
| device_name: ::std::string::String::new(), |
| state: ::protobuf::EnumOrUnknown::from_i32(0), |
| size: 0, |
| records: 0, |
| timestamp: ::protobuf::MessageField::none(), |
| valid: false, |
| special_fields: ::protobuf::SpecialFields::new(), |
| }; |
| &instance |
| } |
| } |
| |
| impl ::protobuf::MessageFull for Capture { |
| 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("Capture").unwrap()).clone() |
| } |
| } |
| |
| impl ::std::fmt::Display for Capture { |
| fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { |
| ::protobuf::text_format::fmt(self, f) |
| } |
| } |
| |
| impl ::protobuf::reflect::ProtobufValue for Capture { |
| type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>; |
| } |
| |
| #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] |
| // @@protoc_insertion_point(enum:netsim.model.PhyKind) |
| pub enum PhyKind { |
| // @@protoc_insertion_point(enum_value:netsim.model.PhyKind.NONE) |
| NONE = 0, |
| // @@protoc_insertion_point(enum_value:netsim.model.PhyKind.BLUETOOTH_CLASSIC) |
| BLUETOOTH_CLASSIC = 1, |
| // @@protoc_insertion_point(enum_value:netsim.model.PhyKind.BLUETOOTH_LOW_ENERGY) |
| BLUETOOTH_LOW_ENERGY = 2, |
| // @@protoc_insertion_point(enum_value:netsim.model.PhyKind.WIFI) |
| WIFI = 3, |
| // @@protoc_insertion_point(enum_value:netsim.model.PhyKind.UWB) |
| UWB = 4, |
| // @@protoc_insertion_point(enum_value:netsim.model.PhyKind.WIFI_RTT) |
| WIFI_RTT = 5, |
| } |
| |
| impl ::protobuf::Enum for PhyKind { |
| const NAME: &'static str = "PhyKind"; |
| |
| fn value(&self) -> i32 { |
| *self as i32 |
| } |
| |
| fn from_i32(value: i32) -> ::std::option::Option<PhyKind> { |
| match value { |
| 0 => ::std::option::Option::Some(PhyKind::NONE), |
| 1 => ::std::option::Option::Some(PhyKind::BLUETOOTH_CLASSIC), |
| 2 => ::std::option::Option::Some(PhyKind::BLUETOOTH_LOW_ENERGY), |
| 3 => ::std::option::Option::Some(PhyKind::WIFI), |
| 4 => ::std::option::Option::Some(PhyKind::UWB), |
| 5 => ::std::option::Option::Some(PhyKind::WIFI_RTT), |
| _ => ::std::option::Option::None |
| } |
| } |
| |
| const VALUES: &'static [PhyKind] = &[ |
| PhyKind::NONE, |
| PhyKind::BLUETOOTH_CLASSIC, |
| PhyKind::BLUETOOTH_LOW_ENERGY, |
| PhyKind::WIFI, |
| PhyKind::UWB, |
| PhyKind::WIFI_RTT, |
| ]; |
| } |
| |
| impl ::protobuf::EnumFull for PhyKind { |
| fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor { |
| static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new(); |
| descriptor.get(|| file_descriptor().enum_by_package_relative_name("PhyKind").unwrap()).clone() |
| } |
| |
| fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor { |
| let index = *self as usize; |
| Self::enum_descriptor().value_by_index(index) |
| } |
| } |
| |
| impl ::std::default::Default for PhyKind { |
| fn default() -> Self { |
| PhyKind::NONE |
| } |
| } |
| |
| impl PhyKind { |
| fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData { |
| ::protobuf::reflect::GeneratedEnumDescriptorData::new::<PhyKind>("PhyKind") |
| } |
| } |
| |
| #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] |
| // @@protoc_insertion_point(enum:netsim.model.State) |
| pub enum State { |
| // @@protoc_insertion_point(enum_value:netsim.model.State.UNKNOWN) |
| UNKNOWN = 0, |
| // @@protoc_insertion_point(enum_value:netsim.model.State.ON) |
| ON = 1, |
| // @@protoc_insertion_point(enum_value:netsim.model.State.OFF) |
| OFF = 2, |
| } |
| |
| impl ::protobuf::Enum for State { |
| const NAME: &'static str = "State"; |
| |
| fn value(&self) -> i32 { |
| *self as i32 |
| } |
| |
| fn from_i32(value: i32) -> ::std::option::Option<State> { |
| match value { |
| 0 => ::std::option::Option::Some(State::UNKNOWN), |
| 1 => ::std::option::Option::Some(State::ON), |
| 2 => ::std::option::Option::Some(State::OFF), |
| _ => ::std::option::Option::None |
| } |
| } |
| |
| const VALUES: &'static [State] = &[ |
| State::UNKNOWN, |
| State::ON, |
| State::OFF, |
| ]; |
| } |
| |
| impl ::protobuf::EnumFull for State { |
| fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor { |
| static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new(); |
| descriptor.get(|| file_descriptor().enum_by_package_relative_name("State").unwrap()).clone() |
| } |
| |
| fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor { |
| let index = *self as usize; |
| Self::enum_descriptor().value_by_index(index) |
| } |
| } |
| |
| impl ::std::default::Default for State { |
| fn default() -> Self { |
| State::UNKNOWN |
| } |
| } |
| |
| impl State { |
| fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData { |
| ::protobuf::reflect::GeneratedEnumDescriptorData::new::<State>("State") |
| } |
| } |
| |
| static file_descriptor_proto_data: &'static [u8] = b"\ |
| \n\x0bmodel.proto\x12\x0cnetsim.model\x1a\x0ccommon.proto\x1a\x1fgoogle/\ |
| protobuf/timestamp.proto\"4\n\x08Position\x12\x0c\n\x01x\x18\x01\x20\x01\ |
| (\x02R\x01x\x12\x0c\n\x01y\x18\x02\x20\x01(\x02R\x01y\x12\x0c\n\x01z\x18\ |
| \x03\x20\x01(\x02R\x01z\"I\n\x0bOrientation\x12\x10\n\x03yaw\x18\x01\x20\ |
| \x01(\x02R\x03yaw\x12\x14\n\x05pitch\x18\x02\x20\x01(\x02R\x05pitch\x12\ |
| \x12\n\x04roll\x18\x03\x20\x01(\x02R\x04roll\"\xae\x04\n\x04Chip\x12+\n\ |
| \x04kind\x18\x01\x20\x01(\x0e2\x17.netsim.common.ChipKindR\x04kind\x12\ |
| \x0e\n\x02id\x18\x02\x20\x01(\x05R\x02id\x12\x12\n\x04name\x18\x03\x20\ |
| \x01(\tR\x04name\x12\"\n\x0cmanufacturer\x18\x04\x20\x01(\tR\x0cmanufact\ |
| urer\x12!\n\x0cproduct_name\x18\x05\x20\x01(\tR\x0bproductName\x12.\n\ |
| \x02bt\x18\x06\x20\x01(\x0b2\x1c.netsim.model.Chip.BluetoothH\0R\x02bt\ |
| \x12,\n\x03uwb\x18\x07\x20\x01(\x0b2\x18.netsim.model.Chip.RadioH\0R\x03\ |
| uwb\x12.\n\x04wifi\x18\x08\x20\x01(\x0b2\x18.netsim.model.Chip.RadioH\0R\ |
| \x04wifi\x1a~\n\x05Radio\x12)\n\x05state\x18\x01\x20\x01(\x0e2\x13.netsi\ |
| m.model.StateR\x05state\x12\x14\n\x05range\x18\x02\x20\x01(\x02R\x05rang\ |
| e\x12\x19\n\x08tx_count\x18\x03\x20\x01(\x05R\x07txCount\x12\x19\n\x08rx\ |
| _count\x18\x04\x20\x01(\x05R\x07rxCount\x1ax\n\tBluetooth\x127\n\nlow_en\ |
| ergy\x18\x01\x20\x01(\x0b2\x18.netsim.model.Chip.RadioR\tlowEnergy\x122\ |
| \n\x07classic\x18\x02\x20\x01(\x0b2\x18.netsim.model.Chip.RadioR\x07clas\ |
| sicB\x06\n\x04chip\"\xe1\x01\n\x06Device\x12\x0e\n\x02id\x18\x01\x20\x01\ |
| (\x05R\x02id\x12\x12\n\x04name\x18\x02\x20\x01(\tR\x04name\x12\x18\n\x07\ |
| visible\x18\x03\x20\x01(\x08R\x07visible\x122\n\x08position\x18\x04\x20\ |
| \x01(\x0b2\x16.netsim.model.PositionR\x08position\x12;\n\x0borientation\ |
| \x18\x05\x20\x01(\x0b2\x19.netsim.model.OrientationR\x0borientation\x12(\ |
| \n\x05chips\x18\x06\x20\x03(\x0b2\x12.netsim.model.ChipR\x05chips\"7\n\ |
| \x05Scene\x12.\n\x07devices\x18\x01\x20\x03(\x0b2\x14.netsim.model.Devic\ |
| eR\x07devices\"\x99\x02\n\x07Capture\x12\x0e\n\x02id\x18\x01\x20\x01(\ |
| \x05R\x02id\x124\n\tchip_kind\x18\x02\x20\x01(\x0e2\x17.netsim.common.Ch\ |
| ipKindR\x08chipKind\x12\x1f\n\x0bdevice_name\x18\x03\x20\x01(\tR\ndevice\ |
| Name\x12)\n\x05state\x18\x04\x20\x01(\x0e2\x13.netsim.model.StateR\x05st\ |
| ate\x12\x12\n\x04size\x18\x05\x20\x01(\x05R\x04size\x12\x18\n\x07records\ |
| \x18\x06\x20\x01(\x05R\x07records\x128\n\ttimestamp\x18\x07\x20\x01(\x0b\ |
| 2\x1a.google.protobuf.TimestampR\ttimestamp\x12\x14\n\x05valid\x18\x08\ |
| \x20\x01(\x08R\x05valid*e\n\x07PhyKind\x12\x08\n\x04NONE\x10\0\x12\x15\n\ |
| \x11BLUETOOTH_CLASSIC\x10\x01\x12\x18\n\x14BLUETOOTH_LOW_ENERGY\x10\x02\ |
| \x12\x08\n\x04WIFI\x10\x03\x12\x07\n\x03UWB\x10\x04\x12\x0c\n\x08WIFI_RT\ |
| T\x10\x05*%\n\x05State\x12\x0b\n\x07UNKNOWN\x10\0\x12\x06\n\x02ON\x10\ |
| \x01\x12\x07\n\x03OFF\x10\x02b\x06proto3\ |
| "; |
| |
| /// `FileDescriptorProto` object which was a source for this generated file |
| 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() |
| }) |
| } |
| |
| /// `FileDescriptor` object which allows dynamic access to files |
| 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(2); |
| deps.push(super::common::file_descriptor().clone()); |
| deps.push(::protobuf::well_known_types::timestamp::file_descriptor().clone()); |
| let mut messages = ::std::vec::Vec::with_capacity(8); |
| messages.push(Position::generated_message_descriptor_data()); |
| messages.push(Orientation::generated_message_descriptor_data()); |
| messages.push(Chip::generated_message_descriptor_data()); |
| messages.push(Device::generated_message_descriptor_data()); |
| messages.push(Scene::generated_message_descriptor_data()); |
| messages.push(Capture::generated_message_descriptor_data()); |
| messages.push(chip::Radio::generated_message_descriptor_data()); |
| messages.push(chip::Bluetooth::generated_message_descriptor_data()); |
| let mut enums = ::std::vec::Vec::with_capacity(2); |
| enums.push(PhyKind::generated_enum_descriptor_data()); |
| enums.push(State::generated_enum_descriptor_data()); |
| ::protobuf::reflect::GeneratedFileDescriptor::new_generated( |
| file_descriptor_proto(), |
| deps, |
| messages, |
| enums, |
| ) |
| }); |
| ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor) |
| }) |
| } |
