1#![allow(unknown_lints)]
7#![allow(clippy::all)]
8
9#![allow(unused_attributes)]
10#![cfg_attr(rustfmt, rustfmt::skip)]
11
12#![allow(dead_code)]
13#![allow(missing_docs)]
14#![allow(non_camel_case_types)]
15#![allow(non_snake_case)]
16#![allow(non_upper_case_globals)]
17#![allow(trivial_casts)]
18#![allow(unused_results)]
19#![allow(unused_mut)]
20
21const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_7_2;
26
27#[derive(::gz_msgs_common::IgnMessage)]
28#[derive(PartialEq,Clone,Default,Debug)]
30pub struct PointCloudPacked {
31 pub header: ::protobuf::MessageField<super::header::Header>,
34 pub field: ::std::vec::Vec<point_cloud_packed::Field>,
36 pub height: u32,
38 pub width: u32,
40 pub is_bigendian: bool,
42 pub point_step: u32,
44 pub row_step: u32,
46 pub data: ::std::vec::Vec<u8>,
48 pub is_dense: bool,
50 pub special_fields: ::protobuf::SpecialFields,
53}
54
55impl<'a> ::std::default::Default for &'a PointCloudPacked {
56 fn default() -> &'a PointCloudPacked {
57 <PointCloudPacked as ::protobuf::Message>::default_instance()
58 }
59}
60
61impl PointCloudPacked {
62 pub fn new() -> PointCloudPacked {
63 ::std::default::Default::default()
64 }
65
66 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
67 let mut fields = ::std::vec::Vec::with_capacity(9);
68 let mut oneofs = ::std::vec::Vec::with_capacity(0);
69 fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::header::Header>(
70 "header",
71 |m: &PointCloudPacked| { &m.header },
72 |m: &mut PointCloudPacked| { &mut m.header },
73 ));
74 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
75 "field",
76 |m: &PointCloudPacked| { &m.field },
77 |m: &mut PointCloudPacked| { &mut m.field },
78 ));
79 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
80 "height",
81 |m: &PointCloudPacked| { &m.height },
82 |m: &mut PointCloudPacked| { &mut m.height },
83 ));
84 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
85 "width",
86 |m: &PointCloudPacked| { &m.width },
87 |m: &mut PointCloudPacked| { &mut m.width },
88 ));
89 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
90 "is_bigendian",
91 |m: &PointCloudPacked| { &m.is_bigendian },
92 |m: &mut PointCloudPacked| { &mut m.is_bigendian },
93 ));
94 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
95 "point_step",
96 |m: &PointCloudPacked| { &m.point_step },
97 |m: &mut PointCloudPacked| { &mut m.point_step },
98 ));
99 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
100 "row_step",
101 |m: &PointCloudPacked| { &m.row_step },
102 |m: &mut PointCloudPacked| { &mut m.row_step },
103 ));
104 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
105 "data",
106 |m: &PointCloudPacked| { &m.data },
107 |m: &mut PointCloudPacked| { &mut m.data },
108 ));
109 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
110 "is_dense",
111 |m: &PointCloudPacked| { &m.is_dense },
112 |m: &mut PointCloudPacked| { &mut m.is_dense },
113 ));
114 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PointCloudPacked>(
115 "PointCloudPacked",
116 fields,
117 oneofs,
118 )
119 }
120}
121
122impl ::protobuf::Message for PointCloudPacked {
123 const NAME: &'static str = "PointCloudPacked";
124
125 fn is_initialized(&self) -> bool {
126 true
127 }
128
129 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
130 while let Some(tag) = is.read_raw_tag_or_eof()? {
131 match tag {
132 10 => {
133 ::protobuf::rt::read_singular_message_into_field(is, &mut self.header)?;
134 },
135 18 => {
136 self.field.push(is.read_message()?);
137 },
138 24 => {
139 self.height = is.read_uint32()?;
140 },
141 32 => {
142 self.width = is.read_uint32()?;
143 },
144 40 => {
145 self.is_bigendian = is.read_bool()?;
146 },
147 48 => {
148 self.point_step = is.read_uint32()?;
149 },
150 56 => {
151 self.row_step = is.read_uint32()?;
152 },
153 66 => {
154 self.data = is.read_bytes()?;
155 },
156 72 => {
157 self.is_dense = is.read_bool()?;
158 },
159 tag => {
160 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
161 },
162 };
163 }
164 ::std::result::Result::Ok(())
165 }
166
167 #[allow(unused_variables)]
169 fn compute_size(&self) -> u64 {
170 let mut my_size = 0;
171 if let Some(v) = self.header.as_ref() {
172 let len = v.compute_size();
173 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
174 }
175 for value in &self.field {
176 let len = value.compute_size();
177 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
178 };
179 if self.height != 0 {
180 my_size += ::protobuf::rt::uint32_size(3, self.height);
181 }
182 if self.width != 0 {
183 my_size += ::protobuf::rt::uint32_size(4, self.width);
184 }
185 if self.is_bigendian != false {
186 my_size += 1 + 1;
187 }
188 if self.point_step != 0 {
189 my_size += ::protobuf::rt::uint32_size(6, self.point_step);
190 }
191 if self.row_step != 0 {
192 my_size += ::protobuf::rt::uint32_size(7, self.row_step);
193 }
194 if !self.data.is_empty() {
195 my_size += ::protobuf::rt::bytes_size(8, &self.data);
196 }
197 if self.is_dense != false {
198 my_size += 1 + 1;
199 }
200 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
201 self.special_fields.cached_size().set(my_size as u32);
202 my_size
203 }
204
205 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
206 if let Some(v) = self.header.as_ref() {
207 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
208 }
209 for v in &self.field {
210 ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
211 };
212 if self.height != 0 {
213 os.write_uint32(3, self.height)?;
214 }
215 if self.width != 0 {
216 os.write_uint32(4, self.width)?;
217 }
218 if self.is_bigendian != false {
219 os.write_bool(5, self.is_bigendian)?;
220 }
221 if self.point_step != 0 {
222 os.write_uint32(6, self.point_step)?;
223 }
224 if self.row_step != 0 {
225 os.write_uint32(7, self.row_step)?;
226 }
227 if !self.data.is_empty() {
228 os.write_bytes(8, &self.data)?;
229 }
230 if self.is_dense != false {
231 os.write_bool(9, self.is_dense)?;
232 }
233 os.write_unknown_fields(self.special_fields.unknown_fields())?;
234 ::std::result::Result::Ok(())
235 }
236
237 fn special_fields(&self) -> &::protobuf::SpecialFields {
238 &self.special_fields
239 }
240
241 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
242 &mut self.special_fields
243 }
244
245 fn new() -> PointCloudPacked {
246 PointCloudPacked::new()
247 }
248
249 fn clear(&mut self) {
250 self.header.clear();
251 self.field.clear();
252 self.height = 0;
253 self.width = 0;
254 self.is_bigendian = false;
255 self.point_step = 0;
256 self.row_step = 0;
257 self.data.clear();
258 self.is_dense = false;
259 self.special_fields.clear();
260 }
261
262 fn default_instance() -> &'static PointCloudPacked {
263 static instance: PointCloudPacked = PointCloudPacked {
264 header: ::protobuf::MessageField::none(),
265 field: ::std::vec::Vec::new(),
266 height: 0,
267 width: 0,
268 is_bigendian: false,
269 point_step: 0,
270 row_step: 0,
271 data: ::std::vec::Vec::new(),
272 is_dense: false,
273 special_fields: ::protobuf::SpecialFields::new(),
274 };
275 &instance
276 }
277}
278
279impl ::protobuf::MessageFull for PointCloudPacked {
280 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
281 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
282 descriptor.get(|| file_descriptor().message_by_package_relative_name("PointCloudPacked").unwrap()).clone()
283 }
284}
285
286impl ::std::fmt::Display for PointCloudPacked {
287 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
288 ::protobuf::text_format::fmt(self, f)
289 }
290}
291
292impl ::protobuf::reflect::ProtobufValue for PointCloudPacked {
293 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
294}
295
296pub mod point_cloud_packed {
298 #[derive(::gz_msgs_common::IgnMessage)]
299 #[derive(PartialEq,Clone,Default,Debug)]
301 pub struct Field {
302 pub name: ::std::string::String,
305 pub offset: u32,
307 pub datatype: ::protobuf::EnumOrUnknown<field::DataType>,
309 pub count: u32,
311 pub special_fields: ::protobuf::SpecialFields,
314 }
315
316 impl<'a> ::std::default::Default for &'a Field {
317 fn default() -> &'a Field {
318 <Field as ::protobuf::Message>::default_instance()
319 }
320 }
321
322 impl Field {
323 pub fn new() -> Field {
324 ::std::default::Default::default()
325 }
326
327 pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
328 let mut fields = ::std::vec::Vec::with_capacity(4);
329 let mut oneofs = ::std::vec::Vec::with_capacity(0);
330 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
331 "name",
332 |m: &Field| { &m.name },
333 |m: &mut Field| { &mut m.name },
334 ));
335 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
336 "offset",
337 |m: &Field| { &m.offset },
338 |m: &mut Field| { &mut m.offset },
339 ));
340 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
341 "datatype",
342 |m: &Field| { &m.datatype },
343 |m: &mut Field| { &mut m.datatype },
344 ));
345 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
346 "count",
347 |m: &Field| { &m.count },
348 |m: &mut Field| { &mut m.count },
349 ));
350 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Field>(
351 "PointCloudPacked.Field",
352 fields,
353 oneofs,
354 )
355 }
356 }
357
358 impl ::protobuf::Message for Field {
359 const NAME: &'static str = "Field";
360
361 fn is_initialized(&self) -> bool {
362 true
363 }
364
365 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
366 while let Some(tag) = is.read_raw_tag_or_eof()? {
367 match tag {
368 10 => {
369 self.name = is.read_string()?;
370 },
371 16 => {
372 self.offset = is.read_uint32()?;
373 },
374 24 => {
375 self.datatype = is.read_enum_or_unknown()?;
376 },
377 32 => {
378 self.count = is.read_uint32()?;
379 },
380 tag => {
381 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
382 },
383 };
384 }
385 ::std::result::Result::Ok(())
386 }
387
388 #[allow(unused_variables)]
390 fn compute_size(&self) -> u64 {
391 let mut my_size = 0;
392 if !self.name.is_empty() {
393 my_size += ::protobuf::rt::string_size(1, &self.name);
394 }
395 if self.offset != 0 {
396 my_size += ::protobuf::rt::uint32_size(2, self.offset);
397 }
398 if self.datatype != ::protobuf::EnumOrUnknown::new(field::DataType::INT8) {
399 my_size += ::protobuf::rt::int32_size(3, self.datatype.value());
400 }
401 if self.count != 0 {
402 my_size += ::protobuf::rt::uint32_size(4, self.count);
403 }
404 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
405 self.special_fields.cached_size().set(my_size as u32);
406 my_size
407 }
408
409 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
410 if !self.name.is_empty() {
411 os.write_string(1, &self.name)?;
412 }
413 if self.offset != 0 {
414 os.write_uint32(2, self.offset)?;
415 }
416 if self.datatype != ::protobuf::EnumOrUnknown::new(field::DataType::INT8) {
417 os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.datatype))?;
418 }
419 if self.count != 0 {
420 os.write_uint32(4, self.count)?;
421 }
422 os.write_unknown_fields(self.special_fields.unknown_fields())?;
423 ::std::result::Result::Ok(())
424 }
425
426 fn special_fields(&self) -> &::protobuf::SpecialFields {
427 &self.special_fields
428 }
429
430 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
431 &mut self.special_fields
432 }
433
434 fn new() -> Field {
435 Field::new()
436 }
437
438 fn clear(&mut self) {
439 self.name.clear();
440 self.offset = 0;
441 self.datatype = ::protobuf::EnumOrUnknown::new(field::DataType::INT8);
442 self.count = 0;
443 self.special_fields.clear();
444 }
445
446 fn default_instance() -> &'static Field {
447 static instance: Field = Field {
448 name: ::std::string::String::new(),
449 offset: 0,
450 datatype: ::protobuf::EnumOrUnknown::from_i32(0),
451 count: 0,
452 special_fields: ::protobuf::SpecialFields::new(),
453 };
454 &instance
455 }
456 }
457
458 impl ::protobuf::MessageFull for Field {
459 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
460 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
461 descriptor.get(|| super::file_descriptor().message_by_package_relative_name("PointCloudPacked.Field").unwrap()).clone()
462 }
463 }
464
465 impl ::std::fmt::Display for Field {
466 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
467 ::protobuf::text_format::fmt(self, f)
468 }
469 }
470
471 impl ::protobuf::reflect::ProtobufValue for Field {
472 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
473 }
474
475 pub mod field {
477 #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
478 pub enum DataType {
480 INT8 = 0,
482 UINT8 = 1,
484 INT16 = 2,
486 UINT16 = 3,
488 INT32 = 4,
490 UINT32 = 5,
492 FLOAT32 = 6,
494 FLOAT64 = 7,
496 }
497
498 impl ::protobuf::Enum for DataType {
499 const NAME: &'static str = "DataType";
500
501 fn value(&self) -> i32 {
502 *self as i32
503 }
504
505 fn from_i32(value: i32) -> ::std::option::Option<DataType> {
506 match value {
507 0 => ::std::option::Option::Some(DataType::INT8),
508 1 => ::std::option::Option::Some(DataType::UINT8),
509 2 => ::std::option::Option::Some(DataType::INT16),
510 3 => ::std::option::Option::Some(DataType::UINT16),
511 4 => ::std::option::Option::Some(DataType::INT32),
512 5 => ::std::option::Option::Some(DataType::UINT32),
513 6 => ::std::option::Option::Some(DataType::FLOAT32),
514 7 => ::std::option::Option::Some(DataType::FLOAT64),
515 _ => ::std::option::Option::None
516 }
517 }
518
519 fn from_str(str: &str) -> ::std::option::Option<DataType> {
520 match str {
521 "INT8" => ::std::option::Option::Some(DataType::INT8),
522 "UINT8" => ::std::option::Option::Some(DataType::UINT8),
523 "INT16" => ::std::option::Option::Some(DataType::INT16),
524 "UINT16" => ::std::option::Option::Some(DataType::UINT16),
525 "INT32" => ::std::option::Option::Some(DataType::INT32),
526 "UINT32" => ::std::option::Option::Some(DataType::UINT32),
527 "FLOAT32" => ::std::option::Option::Some(DataType::FLOAT32),
528 "FLOAT64" => ::std::option::Option::Some(DataType::FLOAT64),
529 _ => ::std::option::Option::None
530 }
531 }
532
533 const VALUES: &'static [DataType] = &[
534 DataType::INT8,
535 DataType::UINT8,
536 DataType::INT16,
537 DataType::UINT16,
538 DataType::INT32,
539 DataType::UINT32,
540 DataType::FLOAT32,
541 DataType::FLOAT64,
542 ];
543 }
544
545 impl ::protobuf::EnumFull for DataType {
546 fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
547 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
548 descriptor.get(|| super::super::file_descriptor().enum_by_package_relative_name("PointCloudPacked.Field.DataType").unwrap()).clone()
549 }
550
551 fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
552 let index = *self as usize;
553 Self::enum_descriptor().value_by_index(index)
554 }
555 }
556
557 impl ::std::default::Default for DataType {
558 fn default() -> Self {
559 DataType::INT8
560 }
561 }
562
563 impl DataType {
564 pub(in super::super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
565 ::protobuf::reflect::GeneratedEnumDescriptorData::new::<DataType>("PointCloudPacked.Field.DataType")
566 }
567 }
568 }
569}
570
571static file_descriptor_proto_data: &'static [u8] = b"\
572 \n%ignition/msgs/pointcloud_packed.proto\x12\rignition.msgs\x1a\x1aignit\
573 ion/msgs/header.proto\"\xb9\x04\n\x10PointCloudPacked\x12-\n\x06header\
574 \x18\x01\x20\x01(\x0b2\x15.ignition.msgs.HeaderR\x06header\x12;\n\x05fie\
575 ld\x18\x02\x20\x03(\x0b2%.ignition.msgs.PointCloudPacked.FieldR\x05field\
576 \x12\x16\n\x06height\x18\x03\x20\x01(\rR\x06height\x12\x14\n\x05width\
577 \x18\x04\x20\x01(\rR\x05width\x12!\n\x0cis_bigendian\x18\x05\x20\x01(\
578 \x08R\x0bisBigendian\x12\x1d\n\npoint_step\x18\x06\x20\x01(\rR\tpointSte\
579 p\x12\x19\n\x08row_step\x18\x07\x20\x01(\rR\x07rowStep\x12\x12\n\x04data\
580 \x18\x08\x20\x01(\x0cR\x04data\x12\x19\n\x08is_dense\x18\t\x20\x01(\x08R\
581 \x07isDense\x1a\xfe\x01\n\x05Field\x12\x12\n\x04name\x18\x01\x20\x01(\tR\
582 \x04name\x12\x16\n\x06offset\x18\x02\x20\x01(\rR\x06offset\x12J\n\x08dat\
583 atype\x18\x03\x20\x01(\x0e2..ignition.msgs.PointCloudPacked.Field.DataTy\
584 peR\x08datatype\x12\x14\n\x05count\x18\x04\x20\x01(\rR\x05count\"g\n\x08\
585 DataType\x12\x08\n\x04INT8\x10\0\x12\t\n\x05UINT8\x10\x01\x12\t\n\x05INT\
586 16\x10\x02\x12\n\n\x06UINT16\x10\x03\x12\t\n\x05INT32\x10\x04\x12\n\n\
587 \x06UINT32\x10\x05\x12\x0b\n\x07FLOAT32\x10\x06\x12\x0b\n\x07FLOAT64\x10\
588 \x07B+\n\x11com.ignition.msgsB\x16PointCloudPackedProtosb\x06proto3\
589";
590
591fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
593 static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
594 file_descriptor_proto_lazy.get(|| {
595 ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
596 })
597}
598
599pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
601 static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
602 static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
603 file_descriptor.get(|| {
604 let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
605 let mut deps = ::std::vec::Vec::with_capacity(1);
606 deps.push(super::header::file_descriptor().clone());
607 let mut messages = ::std::vec::Vec::with_capacity(2);
608 messages.push(PointCloudPacked::generated_message_descriptor_data());
609 messages.push(point_cloud_packed::Field::generated_message_descriptor_data());
610 let mut enums = ::std::vec::Vec::with_capacity(1);
611 enums.push(point_cloud_packed::field::DataType::generated_enum_descriptor_data());
612 ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
613 file_descriptor_proto(),
614 deps,
615 messages,
616 enums,
617 )
618 });
619 ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
620 })
621}