matrix_protos_rust/protos/
recognition.rs1#![allow(unknown_lints)]
6#![allow(clippy::all)]
7
8#![allow(unused_attributes)]
9#![cfg_attr(rustfmt, rustfmt::skip)]
10
11#![allow(box_pointers)]
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_imports)]
19#![allow(unused_results)]
20#[derive(PartialEq,Clone,Default)]
27pub struct FeatureDescriptor {
28 pub uuid: ::std::string::String,
30 pub data_format: ::std::string::String,
31 pub data: ::std::vec::Vec<f32>,
32 pub tags: ::protobuf::RepeatedField<::std::string::String>,
33 pub unknown_fields: ::protobuf::UnknownFields,
35 pub cached_size: ::protobuf::CachedSize,
36}
37
38impl<'a> ::std::default::Default for &'a FeatureDescriptor {
39 fn default() -> &'a FeatureDescriptor {
40 <FeatureDescriptor as ::protobuf::Message>::default_instance()
41 }
42}
43
44impl FeatureDescriptor {
45 pub fn new() -> FeatureDescriptor {
46 ::std::default::Default::default()
47 }
48
49 pub fn get_uuid(&self) -> &str {
53 &self.uuid
54 }
55 pub fn clear_uuid(&mut self) {
56 self.uuid.clear();
57 }
58
59 pub fn set_uuid(&mut self, v: ::std::string::String) {
61 self.uuid = v;
62 }
63
64 pub fn mut_uuid(&mut self) -> &mut ::std::string::String {
67 &mut self.uuid
68 }
69
70 pub fn take_uuid(&mut self) -> ::std::string::String {
72 ::std::mem::replace(&mut self.uuid, ::std::string::String::new())
73 }
74
75 pub fn get_data_format(&self) -> &str {
79 &self.data_format
80 }
81 pub fn clear_data_format(&mut self) {
82 self.data_format.clear();
83 }
84
85 pub fn set_data_format(&mut self, v: ::std::string::String) {
87 self.data_format = v;
88 }
89
90 pub fn mut_data_format(&mut self) -> &mut ::std::string::String {
93 &mut self.data_format
94 }
95
96 pub fn take_data_format(&mut self) -> ::std::string::String {
98 ::std::mem::replace(&mut self.data_format, ::std::string::String::new())
99 }
100
101 pub fn get_data(&self) -> &[f32] {
105 &self.data
106 }
107 pub fn clear_data(&mut self) {
108 self.data.clear();
109 }
110
111 pub fn set_data(&mut self, v: ::std::vec::Vec<f32>) {
113 self.data = v;
114 }
115
116 pub fn mut_data(&mut self) -> &mut ::std::vec::Vec<f32> {
118 &mut self.data
119 }
120
121 pub fn take_data(&mut self) -> ::std::vec::Vec<f32> {
123 ::std::mem::replace(&mut self.data, ::std::vec::Vec::new())
124 }
125
126 pub fn get_tags(&self) -> &[::std::string::String] {
130 &self.tags
131 }
132 pub fn clear_tags(&mut self) {
133 self.tags.clear();
134 }
135
136 pub fn set_tags(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
138 self.tags = v;
139 }
140
141 pub fn mut_tags(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
143 &mut self.tags
144 }
145
146 pub fn take_tags(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
148 ::std::mem::replace(&mut self.tags, ::protobuf::RepeatedField::new())
149 }
150}
151
152impl ::protobuf::Message for FeatureDescriptor {
153 fn is_initialized(&self) -> bool {
154 true
155 }
156
157 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
158 while !is.eof()? {
159 let (field_number, wire_type) = is.read_tag_unpack()?;
160 match field_number {
161 1 => {
162 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.uuid)?;
163 },
164 2 => {
165 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.data_format)?;
166 },
167 3 => {
168 ::protobuf::rt::read_repeated_float_into(wire_type, is, &mut self.data)?;
169 },
170 4 => {
171 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.tags)?;
172 },
173 _ => {
174 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
175 },
176 };
177 }
178 ::std::result::Result::Ok(())
179 }
180
181 #[allow(unused_variables)]
183 fn compute_size(&self) -> u32 {
184 let mut my_size = 0;
185 if !self.uuid.is_empty() {
186 my_size += ::protobuf::rt::string_size(1, &self.uuid);
187 }
188 if !self.data_format.is_empty() {
189 my_size += ::protobuf::rt::string_size(2, &self.data_format);
190 }
191 my_size += 5 * self.data.len() as u32;
192 for value in &self.tags {
193 my_size += ::protobuf::rt::string_size(4, &value);
194 };
195 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
196 self.cached_size.set(my_size);
197 my_size
198 }
199
200 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
201 if !self.uuid.is_empty() {
202 os.write_string(1, &self.uuid)?;
203 }
204 if !self.data_format.is_empty() {
205 os.write_string(2, &self.data_format)?;
206 }
207 for v in &self.data {
208 os.write_float(3, *v)?;
209 };
210 for v in &self.tags {
211 os.write_string(4, &v)?;
212 };
213 os.write_unknown_fields(self.get_unknown_fields())?;
214 ::std::result::Result::Ok(())
215 }
216
217 fn get_cached_size(&self) -> u32 {
218 self.cached_size.get()
219 }
220
221 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
222 &self.unknown_fields
223 }
224
225 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
226 &mut self.unknown_fields
227 }
228
229 fn as_any(&self) -> &dyn (::std::any::Any) {
230 self as &dyn (::std::any::Any)
231 }
232 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
233 self as &mut dyn (::std::any::Any)
234 }
235 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
236 self
237 }
238
239 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
240 Self::descriptor_static()
241 }
242
243 fn new() -> FeatureDescriptor {
244 FeatureDescriptor::new()
245 }
246
247 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
248 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
249 descriptor.get(|| {
250 let mut fields = ::std::vec::Vec::new();
251 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
252 "uuid",
253 |m: &FeatureDescriptor| { &m.uuid },
254 |m: &mut FeatureDescriptor| { &mut m.uuid },
255 ));
256 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
257 "data_format",
258 |m: &FeatureDescriptor| { &m.data_format },
259 |m: &mut FeatureDescriptor| { &mut m.data_format },
260 ));
261 fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
262 "data",
263 |m: &FeatureDescriptor| { &m.data },
264 |m: &mut FeatureDescriptor| { &mut m.data },
265 ));
266 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
267 "tags",
268 |m: &FeatureDescriptor| { &m.tags },
269 |m: &mut FeatureDescriptor| { &mut m.tags },
270 ));
271 ::protobuf::reflect::MessageDescriptor::new_pb_name::<FeatureDescriptor>(
272 "FeatureDescriptor",
273 fields,
274 file_descriptor_proto()
275 )
276 })
277 }
278
279 fn default_instance() -> &'static FeatureDescriptor {
280 static instance: ::protobuf::rt::LazyV2<FeatureDescriptor> = ::protobuf::rt::LazyV2::INIT;
281 instance.get(FeatureDescriptor::new)
282 }
283}
284
285impl ::protobuf::Clear for FeatureDescriptor {
286 fn clear(&mut self) {
287 self.uuid.clear();
288 self.data_format.clear();
289 self.data.clear();
290 self.tags.clear();
291 self.unknown_fields.clear();
292 }
293}
294
295impl ::std::fmt::Debug for FeatureDescriptor {
296 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
297 ::protobuf::text_format::fmt(self, f)
298 }
299}
300
301impl ::protobuf::reflect::ProtobufValue for FeatureDescriptor {
302 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
303 ::protobuf::reflect::ReflectValueRef::Message(self)
304 }
305}
306
307#[derive(PartialEq,Clone,Default)]
308pub struct FeatureDescriptorList {
309 pub feature_descriptors: ::protobuf::RepeatedField<FeatureDescriptor>,
311 pub unknown_fields: ::protobuf::UnknownFields,
313 pub cached_size: ::protobuf::CachedSize,
314}
315
316impl<'a> ::std::default::Default for &'a FeatureDescriptorList {
317 fn default() -> &'a FeatureDescriptorList {
318 <FeatureDescriptorList as ::protobuf::Message>::default_instance()
319 }
320}
321
322impl FeatureDescriptorList {
323 pub fn new() -> FeatureDescriptorList {
324 ::std::default::Default::default()
325 }
326
327 pub fn get_feature_descriptors(&self) -> &[FeatureDescriptor] {
331 &self.feature_descriptors
332 }
333 pub fn clear_feature_descriptors(&mut self) {
334 self.feature_descriptors.clear();
335 }
336
337 pub fn set_feature_descriptors(&mut self, v: ::protobuf::RepeatedField<FeatureDescriptor>) {
339 self.feature_descriptors = v;
340 }
341
342 pub fn mut_feature_descriptors(&mut self) -> &mut ::protobuf::RepeatedField<FeatureDescriptor> {
344 &mut self.feature_descriptors
345 }
346
347 pub fn take_feature_descriptors(&mut self) -> ::protobuf::RepeatedField<FeatureDescriptor> {
349 ::std::mem::replace(&mut self.feature_descriptors, ::protobuf::RepeatedField::new())
350 }
351}
352
353impl ::protobuf::Message for FeatureDescriptorList {
354 fn is_initialized(&self) -> bool {
355 for v in &self.feature_descriptors {
356 if !v.is_initialized() {
357 return false;
358 }
359 };
360 true
361 }
362
363 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
364 while !is.eof()? {
365 let (field_number, wire_type) = is.read_tag_unpack()?;
366 match field_number {
367 1 => {
368 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.feature_descriptors)?;
369 },
370 _ => {
371 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
372 },
373 };
374 }
375 ::std::result::Result::Ok(())
376 }
377
378 #[allow(unused_variables)]
380 fn compute_size(&self) -> u32 {
381 let mut my_size = 0;
382 for value in &self.feature_descriptors {
383 let len = value.compute_size();
384 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
385 };
386 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
387 self.cached_size.set(my_size);
388 my_size
389 }
390
391 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
392 for v in &self.feature_descriptors {
393 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
394 os.write_raw_varint32(v.get_cached_size())?;
395 v.write_to_with_cached_sizes(os)?;
396 };
397 os.write_unknown_fields(self.get_unknown_fields())?;
398 ::std::result::Result::Ok(())
399 }
400
401 fn get_cached_size(&self) -> u32 {
402 self.cached_size.get()
403 }
404
405 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
406 &self.unknown_fields
407 }
408
409 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
410 &mut self.unknown_fields
411 }
412
413 fn as_any(&self) -> &dyn (::std::any::Any) {
414 self as &dyn (::std::any::Any)
415 }
416 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
417 self as &mut dyn (::std::any::Any)
418 }
419 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
420 self
421 }
422
423 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
424 Self::descriptor_static()
425 }
426
427 fn new() -> FeatureDescriptorList {
428 FeatureDescriptorList::new()
429 }
430
431 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
432 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
433 descriptor.get(|| {
434 let mut fields = ::std::vec::Vec::new();
435 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FeatureDescriptor>>(
436 "feature_descriptors",
437 |m: &FeatureDescriptorList| { &m.feature_descriptors },
438 |m: &mut FeatureDescriptorList| { &mut m.feature_descriptors },
439 ));
440 ::protobuf::reflect::MessageDescriptor::new_pb_name::<FeatureDescriptorList>(
441 "FeatureDescriptorList",
442 fields,
443 file_descriptor_proto()
444 )
445 })
446 }
447
448 fn default_instance() -> &'static FeatureDescriptorList {
449 static instance: ::protobuf::rt::LazyV2<FeatureDescriptorList> = ::protobuf::rt::LazyV2::INIT;
450 instance.get(FeatureDescriptorList::new)
451 }
452}
453
454impl ::protobuf::Clear for FeatureDescriptorList {
455 fn clear(&mut self) {
456 self.feature_descriptors.clear();
457 self.unknown_fields.clear();
458 }
459}
460
461impl ::std::fmt::Debug for FeatureDescriptorList {
462 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
463 ::protobuf::text_format::fmt(self, f)
464 }
465}
466
467impl ::protobuf::reflect::ProtobufValue for FeatureDescriptorList {
468 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
469 ::protobuf::reflect::ReflectValueRef::Message(self)
470 }
471}
472
473static file_descriptor_proto_data: &'static [u8] = b"\
474 \n*matrix_io/recognition/v1/recognition.proto\x12\x18matrix_io.recogniti\
475 on.v1\"z\n\x11FeatureDescriptor\x12\x14\n\x04uuid\x18\x01\x20\x01(\tR\
476 \x04uuidB\0\x12!\n\x0bdata_format\x18\x02\x20\x01(\tR\ndataFormatB\0\x12\
477 \x14\n\x04data\x18\x03\x20\x03(\x02R\x04dataB\0\x12\x14\n\x04tags\x18\
478 \x04\x20\x03(\tR\x04tagsB\0:\0\"y\n\x15FeatureDescriptorList\x12^\n\x13f\
479 eature_descriptors\x18\x01\x20\x03(\x0b2+.matrix_io.recognition.v1.Featu\
480 reDescriptorR\x12featureDescriptorsB\0:\0B\0b\x06proto3\
481";
482
483static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
484
485fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
486 ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
487}
488
489pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
490 file_descriptor_proto_lazy.get(|| {
491 parse_descriptor_proto()
492 })
493}