1#![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 StoreFeatureDescriptorsRequest {
28 pub vision_request: ::protobuf::SingularPtrField<super::vision_service::VisionRequest>,
30 pub tags: ::protobuf::RepeatedField<::std::string::String>,
31 pub feature_descriptors: ::protobuf::RepeatedField<super::recognition::FeatureDescriptor>,
32 pub device_id: ::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 StoreFeatureDescriptorsRequest {
39 fn default() -> &'a StoreFeatureDescriptorsRequest {
40 <StoreFeatureDescriptorsRequest as ::protobuf::Message>::default_instance()
41 }
42}
43
44impl StoreFeatureDescriptorsRequest {
45 pub fn new() -> StoreFeatureDescriptorsRequest {
46 ::std::default::Default::default()
47 }
48
49 pub fn get_vision_request(&self) -> &super::vision_service::VisionRequest {
53 self.vision_request.as_ref().unwrap_or_else(|| <super::vision_service::VisionRequest as ::protobuf::Message>::default_instance())
54 }
55 pub fn clear_vision_request(&mut self) {
56 self.vision_request.clear();
57 }
58
59 pub fn has_vision_request(&self) -> bool {
60 self.vision_request.is_some()
61 }
62
63 pub fn set_vision_request(&mut self, v: super::vision_service::VisionRequest) {
65 self.vision_request = ::protobuf::SingularPtrField::some(v);
66 }
67
68 pub fn mut_vision_request(&mut self) -> &mut super::vision_service::VisionRequest {
71 if self.vision_request.is_none() {
72 self.vision_request.set_default();
73 }
74 self.vision_request.as_mut().unwrap()
75 }
76
77 pub fn take_vision_request(&mut self) -> super::vision_service::VisionRequest {
79 self.vision_request.take().unwrap_or_else(|| super::vision_service::VisionRequest::new())
80 }
81
82 pub fn get_tags(&self) -> &[::std::string::String] {
86 &self.tags
87 }
88 pub fn clear_tags(&mut self) {
89 self.tags.clear();
90 }
91
92 pub fn set_tags(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
94 self.tags = v;
95 }
96
97 pub fn mut_tags(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
99 &mut self.tags
100 }
101
102 pub fn take_tags(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
104 ::std::mem::replace(&mut self.tags, ::protobuf::RepeatedField::new())
105 }
106
107 pub fn get_feature_descriptors(&self) -> &[super::recognition::FeatureDescriptor] {
111 &self.feature_descriptors
112 }
113 pub fn clear_feature_descriptors(&mut self) {
114 self.feature_descriptors.clear();
115 }
116
117 pub fn set_feature_descriptors(&mut self, v: ::protobuf::RepeatedField<super::recognition::FeatureDescriptor>) {
119 self.feature_descriptors = v;
120 }
121
122 pub fn mut_feature_descriptors(&mut self) -> &mut ::protobuf::RepeatedField<super::recognition::FeatureDescriptor> {
124 &mut self.feature_descriptors
125 }
126
127 pub fn take_feature_descriptors(&mut self) -> ::protobuf::RepeatedField<super::recognition::FeatureDescriptor> {
129 ::std::mem::replace(&mut self.feature_descriptors, ::protobuf::RepeatedField::new())
130 }
131
132 pub fn get_device_id(&self) -> &[::std::string::String] {
136 &self.device_id
137 }
138 pub fn clear_device_id(&mut self) {
139 self.device_id.clear();
140 }
141
142 pub fn set_device_id(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
144 self.device_id = v;
145 }
146
147 pub fn mut_device_id(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
149 &mut self.device_id
150 }
151
152 pub fn take_device_id(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
154 ::std::mem::replace(&mut self.device_id, ::protobuf::RepeatedField::new())
155 }
156}
157
158impl ::protobuf::Message for StoreFeatureDescriptorsRequest {
159 fn is_initialized(&self) -> bool {
160 for v in &self.vision_request {
161 if !v.is_initialized() {
162 return false;
163 }
164 };
165 for v in &self.feature_descriptors {
166 if !v.is_initialized() {
167 return false;
168 }
169 };
170 true
171 }
172
173 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
174 while !is.eof()? {
175 let (field_number, wire_type) = is.read_tag_unpack()?;
176 match field_number {
177 1 => {
178 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.vision_request)?;
179 },
180 2 => {
181 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.tags)?;
182 },
183 3 => {
184 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.feature_descriptors)?;
185 },
186 4 => {
187 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.device_id)?;
188 },
189 _ => {
190 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
191 },
192 };
193 }
194 ::std::result::Result::Ok(())
195 }
196
197 #[allow(unused_variables)]
199 fn compute_size(&self) -> u32 {
200 let mut my_size = 0;
201 if let Some(ref v) = self.vision_request.as_ref() {
202 let len = v.compute_size();
203 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
204 }
205 for value in &self.tags {
206 my_size += ::protobuf::rt::string_size(2, &value);
207 };
208 for value in &self.feature_descriptors {
209 let len = value.compute_size();
210 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
211 };
212 for value in &self.device_id {
213 my_size += ::protobuf::rt::string_size(4, &value);
214 };
215 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
216 self.cached_size.set(my_size);
217 my_size
218 }
219
220 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
221 if let Some(ref v) = self.vision_request.as_ref() {
222 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
223 os.write_raw_varint32(v.get_cached_size())?;
224 v.write_to_with_cached_sizes(os)?;
225 }
226 for v in &self.tags {
227 os.write_string(2, &v)?;
228 };
229 for v in &self.feature_descriptors {
230 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
231 os.write_raw_varint32(v.get_cached_size())?;
232 v.write_to_with_cached_sizes(os)?;
233 };
234 for v in &self.device_id {
235 os.write_string(4, &v)?;
236 };
237 os.write_unknown_fields(self.get_unknown_fields())?;
238 ::std::result::Result::Ok(())
239 }
240
241 fn get_cached_size(&self) -> u32 {
242 self.cached_size.get()
243 }
244
245 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
246 &self.unknown_fields
247 }
248
249 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
250 &mut self.unknown_fields
251 }
252
253 fn as_any(&self) -> &dyn (::std::any::Any) {
254 self as &dyn (::std::any::Any)
255 }
256 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
257 self as &mut dyn (::std::any::Any)
258 }
259 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
260 self
261 }
262
263 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
264 Self::descriptor_static()
265 }
266
267 fn new() -> StoreFeatureDescriptorsRequest {
268 StoreFeatureDescriptorsRequest::new()
269 }
270
271 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
272 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
273 descriptor.get(|| {
274 let mut fields = ::std::vec::Vec::new();
275 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::vision_service::VisionRequest>>(
276 "vision_request",
277 |m: &StoreFeatureDescriptorsRequest| { &m.vision_request },
278 |m: &mut StoreFeatureDescriptorsRequest| { &mut m.vision_request },
279 ));
280 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
281 "tags",
282 |m: &StoreFeatureDescriptorsRequest| { &m.tags },
283 |m: &mut StoreFeatureDescriptorsRequest| { &mut m.tags },
284 ));
285 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::recognition::FeatureDescriptor>>(
286 "feature_descriptors",
287 |m: &StoreFeatureDescriptorsRequest| { &m.feature_descriptors },
288 |m: &mut StoreFeatureDescriptorsRequest| { &mut m.feature_descriptors },
289 ));
290 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
291 "device_id",
292 |m: &StoreFeatureDescriptorsRequest| { &m.device_id },
293 |m: &mut StoreFeatureDescriptorsRequest| { &mut m.device_id },
294 ));
295 ::protobuf::reflect::MessageDescriptor::new_pb_name::<StoreFeatureDescriptorsRequest>(
296 "StoreFeatureDescriptorsRequest",
297 fields,
298 file_descriptor_proto()
299 )
300 })
301 }
302
303 fn default_instance() -> &'static StoreFeatureDescriptorsRequest {
304 static instance: ::protobuf::rt::LazyV2<StoreFeatureDescriptorsRequest> = ::protobuf::rt::LazyV2::INIT;
305 instance.get(StoreFeatureDescriptorsRequest::new)
306 }
307}
308
309impl ::protobuf::Clear for StoreFeatureDescriptorsRequest {
310 fn clear(&mut self) {
311 self.vision_request.clear();
312 self.tags.clear();
313 self.feature_descriptors.clear();
314 self.device_id.clear();
315 self.unknown_fields.clear();
316 }
317}
318
319impl ::std::fmt::Debug for StoreFeatureDescriptorsRequest {
320 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
321 ::protobuf::text_format::fmt(self, f)
322 }
323}
324
325impl ::protobuf::reflect::ProtobufValue for StoreFeatureDescriptorsRequest {
326 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
327 ::protobuf::reflect::ReflectValueRef::Message(self)
328 }
329}
330
331#[derive(PartialEq,Clone,Default)]
332pub struct StoreFeatureDescriptorsResponse {
333 pub uuids: ::protobuf::RepeatedField<::std::string::String>,
335 pub unknown_fields: ::protobuf::UnknownFields,
337 pub cached_size: ::protobuf::CachedSize,
338}
339
340impl<'a> ::std::default::Default for &'a StoreFeatureDescriptorsResponse {
341 fn default() -> &'a StoreFeatureDescriptorsResponse {
342 <StoreFeatureDescriptorsResponse as ::protobuf::Message>::default_instance()
343 }
344}
345
346impl StoreFeatureDescriptorsResponse {
347 pub fn new() -> StoreFeatureDescriptorsResponse {
348 ::std::default::Default::default()
349 }
350
351 pub fn get_uuids(&self) -> &[::std::string::String] {
355 &self.uuids
356 }
357 pub fn clear_uuids(&mut self) {
358 self.uuids.clear();
359 }
360
361 pub fn set_uuids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
363 self.uuids = v;
364 }
365
366 pub fn mut_uuids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
368 &mut self.uuids
369 }
370
371 pub fn take_uuids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
373 ::std::mem::replace(&mut self.uuids, ::protobuf::RepeatedField::new())
374 }
375}
376
377impl ::protobuf::Message for StoreFeatureDescriptorsResponse {
378 fn is_initialized(&self) -> bool {
379 true
380 }
381
382 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
383 while !is.eof()? {
384 let (field_number, wire_type) = is.read_tag_unpack()?;
385 match field_number {
386 1 => {
387 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.uuids)?;
388 },
389 _ => {
390 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
391 },
392 };
393 }
394 ::std::result::Result::Ok(())
395 }
396
397 #[allow(unused_variables)]
399 fn compute_size(&self) -> u32 {
400 let mut my_size = 0;
401 for value in &self.uuids {
402 my_size += ::protobuf::rt::string_size(1, &value);
403 };
404 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
405 self.cached_size.set(my_size);
406 my_size
407 }
408
409 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
410 for v in &self.uuids {
411 os.write_string(1, &v)?;
412 };
413 os.write_unknown_fields(self.get_unknown_fields())?;
414 ::std::result::Result::Ok(())
415 }
416
417 fn get_cached_size(&self) -> u32 {
418 self.cached_size.get()
419 }
420
421 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
422 &self.unknown_fields
423 }
424
425 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
426 &mut self.unknown_fields
427 }
428
429 fn as_any(&self) -> &dyn (::std::any::Any) {
430 self as &dyn (::std::any::Any)
431 }
432 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
433 self as &mut dyn (::std::any::Any)
434 }
435 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
436 self
437 }
438
439 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
440 Self::descriptor_static()
441 }
442
443 fn new() -> StoreFeatureDescriptorsResponse {
444 StoreFeatureDescriptorsResponse::new()
445 }
446
447 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
448 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
449 descriptor.get(|| {
450 let mut fields = ::std::vec::Vec::new();
451 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
452 "uuids",
453 |m: &StoreFeatureDescriptorsResponse| { &m.uuids },
454 |m: &mut StoreFeatureDescriptorsResponse| { &mut m.uuids },
455 ));
456 ::protobuf::reflect::MessageDescriptor::new_pb_name::<StoreFeatureDescriptorsResponse>(
457 "StoreFeatureDescriptorsResponse",
458 fields,
459 file_descriptor_proto()
460 )
461 })
462 }
463
464 fn default_instance() -> &'static StoreFeatureDescriptorsResponse {
465 static instance: ::protobuf::rt::LazyV2<StoreFeatureDescriptorsResponse> = ::protobuf::rt::LazyV2::INIT;
466 instance.get(StoreFeatureDescriptorsResponse::new)
467 }
468}
469
470impl ::protobuf::Clear for StoreFeatureDescriptorsResponse {
471 fn clear(&mut self) {
472 self.uuids.clear();
473 self.unknown_fields.clear();
474 }
475}
476
477impl ::std::fmt::Debug for StoreFeatureDescriptorsResponse {
478 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
479 ::protobuf::text_format::fmt(self, f)
480 }
481}
482
483impl ::protobuf::reflect::ProtobufValue for StoreFeatureDescriptorsResponse {
484 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
485 ::protobuf::reflect::ReflectValueRef::Message(self)
486 }
487}
488
489#[derive(PartialEq,Clone,Default)]
490pub struct GetFeatureDescriptorsRequest {
491 pub uuids: ::protobuf::RepeatedField<::std::string::String>,
493 pub tags: ::protobuf::RepeatedField<::std::string::String>,
494 pub device_id: ::std::string::String,
495 pub next_page_token: ::std::string::String,
496 pub unknown_fields: ::protobuf::UnknownFields,
498 pub cached_size: ::protobuf::CachedSize,
499}
500
501impl<'a> ::std::default::Default for &'a GetFeatureDescriptorsRequest {
502 fn default() -> &'a GetFeatureDescriptorsRequest {
503 <GetFeatureDescriptorsRequest as ::protobuf::Message>::default_instance()
504 }
505}
506
507impl GetFeatureDescriptorsRequest {
508 pub fn new() -> GetFeatureDescriptorsRequest {
509 ::std::default::Default::default()
510 }
511
512 pub fn get_uuids(&self) -> &[::std::string::String] {
516 &self.uuids
517 }
518 pub fn clear_uuids(&mut self) {
519 self.uuids.clear();
520 }
521
522 pub fn set_uuids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
524 self.uuids = v;
525 }
526
527 pub fn mut_uuids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
529 &mut self.uuids
530 }
531
532 pub fn take_uuids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
534 ::std::mem::replace(&mut self.uuids, ::protobuf::RepeatedField::new())
535 }
536
537 pub fn get_tags(&self) -> &[::std::string::String] {
541 &self.tags
542 }
543 pub fn clear_tags(&mut self) {
544 self.tags.clear();
545 }
546
547 pub fn set_tags(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
549 self.tags = v;
550 }
551
552 pub fn mut_tags(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
554 &mut self.tags
555 }
556
557 pub fn take_tags(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
559 ::std::mem::replace(&mut self.tags, ::protobuf::RepeatedField::new())
560 }
561
562 pub fn get_device_id(&self) -> &str {
566 &self.device_id
567 }
568 pub fn clear_device_id(&mut self) {
569 self.device_id.clear();
570 }
571
572 pub fn set_device_id(&mut self, v: ::std::string::String) {
574 self.device_id = v;
575 }
576
577 pub fn mut_device_id(&mut self) -> &mut ::std::string::String {
580 &mut self.device_id
581 }
582
583 pub fn take_device_id(&mut self) -> ::std::string::String {
585 ::std::mem::replace(&mut self.device_id, ::std::string::String::new())
586 }
587
588 pub fn get_next_page_token(&self) -> &str {
592 &self.next_page_token
593 }
594 pub fn clear_next_page_token(&mut self) {
595 self.next_page_token.clear();
596 }
597
598 pub fn set_next_page_token(&mut self, v: ::std::string::String) {
600 self.next_page_token = v;
601 }
602
603 pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String {
606 &mut self.next_page_token
607 }
608
609 pub fn take_next_page_token(&mut self) -> ::std::string::String {
611 ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new())
612 }
613}
614
615impl ::protobuf::Message for GetFeatureDescriptorsRequest {
616 fn is_initialized(&self) -> bool {
617 true
618 }
619
620 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
621 while !is.eof()? {
622 let (field_number, wire_type) = is.read_tag_unpack()?;
623 match field_number {
624 1 => {
625 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.uuids)?;
626 },
627 2 => {
628 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.tags)?;
629 },
630 3 => {
631 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.device_id)?;
632 },
633 4 => {
634 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?;
635 },
636 _ => {
637 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
638 },
639 };
640 }
641 ::std::result::Result::Ok(())
642 }
643
644 #[allow(unused_variables)]
646 fn compute_size(&self) -> u32 {
647 let mut my_size = 0;
648 for value in &self.uuids {
649 my_size += ::protobuf::rt::string_size(1, &value);
650 };
651 for value in &self.tags {
652 my_size += ::protobuf::rt::string_size(2, &value);
653 };
654 if !self.device_id.is_empty() {
655 my_size += ::protobuf::rt::string_size(3, &self.device_id);
656 }
657 if !self.next_page_token.is_empty() {
658 my_size += ::protobuf::rt::string_size(4, &self.next_page_token);
659 }
660 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
661 self.cached_size.set(my_size);
662 my_size
663 }
664
665 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
666 for v in &self.uuids {
667 os.write_string(1, &v)?;
668 };
669 for v in &self.tags {
670 os.write_string(2, &v)?;
671 };
672 if !self.device_id.is_empty() {
673 os.write_string(3, &self.device_id)?;
674 }
675 if !self.next_page_token.is_empty() {
676 os.write_string(4, &self.next_page_token)?;
677 }
678 os.write_unknown_fields(self.get_unknown_fields())?;
679 ::std::result::Result::Ok(())
680 }
681
682 fn get_cached_size(&self) -> u32 {
683 self.cached_size.get()
684 }
685
686 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
687 &self.unknown_fields
688 }
689
690 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
691 &mut self.unknown_fields
692 }
693
694 fn as_any(&self) -> &dyn (::std::any::Any) {
695 self as &dyn (::std::any::Any)
696 }
697 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
698 self as &mut dyn (::std::any::Any)
699 }
700 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
701 self
702 }
703
704 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
705 Self::descriptor_static()
706 }
707
708 fn new() -> GetFeatureDescriptorsRequest {
709 GetFeatureDescriptorsRequest::new()
710 }
711
712 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
713 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
714 descriptor.get(|| {
715 let mut fields = ::std::vec::Vec::new();
716 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
717 "uuids",
718 |m: &GetFeatureDescriptorsRequest| { &m.uuids },
719 |m: &mut GetFeatureDescriptorsRequest| { &mut m.uuids },
720 ));
721 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
722 "tags",
723 |m: &GetFeatureDescriptorsRequest| { &m.tags },
724 |m: &mut GetFeatureDescriptorsRequest| { &mut m.tags },
725 ));
726 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
727 "device_id",
728 |m: &GetFeatureDescriptorsRequest| { &m.device_id },
729 |m: &mut GetFeatureDescriptorsRequest| { &mut m.device_id },
730 ));
731 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
732 "next_page_token",
733 |m: &GetFeatureDescriptorsRequest| { &m.next_page_token },
734 |m: &mut GetFeatureDescriptorsRequest| { &mut m.next_page_token },
735 ));
736 ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetFeatureDescriptorsRequest>(
737 "GetFeatureDescriptorsRequest",
738 fields,
739 file_descriptor_proto()
740 )
741 })
742 }
743
744 fn default_instance() -> &'static GetFeatureDescriptorsRequest {
745 static instance: ::protobuf::rt::LazyV2<GetFeatureDescriptorsRequest> = ::protobuf::rt::LazyV2::INIT;
746 instance.get(GetFeatureDescriptorsRequest::new)
747 }
748}
749
750impl ::protobuf::Clear for GetFeatureDescriptorsRequest {
751 fn clear(&mut self) {
752 self.uuids.clear();
753 self.tags.clear();
754 self.device_id.clear();
755 self.next_page_token.clear();
756 self.unknown_fields.clear();
757 }
758}
759
760impl ::std::fmt::Debug for GetFeatureDescriptorsRequest {
761 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
762 ::protobuf::text_format::fmt(self, f)
763 }
764}
765
766impl ::protobuf::reflect::ProtobufValue for GetFeatureDescriptorsRequest {
767 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
768 ::protobuf::reflect::ReflectValueRef::Message(self)
769 }
770}
771
772#[derive(PartialEq,Clone,Default)]
773pub struct GetFeatureDescriptorsResponse {
774 pub feature_descriptor_list: ::protobuf::SingularPtrField<super::recognition::FeatureDescriptorList>,
776 pub next_page_token: ::std::string::String,
777 pub unknown_fields: ::protobuf::UnknownFields,
779 pub cached_size: ::protobuf::CachedSize,
780}
781
782impl<'a> ::std::default::Default for &'a GetFeatureDescriptorsResponse {
783 fn default() -> &'a GetFeatureDescriptorsResponse {
784 <GetFeatureDescriptorsResponse as ::protobuf::Message>::default_instance()
785 }
786}
787
788impl GetFeatureDescriptorsResponse {
789 pub fn new() -> GetFeatureDescriptorsResponse {
790 ::std::default::Default::default()
791 }
792
793 pub fn get_feature_descriptor_list(&self) -> &super::recognition::FeatureDescriptorList {
797 self.feature_descriptor_list.as_ref().unwrap_or_else(|| <super::recognition::FeatureDescriptorList as ::protobuf::Message>::default_instance())
798 }
799 pub fn clear_feature_descriptor_list(&mut self) {
800 self.feature_descriptor_list.clear();
801 }
802
803 pub fn has_feature_descriptor_list(&self) -> bool {
804 self.feature_descriptor_list.is_some()
805 }
806
807 pub fn set_feature_descriptor_list(&mut self, v: super::recognition::FeatureDescriptorList) {
809 self.feature_descriptor_list = ::protobuf::SingularPtrField::some(v);
810 }
811
812 pub fn mut_feature_descriptor_list(&mut self) -> &mut super::recognition::FeatureDescriptorList {
815 if self.feature_descriptor_list.is_none() {
816 self.feature_descriptor_list.set_default();
817 }
818 self.feature_descriptor_list.as_mut().unwrap()
819 }
820
821 pub fn take_feature_descriptor_list(&mut self) -> super::recognition::FeatureDescriptorList {
823 self.feature_descriptor_list.take().unwrap_or_else(|| super::recognition::FeatureDescriptorList::new())
824 }
825
826 pub fn get_next_page_token(&self) -> &str {
830 &self.next_page_token
831 }
832 pub fn clear_next_page_token(&mut self) {
833 self.next_page_token.clear();
834 }
835
836 pub fn set_next_page_token(&mut self, v: ::std::string::String) {
838 self.next_page_token = v;
839 }
840
841 pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String {
844 &mut self.next_page_token
845 }
846
847 pub fn take_next_page_token(&mut self) -> ::std::string::String {
849 ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new())
850 }
851}
852
853impl ::protobuf::Message for GetFeatureDescriptorsResponse {
854 fn is_initialized(&self) -> bool {
855 for v in &self.feature_descriptor_list {
856 if !v.is_initialized() {
857 return false;
858 }
859 };
860 true
861 }
862
863 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
864 while !is.eof()? {
865 let (field_number, wire_type) = is.read_tag_unpack()?;
866 match field_number {
867 1 => {
868 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.feature_descriptor_list)?;
869 },
870 2 => {
871 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?;
872 },
873 _ => {
874 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
875 },
876 };
877 }
878 ::std::result::Result::Ok(())
879 }
880
881 #[allow(unused_variables)]
883 fn compute_size(&self) -> u32 {
884 let mut my_size = 0;
885 if let Some(ref v) = self.feature_descriptor_list.as_ref() {
886 let len = v.compute_size();
887 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
888 }
889 if !self.next_page_token.is_empty() {
890 my_size += ::protobuf::rt::string_size(2, &self.next_page_token);
891 }
892 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
893 self.cached_size.set(my_size);
894 my_size
895 }
896
897 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
898 if let Some(ref v) = self.feature_descriptor_list.as_ref() {
899 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
900 os.write_raw_varint32(v.get_cached_size())?;
901 v.write_to_with_cached_sizes(os)?;
902 }
903 if !self.next_page_token.is_empty() {
904 os.write_string(2, &self.next_page_token)?;
905 }
906 os.write_unknown_fields(self.get_unknown_fields())?;
907 ::std::result::Result::Ok(())
908 }
909
910 fn get_cached_size(&self) -> u32 {
911 self.cached_size.get()
912 }
913
914 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
915 &self.unknown_fields
916 }
917
918 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
919 &mut self.unknown_fields
920 }
921
922 fn as_any(&self) -> &dyn (::std::any::Any) {
923 self as &dyn (::std::any::Any)
924 }
925 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
926 self as &mut dyn (::std::any::Any)
927 }
928 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
929 self
930 }
931
932 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
933 Self::descriptor_static()
934 }
935
936 fn new() -> GetFeatureDescriptorsResponse {
937 GetFeatureDescriptorsResponse::new()
938 }
939
940 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
941 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
942 descriptor.get(|| {
943 let mut fields = ::std::vec::Vec::new();
944 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::recognition::FeatureDescriptorList>>(
945 "feature_descriptor_list",
946 |m: &GetFeatureDescriptorsResponse| { &m.feature_descriptor_list },
947 |m: &mut GetFeatureDescriptorsResponse| { &mut m.feature_descriptor_list },
948 ));
949 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
950 "next_page_token",
951 |m: &GetFeatureDescriptorsResponse| { &m.next_page_token },
952 |m: &mut GetFeatureDescriptorsResponse| { &mut m.next_page_token },
953 ));
954 ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetFeatureDescriptorsResponse>(
955 "GetFeatureDescriptorsResponse",
956 fields,
957 file_descriptor_proto()
958 )
959 })
960 }
961
962 fn default_instance() -> &'static GetFeatureDescriptorsResponse {
963 static instance: ::protobuf::rt::LazyV2<GetFeatureDescriptorsResponse> = ::protobuf::rt::LazyV2::INIT;
964 instance.get(GetFeatureDescriptorsResponse::new)
965 }
966}
967
968impl ::protobuf::Clear for GetFeatureDescriptorsResponse {
969 fn clear(&mut self) {
970 self.feature_descriptor_list.clear();
971 self.next_page_token.clear();
972 self.unknown_fields.clear();
973 }
974}
975
976impl ::std::fmt::Debug for GetFeatureDescriptorsResponse {
977 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
978 ::protobuf::text_format::fmt(self, f)
979 }
980}
981
982impl ::protobuf::reflect::ProtobufValue for GetFeatureDescriptorsResponse {
983 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
984 ::protobuf::reflect::ReflectValueRef::Message(self)
985 }
986}
987
988#[derive(PartialEq,Clone,Default)]
989pub struct DeleteFeatureDescriptorsRequest {
990 pub uuids: ::protobuf::RepeatedField<::std::string::String>,
992 pub tags: ::protobuf::RepeatedField<::std::string::String>,
993 pub unknown_fields: ::protobuf::UnknownFields,
995 pub cached_size: ::protobuf::CachedSize,
996}
997
998impl<'a> ::std::default::Default for &'a DeleteFeatureDescriptorsRequest {
999 fn default() -> &'a DeleteFeatureDescriptorsRequest {
1000 <DeleteFeatureDescriptorsRequest as ::protobuf::Message>::default_instance()
1001 }
1002}
1003
1004impl DeleteFeatureDescriptorsRequest {
1005 pub fn new() -> DeleteFeatureDescriptorsRequest {
1006 ::std::default::Default::default()
1007 }
1008
1009 pub fn get_uuids(&self) -> &[::std::string::String] {
1013 &self.uuids
1014 }
1015 pub fn clear_uuids(&mut self) {
1016 self.uuids.clear();
1017 }
1018
1019 pub fn set_uuids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
1021 self.uuids = v;
1022 }
1023
1024 pub fn mut_uuids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
1026 &mut self.uuids
1027 }
1028
1029 pub fn take_uuids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
1031 ::std::mem::replace(&mut self.uuids, ::protobuf::RepeatedField::new())
1032 }
1033
1034 pub fn get_tags(&self) -> &[::std::string::String] {
1038 &self.tags
1039 }
1040 pub fn clear_tags(&mut self) {
1041 self.tags.clear();
1042 }
1043
1044 pub fn set_tags(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
1046 self.tags = v;
1047 }
1048
1049 pub fn mut_tags(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
1051 &mut self.tags
1052 }
1053
1054 pub fn take_tags(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
1056 ::std::mem::replace(&mut self.tags, ::protobuf::RepeatedField::new())
1057 }
1058}
1059
1060impl ::protobuf::Message for DeleteFeatureDescriptorsRequest {
1061 fn is_initialized(&self) -> bool {
1062 true
1063 }
1064
1065 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1066 while !is.eof()? {
1067 let (field_number, wire_type) = is.read_tag_unpack()?;
1068 match field_number {
1069 1 => {
1070 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.uuids)?;
1071 },
1072 2 => {
1073 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.tags)?;
1074 },
1075 _ => {
1076 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1077 },
1078 };
1079 }
1080 ::std::result::Result::Ok(())
1081 }
1082
1083 #[allow(unused_variables)]
1085 fn compute_size(&self) -> u32 {
1086 let mut my_size = 0;
1087 for value in &self.uuids {
1088 my_size += ::protobuf::rt::string_size(1, &value);
1089 };
1090 for value in &self.tags {
1091 my_size += ::protobuf::rt::string_size(2, &value);
1092 };
1093 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1094 self.cached_size.set(my_size);
1095 my_size
1096 }
1097
1098 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1099 for v in &self.uuids {
1100 os.write_string(1, &v)?;
1101 };
1102 for v in &self.tags {
1103 os.write_string(2, &v)?;
1104 };
1105 os.write_unknown_fields(self.get_unknown_fields())?;
1106 ::std::result::Result::Ok(())
1107 }
1108
1109 fn get_cached_size(&self) -> u32 {
1110 self.cached_size.get()
1111 }
1112
1113 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1114 &self.unknown_fields
1115 }
1116
1117 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1118 &mut self.unknown_fields
1119 }
1120
1121 fn as_any(&self) -> &dyn (::std::any::Any) {
1122 self as &dyn (::std::any::Any)
1123 }
1124 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1125 self as &mut dyn (::std::any::Any)
1126 }
1127 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1128 self
1129 }
1130
1131 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1132 Self::descriptor_static()
1133 }
1134
1135 fn new() -> DeleteFeatureDescriptorsRequest {
1136 DeleteFeatureDescriptorsRequest::new()
1137 }
1138
1139 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1140 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
1141 descriptor.get(|| {
1142 let mut fields = ::std::vec::Vec::new();
1143 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1144 "uuids",
1145 |m: &DeleteFeatureDescriptorsRequest| { &m.uuids },
1146 |m: &mut DeleteFeatureDescriptorsRequest| { &mut m.uuids },
1147 ));
1148 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1149 "tags",
1150 |m: &DeleteFeatureDescriptorsRequest| { &m.tags },
1151 |m: &mut DeleteFeatureDescriptorsRequest| { &mut m.tags },
1152 ));
1153 ::protobuf::reflect::MessageDescriptor::new_pb_name::<DeleteFeatureDescriptorsRequest>(
1154 "DeleteFeatureDescriptorsRequest",
1155 fields,
1156 file_descriptor_proto()
1157 )
1158 })
1159 }
1160
1161 fn default_instance() -> &'static DeleteFeatureDescriptorsRequest {
1162 static instance: ::protobuf::rt::LazyV2<DeleteFeatureDescriptorsRequest> = ::protobuf::rt::LazyV2::INIT;
1163 instance.get(DeleteFeatureDescriptorsRequest::new)
1164 }
1165}
1166
1167impl ::protobuf::Clear for DeleteFeatureDescriptorsRequest {
1168 fn clear(&mut self) {
1169 self.uuids.clear();
1170 self.tags.clear();
1171 self.unknown_fields.clear();
1172 }
1173}
1174
1175impl ::std::fmt::Debug for DeleteFeatureDescriptorsRequest {
1176 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1177 ::protobuf::text_format::fmt(self, f)
1178 }
1179}
1180
1181impl ::protobuf::reflect::ProtobufValue for DeleteFeatureDescriptorsRequest {
1182 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1183 ::protobuf::reflect::ReflectValueRef::Message(self)
1184 }
1185}
1186
1187#[derive(PartialEq,Clone,Default)]
1188pub struct DeleteFeatureDescriptorsResponse {
1189 pub uuids: ::protobuf::RepeatedField<::std::string::String>,
1191 pub unknown_fields: ::protobuf::UnknownFields,
1193 pub cached_size: ::protobuf::CachedSize,
1194}
1195
1196impl<'a> ::std::default::Default for &'a DeleteFeatureDescriptorsResponse {
1197 fn default() -> &'a DeleteFeatureDescriptorsResponse {
1198 <DeleteFeatureDescriptorsResponse as ::protobuf::Message>::default_instance()
1199 }
1200}
1201
1202impl DeleteFeatureDescriptorsResponse {
1203 pub fn new() -> DeleteFeatureDescriptorsResponse {
1204 ::std::default::Default::default()
1205 }
1206
1207 pub fn get_uuids(&self) -> &[::std::string::String] {
1211 &self.uuids
1212 }
1213 pub fn clear_uuids(&mut self) {
1214 self.uuids.clear();
1215 }
1216
1217 pub fn set_uuids(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
1219 self.uuids = v;
1220 }
1221
1222 pub fn mut_uuids(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
1224 &mut self.uuids
1225 }
1226
1227 pub fn take_uuids(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
1229 ::std::mem::replace(&mut self.uuids, ::protobuf::RepeatedField::new())
1230 }
1231}
1232
1233impl ::protobuf::Message for DeleteFeatureDescriptorsResponse {
1234 fn is_initialized(&self) -> bool {
1235 true
1236 }
1237
1238 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1239 while !is.eof()? {
1240 let (field_number, wire_type) = is.read_tag_unpack()?;
1241 match field_number {
1242 1 => {
1243 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.uuids)?;
1244 },
1245 _ => {
1246 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1247 },
1248 };
1249 }
1250 ::std::result::Result::Ok(())
1251 }
1252
1253 #[allow(unused_variables)]
1255 fn compute_size(&self) -> u32 {
1256 let mut my_size = 0;
1257 for value in &self.uuids {
1258 my_size += ::protobuf::rt::string_size(1, &value);
1259 };
1260 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1261 self.cached_size.set(my_size);
1262 my_size
1263 }
1264
1265 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1266 for v in &self.uuids {
1267 os.write_string(1, &v)?;
1268 };
1269 os.write_unknown_fields(self.get_unknown_fields())?;
1270 ::std::result::Result::Ok(())
1271 }
1272
1273 fn get_cached_size(&self) -> u32 {
1274 self.cached_size.get()
1275 }
1276
1277 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1278 &self.unknown_fields
1279 }
1280
1281 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1282 &mut self.unknown_fields
1283 }
1284
1285 fn as_any(&self) -> &dyn (::std::any::Any) {
1286 self as &dyn (::std::any::Any)
1287 }
1288 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1289 self as &mut dyn (::std::any::Any)
1290 }
1291 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1292 self
1293 }
1294
1295 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1296 Self::descriptor_static()
1297 }
1298
1299 fn new() -> DeleteFeatureDescriptorsResponse {
1300 DeleteFeatureDescriptorsResponse::new()
1301 }
1302
1303 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1304 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
1305 descriptor.get(|| {
1306 let mut fields = ::std::vec::Vec::new();
1307 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1308 "uuids",
1309 |m: &DeleteFeatureDescriptorsResponse| { &m.uuids },
1310 |m: &mut DeleteFeatureDescriptorsResponse| { &mut m.uuids },
1311 ));
1312 ::protobuf::reflect::MessageDescriptor::new_pb_name::<DeleteFeatureDescriptorsResponse>(
1313 "DeleteFeatureDescriptorsResponse",
1314 fields,
1315 file_descriptor_proto()
1316 )
1317 })
1318 }
1319
1320 fn default_instance() -> &'static DeleteFeatureDescriptorsResponse {
1321 static instance: ::protobuf::rt::LazyV2<DeleteFeatureDescriptorsResponse> = ::protobuf::rt::LazyV2::INIT;
1322 instance.get(DeleteFeatureDescriptorsResponse::new)
1323 }
1324}
1325
1326impl ::protobuf::Clear for DeleteFeatureDescriptorsResponse {
1327 fn clear(&mut self) {
1328 self.uuids.clear();
1329 self.unknown_fields.clear();
1330 }
1331}
1332
1333impl ::std::fmt::Debug for DeleteFeatureDescriptorsResponse {
1334 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1335 ::protobuf::text_format::fmt(self, f)
1336 }
1337}
1338
1339impl ::protobuf::reflect::ProtobufValue for DeleteFeatureDescriptorsResponse {
1340 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1341 ::protobuf::reflect::ReflectValueRef::Message(self)
1342 }
1343}
1344
1345#[derive(PartialEq,Clone,Default)]
1346pub struct RecognizeRequest {
1347 pub vision_request: ::protobuf::SingularPtrField<super::vision_service::VisionRequest>,
1349 pub feature_descriptor_list: ::protobuf::SingularPtrField<super::recognition::FeatureDescriptorList>,
1350 pub matching_algorithm_version: ::std::string::String,
1351 pub unknown_fields: ::protobuf::UnknownFields,
1353 pub cached_size: ::protobuf::CachedSize,
1354}
1355
1356impl<'a> ::std::default::Default for &'a RecognizeRequest {
1357 fn default() -> &'a RecognizeRequest {
1358 <RecognizeRequest as ::protobuf::Message>::default_instance()
1359 }
1360}
1361
1362impl RecognizeRequest {
1363 pub fn new() -> RecognizeRequest {
1364 ::std::default::Default::default()
1365 }
1366
1367 pub fn get_vision_request(&self) -> &super::vision_service::VisionRequest {
1371 self.vision_request.as_ref().unwrap_or_else(|| <super::vision_service::VisionRequest as ::protobuf::Message>::default_instance())
1372 }
1373 pub fn clear_vision_request(&mut self) {
1374 self.vision_request.clear();
1375 }
1376
1377 pub fn has_vision_request(&self) -> bool {
1378 self.vision_request.is_some()
1379 }
1380
1381 pub fn set_vision_request(&mut self, v: super::vision_service::VisionRequest) {
1383 self.vision_request = ::protobuf::SingularPtrField::some(v);
1384 }
1385
1386 pub fn mut_vision_request(&mut self) -> &mut super::vision_service::VisionRequest {
1389 if self.vision_request.is_none() {
1390 self.vision_request.set_default();
1391 }
1392 self.vision_request.as_mut().unwrap()
1393 }
1394
1395 pub fn take_vision_request(&mut self) -> super::vision_service::VisionRequest {
1397 self.vision_request.take().unwrap_or_else(|| super::vision_service::VisionRequest::new())
1398 }
1399
1400 pub fn get_feature_descriptor_list(&self) -> &super::recognition::FeatureDescriptorList {
1404 self.feature_descriptor_list.as_ref().unwrap_or_else(|| <super::recognition::FeatureDescriptorList as ::protobuf::Message>::default_instance())
1405 }
1406 pub fn clear_feature_descriptor_list(&mut self) {
1407 self.feature_descriptor_list.clear();
1408 }
1409
1410 pub fn has_feature_descriptor_list(&self) -> bool {
1411 self.feature_descriptor_list.is_some()
1412 }
1413
1414 pub fn set_feature_descriptor_list(&mut self, v: super::recognition::FeatureDescriptorList) {
1416 self.feature_descriptor_list = ::protobuf::SingularPtrField::some(v);
1417 }
1418
1419 pub fn mut_feature_descriptor_list(&mut self) -> &mut super::recognition::FeatureDescriptorList {
1422 if self.feature_descriptor_list.is_none() {
1423 self.feature_descriptor_list.set_default();
1424 }
1425 self.feature_descriptor_list.as_mut().unwrap()
1426 }
1427
1428 pub fn take_feature_descriptor_list(&mut self) -> super::recognition::FeatureDescriptorList {
1430 self.feature_descriptor_list.take().unwrap_or_else(|| super::recognition::FeatureDescriptorList::new())
1431 }
1432
1433 pub fn get_matching_algorithm_version(&self) -> &str {
1437 &self.matching_algorithm_version
1438 }
1439 pub fn clear_matching_algorithm_version(&mut self) {
1440 self.matching_algorithm_version.clear();
1441 }
1442
1443 pub fn set_matching_algorithm_version(&mut self, v: ::std::string::String) {
1445 self.matching_algorithm_version = v;
1446 }
1447
1448 pub fn mut_matching_algorithm_version(&mut self) -> &mut ::std::string::String {
1451 &mut self.matching_algorithm_version
1452 }
1453
1454 pub fn take_matching_algorithm_version(&mut self) -> ::std::string::String {
1456 ::std::mem::replace(&mut self.matching_algorithm_version, ::std::string::String::new())
1457 }
1458}
1459
1460impl ::protobuf::Message for RecognizeRequest {
1461 fn is_initialized(&self) -> bool {
1462 for v in &self.vision_request {
1463 if !v.is_initialized() {
1464 return false;
1465 }
1466 };
1467 for v in &self.feature_descriptor_list {
1468 if !v.is_initialized() {
1469 return false;
1470 }
1471 };
1472 true
1473 }
1474
1475 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1476 while !is.eof()? {
1477 let (field_number, wire_type) = is.read_tag_unpack()?;
1478 match field_number {
1479 1 => {
1480 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.vision_request)?;
1481 },
1482 2 => {
1483 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.feature_descriptor_list)?;
1484 },
1485 3 => {
1486 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.matching_algorithm_version)?;
1487 },
1488 _ => {
1489 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1490 },
1491 };
1492 }
1493 ::std::result::Result::Ok(())
1494 }
1495
1496 #[allow(unused_variables)]
1498 fn compute_size(&self) -> u32 {
1499 let mut my_size = 0;
1500 if let Some(ref v) = self.vision_request.as_ref() {
1501 let len = v.compute_size();
1502 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1503 }
1504 if let Some(ref v) = self.feature_descriptor_list.as_ref() {
1505 let len = v.compute_size();
1506 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1507 }
1508 if !self.matching_algorithm_version.is_empty() {
1509 my_size += ::protobuf::rt::string_size(3, &self.matching_algorithm_version);
1510 }
1511 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1512 self.cached_size.set(my_size);
1513 my_size
1514 }
1515
1516 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1517 if let Some(ref v) = self.vision_request.as_ref() {
1518 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1519 os.write_raw_varint32(v.get_cached_size())?;
1520 v.write_to_with_cached_sizes(os)?;
1521 }
1522 if let Some(ref v) = self.feature_descriptor_list.as_ref() {
1523 os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1524 os.write_raw_varint32(v.get_cached_size())?;
1525 v.write_to_with_cached_sizes(os)?;
1526 }
1527 if !self.matching_algorithm_version.is_empty() {
1528 os.write_string(3, &self.matching_algorithm_version)?;
1529 }
1530 os.write_unknown_fields(self.get_unknown_fields())?;
1531 ::std::result::Result::Ok(())
1532 }
1533
1534 fn get_cached_size(&self) -> u32 {
1535 self.cached_size.get()
1536 }
1537
1538 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1539 &self.unknown_fields
1540 }
1541
1542 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1543 &mut self.unknown_fields
1544 }
1545
1546 fn as_any(&self) -> &dyn (::std::any::Any) {
1547 self as &dyn (::std::any::Any)
1548 }
1549 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1550 self as &mut dyn (::std::any::Any)
1551 }
1552 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1553 self
1554 }
1555
1556 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1557 Self::descriptor_static()
1558 }
1559
1560 fn new() -> RecognizeRequest {
1561 RecognizeRequest::new()
1562 }
1563
1564 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1565 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
1566 descriptor.get(|| {
1567 let mut fields = ::std::vec::Vec::new();
1568 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::vision_service::VisionRequest>>(
1569 "vision_request",
1570 |m: &RecognizeRequest| { &m.vision_request },
1571 |m: &mut RecognizeRequest| { &mut m.vision_request },
1572 ));
1573 fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::recognition::FeatureDescriptorList>>(
1574 "feature_descriptor_list",
1575 |m: &RecognizeRequest| { &m.feature_descriptor_list },
1576 |m: &mut RecognizeRequest| { &mut m.feature_descriptor_list },
1577 ));
1578 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1579 "matching_algorithm_version",
1580 |m: &RecognizeRequest| { &m.matching_algorithm_version },
1581 |m: &mut RecognizeRequest| { &mut m.matching_algorithm_version },
1582 ));
1583 ::protobuf::reflect::MessageDescriptor::new_pb_name::<RecognizeRequest>(
1584 "RecognizeRequest",
1585 fields,
1586 file_descriptor_proto()
1587 )
1588 })
1589 }
1590
1591 fn default_instance() -> &'static RecognizeRequest {
1592 static instance: ::protobuf::rt::LazyV2<RecognizeRequest> = ::protobuf::rt::LazyV2::INIT;
1593 instance.get(RecognizeRequest::new)
1594 }
1595}
1596
1597impl ::protobuf::Clear for RecognizeRequest {
1598 fn clear(&mut self) {
1599 self.vision_request.clear();
1600 self.feature_descriptor_list.clear();
1601 self.matching_algorithm_version.clear();
1602 self.unknown_fields.clear();
1603 }
1604}
1605
1606impl ::std::fmt::Debug for RecognizeRequest {
1607 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1608 ::protobuf::text_format::fmt(self, f)
1609 }
1610}
1611
1612impl ::protobuf::reflect::ProtobufValue for RecognizeRequest {
1613 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1614 ::protobuf::reflect::ReflectValueRef::Message(self)
1615 }
1616}
1617
1618#[derive(PartialEq,Clone,Default)]
1619pub struct FeatureDescriptorMatch {
1620 pub tags: ::protobuf::RepeatedField<::std::string::String>,
1622 pub score: f32,
1623 pub unknown_fields: ::protobuf::UnknownFields,
1625 pub cached_size: ::protobuf::CachedSize,
1626}
1627
1628impl<'a> ::std::default::Default for &'a FeatureDescriptorMatch {
1629 fn default() -> &'a FeatureDescriptorMatch {
1630 <FeatureDescriptorMatch as ::protobuf::Message>::default_instance()
1631 }
1632}
1633
1634impl FeatureDescriptorMatch {
1635 pub fn new() -> FeatureDescriptorMatch {
1636 ::std::default::Default::default()
1637 }
1638
1639 pub fn get_tags(&self) -> &[::std::string::String] {
1643 &self.tags
1644 }
1645 pub fn clear_tags(&mut self) {
1646 self.tags.clear();
1647 }
1648
1649 pub fn set_tags(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
1651 self.tags = v;
1652 }
1653
1654 pub fn mut_tags(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
1656 &mut self.tags
1657 }
1658
1659 pub fn take_tags(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
1661 ::std::mem::replace(&mut self.tags, ::protobuf::RepeatedField::new())
1662 }
1663
1664 pub fn get_score(&self) -> f32 {
1668 self.score
1669 }
1670 pub fn clear_score(&mut self) {
1671 self.score = 0.;
1672 }
1673
1674 pub fn set_score(&mut self, v: f32) {
1676 self.score = v;
1677 }
1678}
1679
1680impl ::protobuf::Message for FeatureDescriptorMatch {
1681 fn is_initialized(&self) -> bool {
1682 true
1683 }
1684
1685 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1686 while !is.eof()? {
1687 let (field_number, wire_type) = is.read_tag_unpack()?;
1688 match field_number {
1689 1 => {
1690 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.tags)?;
1691 },
1692 2 => {
1693 if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
1694 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
1695 }
1696 let tmp = is.read_float()?;
1697 self.score = tmp;
1698 },
1699 _ => {
1700 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1701 },
1702 };
1703 }
1704 ::std::result::Result::Ok(())
1705 }
1706
1707 #[allow(unused_variables)]
1709 fn compute_size(&self) -> u32 {
1710 let mut my_size = 0;
1711 for value in &self.tags {
1712 my_size += ::protobuf::rt::string_size(1, &value);
1713 };
1714 if self.score != 0. {
1715 my_size += 5;
1716 }
1717 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1718 self.cached_size.set(my_size);
1719 my_size
1720 }
1721
1722 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1723 for v in &self.tags {
1724 os.write_string(1, &v)?;
1725 };
1726 if self.score != 0. {
1727 os.write_float(2, self.score)?;
1728 }
1729 os.write_unknown_fields(self.get_unknown_fields())?;
1730 ::std::result::Result::Ok(())
1731 }
1732
1733 fn get_cached_size(&self) -> u32 {
1734 self.cached_size.get()
1735 }
1736
1737 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1738 &self.unknown_fields
1739 }
1740
1741 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1742 &mut self.unknown_fields
1743 }
1744
1745 fn as_any(&self) -> &dyn (::std::any::Any) {
1746 self as &dyn (::std::any::Any)
1747 }
1748 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1749 self as &mut dyn (::std::any::Any)
1750 }
1751 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1752 self
1753 }
1754
1755 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1756 Self::descriptor_static()
1757 }
1758
1759 fn new() -> FeatureDescriptorMatch {
1760 FeatureDescriptorMatch::new()
1761 }
1762
1763 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1764 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
1765 descriptor.get(|| {
1766 let mut fields = ::std::vec::Vec::new();
1767 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
1768 "tags",
1769 |m: &FeatureDescriptorMatch| { &m.tags },
1770 |m: &mut FeatureDescriptorMatch| { &mut m.tags },
1771 ));
1772 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
1773 "score",
1774 |m: &FeatureDescriptorMatch| { &m.score },
1775 |m: &mut FeatureDescriptorMatch| { &mut m.score },
1776 ));
1777 ::protobuf::reflect::MessageDescriptor::new_pb_name::<FeatureDescriptorMatch>(
1778 "FeatureDescriptorMatch",
1779 fields,
1780 file_descriptor_proto()
1781 )
1782 })
1783 }
1784
1785 fn default_instance() -> &'static FeatureDescriptorMatch {
1786 static instance: ::protobuf::rt::LazyV2<FeatureDescriptorMatch> = ::protobuf::rt::LazyV2::INIT;
1787 instance.get(FeatureDescriptorMatch::new)
1788 }
1789}
1790
1791impl ::protobuf::Clear for FeatureDescriptorMatch {
1792 fn clear(&mut self) {
1793 self.tags.clear();
1794 self.score = 0.;
1795 self.unknown_fields.clear();
1796 }
1797}
1798
1799impl ::std::fmt::Debug for FeatureDescriptorMatch {
1800 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1801 ::protobuf::text_format::fmt(self, f)
1802 }
1803}
1804
1805impl ::protobuf::reflect::ProtobufValue for FeatureDescriptorMatch {
1806 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1807 ::protobuf::reflect::ReflectValueRef::Message(self)
1808 }
1809}
1810
1811#[derive(PartialEq,Clone,Default)]
1812pub struct RecognizeResponse {
1813 pub matches: ::protobuf::RepeatedField<FeatureDescriptorMatch>,
1815 pub unknown_fields: ::protobuf::UnknownFields,
1817 pub cached_size: ::protobuf::CachedSize,
1818}
1819
1820impl<'a> ::std::default::Default for &'a RecognizeResponse {
1821 fn default() -> &'a RecognizeResponse {
1822 <RecognizeResponse as ::protobuf::Message>::default_instance()
1823 }
1824}
1825
1826impl RecognizeResponse {
1827 pub fn new() -> RecognizeResponse {
1828 ::std::default::Default::default()
1829 }
1830
1831 pub fn get_matches(&self) -> &[FeatureDescriptorMatch] {
1835 &self.matches
1836 }
1837 pub fn clear_matches(&mut self) {
1838 self.matches.clear();
1839 }
1840
1841 pub fn set_matches(&mut self, v: ::protobuf::RepeatedField<FeatureDescriptorMatch>) {
1843 self.matches = v;
1844 }
1845
1846 pub fn mut_matches(&mut self) -> &mut ::protobuf::RepeatedField<FeatureDescriptorMatch> {
1848 &mut self.matches
1849 }
1850
1851 pub fn take_matches(&mut self) -> ::protobuf::RepeatedField<FeatureDescriptorMatch> {
1853 ::std::mem::replace(&mut self.matches, ::protobuf::RepeatedField::new())
1854 }
1855}
1856
1857impl ::protobuf::Message for RecognizeResponse {
1858 fn is_initialized(&self) -> bool {
1859 for v in &self.matches {
1860 if !v.is_initialized() {
1861 return false;
1862 }
1863 };
1864 true
1865 }
1866
1867 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1868 while !is.eof()? {
1869 let (field_number, wire_type) = is.read_tag_unpack()?;
1870 match field_number {
1871 1 => {
1872 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.matches)?;
1873 },
1874 _ => {
1875 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
1876 },
1877 };
1878 }
1879 ::std::result::Result::Ok(())
1880 }
1881
1882 #[allow(unused_variables)]
1884 fn compute_size(&self) -> u32 {
1885 let mut my_size = 0;
1886 for value in &self.matches {
1887 let len = value.compute_size();
1888 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
1889 };
1890 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
1891 self.cached_size.set(my_size);
1892 my_size
1893 }
1894
1895 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
1896 for v in &self.matches {
1897 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
1898 os.write_raw_varint32(v.get_cached_size())?;
1899 v.write_to_with_cached_sizes(os)?;
1900 };
1901 os.write_unknown_fields(self.get_unknown_fields())?;
1902 ::std::result::Result::Ok(())
1903 }
1904
1905 fn get_cached_size(&self) -> u32 {
1906 self.cached_size.get()
1907 }
1908
1909 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
1910 &self.unknown_fields
1911 }
1912
1913 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
1914 &mut self.unknown_fields
1915 }
1916
1917 fn as_any(&self) -> &dyn (::std::any::Any) {
1918 self as &dyn (::std::any::Any)
1919 }
1920 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
1921 self as &mut dyn (::std::any::Any)
1922 }
1923 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
1924 self
1925 }
1926
1927 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
1928 Self::descriptor_static()
1929 }
1930
1931 fn new() -> RecognizeResponse {
1932 RecognizeResponse::new()
1933 }
1934
1935 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
1936 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
1937 descriptor.get(|| {
1938 let mut fields = ::std::vec::Vec::new();
1939 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FeatureDescriptorMatch>>(
1940 "matches",
1941 |m: &RecognizeResponse| { &m.matches },
1942 |m: &mut RecognizeResponse| { &mut m.matches },
1943 ));
1944 ::protobuf::reflect::MessageDescriptor::new_pb_name::<RecognizeResponse>(
1945 "RecognizeResponse",
1946 fields,
1947 file_descriptor_proto()
1948 )
1949 })
1950 }
1951
1952 fn default_instance() -> &'static RecognizeResponse {
1953 static instance: ::protobuf::rt::LazyV2<RecognizeResponse> = ::protobuf::rt::LazyV2::INIT;
1954 instance.get(RecognizeResponse::new)
1955 }
1956}
1957
1958impl ::protobuf::Clear for RecognizeResponse {
1959 fn clear(&mut self) {
1960 self.matches.clear();
1961 self.unknown_fields.clear();
1962 }
1963}
1964
1965impl ::std::fmt::Debug for RecognizeResponse {
1966 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1967 ::protobuf::text_format::fmt(self, f)
1968 }
1969}
1970
1971impl ::protobuf::reflect::ProtobufValue for RecognizeResponse {
1972 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
1973 ::protobuf::reflect::ReflectValueRef::Message(self)
1974 }
1975}
1976
1977#[derive(PartialEq,Clone,Default)]
1978pub struct GetFeatureDescriptorTagsRequest {
1979 pub device_id: ::protobuf::RepeatedField<::std::string::String>,
1981 pub unknown_fields: ::protobuf::UnknownFields,
1983 pub cached_size: ::protobuf::CachedSize,
1984}
1985
1986impl<'a> ::std::default::Default for &'a GetFeatureDescriptorTagsRequest {
1987 fn default() -> &'a GetFeatureDescriptorTagsRequest {
1988 <GetFeatureDescriptorTagsRequest as ::protobuf::Message>::default_instance()
1989 }
1990}
1991
1992impl GetFeatureDescriptorTagsRequest {
1993 pub fn new() -> GetFeatureDescriptorTagsRequest {
1994 ::std::default::Default::default()
1995 }
1996
1997 pub fn get_device_id(&self) -> &[::std::string::String] {
2001 &self.device_id
2002 }
2003 pub fn clear_device_id(&mut self) {
2004 self.device_id.clear();
2005 }
2006
2007 pub fn set_device_id(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
2009 self.device_id = v;
2010 }
2011
2012 pub fn mut_device_id(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
2014 &mut self.device_id
2015 }
2016
2017 pub fn take_device_id(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
2019 ::std::mem::replace(&mut self.device_id, ::protobuf::RepeatedField::new())
2020 }
2021}
2022
2023impl ::protobuf::Message for GetFeatureDescriptorTagsRequest {
2024 fn is_initialized(&self) -> bool {
2025 true
2026 }
2027
2028 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2029 while !is.eof()? {
2030 let (field_number, wire_type) = is.read_tag_unpack()?;
2031 match field_number {
2032 1 => {
2033 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.device_id)?;
2034 },
2035 _ => {
2036 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2037 },
2038 };
2039 }
2040 ::std::result::Result::Ok(())
2041 }
2042
2043 #[allow(unused_variables)]
2045 fn compute_size(&self) -> u32 {
2046 let mut my_size = 0;
2047 for value in &self.device_id {
2048 my_size += ::protobuf::rt::string_size(1, &value);
2049 };
2050 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2051 self.cached_size.set(my_size);
2052 my_size
2053 }
2054
2055 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2056 for v in &self.device_id {
2057 os.write_string(1, &v)?;
2058 };
2059 os.write_unknown_fields(self.get_unknown_fields())?;
2060 ::std::result::Result::Ok(())
2061 }
2062
2063 fn get_cached_size(&self) -> u32 {
2064 self.cached_size.get()
2065 }
2066
2067 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2068 &self.unknown_fields
2069 }
2070
2071 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2072 &mut self.unknown_fields
2073 }
2074
2075 fn as_any(&self) -> &dyn (::std::any::Any) {
2076 self as &dyn (::std::any::Any)
2077 }
2078 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2079 self as &mut dyn (::std::any::Any)
2080 }
2081 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2082 self
2083 }
2084
2085 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2086 Self::descriptor_static()
2087 }
2088
2089 fn new() -> GetFeatureDescriptorTagsRequest {
2090 GetFeatureDescriptorTagsRequest::new()
2091 }
2092
2093 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2094 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
2095 descriptor.get(|| {
2096 let mut fields = ::std::vec::Vec::new();
2097 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2098 "device_id",
2099 |m: &GetFeatureDescriptorTagsRequest| { &m.device_id },
2100 |m: &mut GetFeatureDescriptorTagsRequest| { &mut m.device_id },
2101 ));
2102 ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetFeatureDescriptorTagsRequest>(
2103 "GetFeatureDescriptorTagsRequest",
2104 fields,
2105 file_descriptor_proto()
2106 )
2107 })
2108 }
2109
2110 fn default_instance() -> &'static GetFeatureDescriptorTagsRequest {
2111 static instance: ::protobuf::rt::LazyV2<GetFeatureDescriptorTagsRequest> = ::protobuf::rt::LazyV2::INIT;
2112 instance.get(GetFeatureDescriptorTagsRequest::new)
2113 }
2114}
2115
2116impl ::protobuf::Clear for GetFeatureDescriptorTagsRequest {
2117 fn clear(&mut self) {
2118 self.device_id.clear();
2119 self.unknown_fields.clear();
2120 }
2121}
2122
2123impl ::std::fmt::Debug for GetFeatureDescriptorTagsRequest {
2124 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2125 ::protobuf::text_format::fmt(self, f)
2126 }
2127}
2128
2129impl ::protobuf::reflect::ProtobufValue for GetFeatureDescriptorTagsRequest {
2130 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2131 ::protobuf::reflect::ReflectValueRef::Message(self)
2132 }
2133}
2134
2135#[derive(PartialEq,Clone,Default)]
2136pub struct FeatureDescriptorTagsForDevice {
2137 pub tags: ::protobuf::RepeatedField<::std::string::String>,
2139 pub device_id: ::std::string::String,
2140 pub unknown_fields: ::protobuf::UnknownFields,
2142 pub cached_size: ::protobuf::CachedSize,
2143}
2144
2145impl<'a> ::std::default::Default for &'a FeatureDescriptorTagsForDevice {
2146 fn default() -> &'a FeatureDescriptorTagsForDevice {
2147 <FeatureDescriptorTagsForDevice as ::protobuf::Message>::default_instance()
2148 }
2149}
2150
2151impl FeatureDescriptorTagsForDevice {
2152 pub fn new() -> FeatureDescriptorTagsForDevice {
2153 ::std::default::Default::default()
2154 }
2155
2156 pub fn get_tags(&self) -> &[::std::string::String] {
2160 &self.tags
2161 }
2162 pub fn clear_tags(&mut self) {
2163 self.tags.clear();
2164 }
2165
2166 pub fn set_tags(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
2168 self.tags = v;
2169 }
2170
2171 pub fn mut_tags(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
2173 &mut self.tags
2174 }
2175
2176 pub fn take_tags(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
2178 ::std::mem::replace(&mut self.tags, ::protobuf::RepeatedField::new())
2179 }
2180
2181 pub fn get_device_id(&self) -> &str {
2185 &self.device_id
2186 }
2187 pub fn clear_device_id(&mut self) {
2188 self.device_id.clear();
2189 }
2190
2191 pub fn set_device_id(&mut self, v: ::std::string::String) {
2193 self.device_id = v;
2194 }
2195
2196 pub fn mut_device_id(&mut self) -> &mut ::std::string::String {
2199 &mut self.device_id
2200 }
2201
2202 pub fn take_device_id(&mut self) -> ::std::string::String {
2204 ::std::mem::replace(&mut self.device_id, ::std::string::String::new())
2205 }
2206}
2207
2208impl ::protobuf::Message for FeatureDescriptorTagsForDevice {
2209 fn is_initialized(&self) -> bool {
2210 true
2211 }
2212
2213 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2214 while !is.eof()? {
2215 let (field_number, wire_type) = is.read_tag_unpack()?;
2216 match field_number {
2217 1 => {
2218 ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.tags)?;
2219 },
2220 2 => {
2221 ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.device_id)?;
2222 },
2223 _ => {
2224 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2225 },
2226 };
2227 }
2228 ::std::result::Result::Ok(())
2229 }
2230
2231 #[allow(unused_variables)]
2233 fn compute_size(&self) -> u32 {
2234 let mut my_size = 0;
2235 for value in &self.tags {
2236 my_size += ::protobuf::rt::string_size(1, &value);
2237 };
2238 if !self.device_id.is_empty() {
2239 my_size += ::protobuf::rt::string_size(2, &self.device_id);
2240 }
2241 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2242 self.cached_size.set(my_size);
2243 my_size
2244 }
2245
2246 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2247 for v in &self.tags {
2248 os.write_string(1, &v)?;
2249 };
2250 if !self.device_id.is_empty() {
2251 os.write_string(2, &self.device_id)?;
2252 }
2253 os.write_unknown_fields(self.get_unknown_fields())?;
2254 ::std::result::Result::Ok(())
2255 }
2256
2257 fn get_cached_size(&self) -> u32 {
2258 self.cached_size.get()
2259 }
2260
2261 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2262 &self.unknown_fields
2263 }
2264
2265 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2266 &mut self.unknown_fields
2267 }
2268
2269 fn as_any(&self) -> &dyn (::std::any::Any) {
2270 self as &dyn (::std::any::Any)
2271 }
2272 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2273 self as &mut dyn (::std::any::Any)
2274 }
2275 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2276 self
2277 }
2278
2279 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2280 Self::descriptor_static()
2281 }
2282
2283 fn new() -> FeatureDescriptorTagsForDevice {
2284 FeatureDescriptorTagsForDevice::new()
2285 }
2286
2287 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2288 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
2289 descriptor.get(|| {
2290 let mut fields = ::std::vec::Vec::new();
2291 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2292 "tags",
2293 |m: &FeatureDescriptorTagsForDevice| { &m.tags },
2294 |m: &mut FeatureDescriptorTagsForDevice| { &mut m.tags },
2295 ));
2296 fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
2297 "device_id",
2298 |m: &FeatureDescriptorTagsForDevice| { &m.device_id },
2299 |m: &mut FeatureDescriptorTagsForDevice| { &mut m.device_id },
2300 ));
2301 ::protobuf::reflect::MessageDescriptor::new_pb_name::<FeatureDescriptorTagsForDevice>(
2302 "FeatureDescriptorTagsForDevice",
2303 fields,
2304 file_descriptor_proto()
2305 )
2306 })
2307 }
2308
2309 fn default_instance() -> &'static FeatureDescriptorTagsForDevice {
2310 static instance: ::protobuf::rt::LazyV2<FeatureDescriptorTagsForDevice> = ::protobuf::rt::LazyV2::INIT;
2311 instance.get(FeatureDescriptorTagsForDevice::new)
2312 }
2313}
2314
2315impl ::protobuf::Clear for FeatureDescriptorTagsForDevice {
2316 fn clear(&mut self) {
2317 self.tags.clear();
2318 self.device_id.clear();
2319 self.unknown_fields.clear();
2320 }
2321}
2322
2323impl ::std::fmt::Debug for FeatureDescriptorTagsForDevice {
2324 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2325 ::protobuf::text_format::fmt(self, f)
2326 }
2327}
2328
2329impl ::protobuf::reflect::ProtobufValue for FeatureDescriptorTagsForDevice {
2330 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2331 ::protobuf::reflect::ReflectValueRef::Message(self)
2332 }
2333}
2334
2335#[derive(PartialEq,Clone,Default)]
2336pub struct GetFeatureDescriptorTagsResponse {
2337 pub feature_tags_for_device: ::protobuf::RepeatedField<FeatureDescriptorTagsForDevice>,
2339 pub unknown_fields: ::protobuf::UnknownFields,
2341 pub cached_size: ::protobuf::CachedSize,
2342}
2343
2344impl<'a> ::std::default::Default for &'a GetFeatureDescriptorTagsResponse {
2345 fn default() -> &'a GetFeatureDescriptorTagsResponse {
2346 <GetFeatureDescriptorTagsResponse as ::protobuf::Message>::default_instance()
2347 }
2348}
2349
2350impl GetFeatureDescriptorTagsResponse {
2351 pub fn new() -> GetFeatureDescriptorTagsResponse {
2352 ::std::default::Default::default()
2353 }
2354
2355 pub fn get_feature_tags_for_device(&self) -> &[FeatureDescriptorTagsForDevice] {
2359 &self.feature_tags_for_device
2360 }
2361 pub fn clear_feature_tags_for_device(&mut self) {
2362 self.feature_tags_for_device.clear();
2363 }
2364
2365 pub fn set_feature_tags_for_device(&mut self, v: ::protobuf::RepeatedField<FeatureDescriptorTagsForDevice>) {
2367 self.feature_tags_for_device = v;
2368 }
2369
2370 pub fn mut_feature_tags_for_device(&mut self) -> &mut ::protobuf::RepeatedField<FeatureDescriptorTagsForDevice> {
2372 &mut self.feature_tags_for_device
2373 }
2374
2375 pub fn take_feature_tags_for_device(&mut self) -> ::protobuf::RepeatedField<FeatureDescriptorTagsForDevice> {
2377 ::std::mem::replace(&mut self.feature_tags_for_device, ::protobuf::RepeatedField::new())
2378 }
2379}
2380
2381impl ::protobuf::Message for GetFeatureDescriptorTagsResponse {
2382 fn is_initialized(&self) -> bool {
2383 for v in &self.feature_tags_for_device {
2384 if !v.is_initialized() {
2385 return false;
2386 }
2387 };
2388 true
2389 }
2390
2391 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2392 while !is.eof()? {
2393 let (field_number, wire_type) = is.read_tag_unpack()?;
2394 match field_number {
2395 1 => {
2396 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.feature_tags_for_device)?;
2397 },
2398 _ => {
2399 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
2400 },
2401 };
2402 }
2403 ::std::result::Result::Ok(())
2404 }
2405
2406 #[allow(unused_variables)]
2408 fn compute_size(&self) -> u32 {
2409 let mut my_size = 0;
2410 for value in &self.feature_tags_for_device {
2411 let len = value.compute_size();
2412 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
2413 };
2414 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
2415 self.cached_size.set(my_size);
2416 my_size
2417 }
2418
2419 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
2420 for v in &self.feature_tags_for_device {
2421 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
2422 os.write_raw_varint32(v.get_cached_size())?;
2423 v.write_to_with_cached_sizes(os)?;
2424 };
2425 os.write_unknown_fields(self.get_unknown_fields())?;
2426 ::std::result::Result::Ok(())
2427 }
2428
2429 fn get_cached_size(&self) -> u32 {
2430 self.cached_size.get()
2431 }
2432
2433 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
2434 &self.unknown_fields
2435 }
2436
2437 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
2438 &mut self.unknown_fields
2439 }
2440
2441 fn as_any(&self) -> &dyn (::std::any::Any) {
2442 self as &dyn (::std::any::Any)
2443 }
2444 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
2445 self as &mut dyn (::std::any::Any)
2446 }
2447 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
2448 self
2449 }
2450
2451 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
2452 Self::descriptor_static()
2453 }
2454
2455 fn new() -> GetFeatureDescriptorTagsResponse {
2456 GetFeatureDescriptorTagsResponse::new()
2457 }
2458
2459 fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
2460 static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
2461 descriptor.get(|| {
2462 let mut fields = ::std::vec::Vec::new();
2463 fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FeatureDescriptorTagsForDevice>>(
2464 "feature_tags_for_device",
2465 |m: &GetFeatureDescriptorTagsResponse| { &m.feature_tags_for_device },
2466 |m: &mut GetFeatureDescriptorTagsResponse| { &mut m.feature_tags_for_device },
2467 ));
2468 ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetFeatureDescriptorTagsResponse>(
2469 "GetFeatureDescriptorTagsResponse",
2470 fields,
2471 file_descriptor_proto()
2472 )
2473 })
2474 }
2475
2476 fn default_instance() -> &'static GetFeatureDescriptorTagsResponse {
2477 static instance: ::protobuf::rt::LazyV2<GetFeatureDescriptorTagsResponse> = ::protobuf::rt::LazyV2::INIT;
2478 instance.get(GetFeatureDescriptorTagsResponse::new)
2479 }
2480}
2481
2482impl ::protobuf::Clear for GetFeatureDescriptorTagsResponse {
2483 fn clear(&mut self) {
2484 self.feature_tags_for_device.clear();
2485 self.unknown_fields.clear();
2486 }
2487}
2488
2489impl ::std::fmt::Debug for GetFeatureDescriptorTagsResponse {
2490 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2491 ::protobuf::text_format::fmt(self, f)
2492 }
2493}
2494
2495impl ::protobuf::reflect::ProtobufValue for GetFeatureDescriptorTagsResponse {
2496 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
2497 ::protobuf::reflect::ReflectValueRef::Message(self)
2498 }
2499}
2500
2501static file_descriptor_proto_data: &'static [u8] = b"\
2502 \n2matrix_io/recognition/v1/recognition_service.proto\x12\x18matrix_io.r\
2503 ecognition.v1\x1a(matrix_io/vision/v1/vision_service.proto\x1a*matrix_io\
2504 /recognition/v1/recognition.proto\"\x84\x02\n\x1eStoreFeatureDescriptors\
2505 Request\x12K\n\x0evision_request\x18\x01\x20\x01(\x0b2\".matrix_io.visio\
2506 n.v1.VisionRequestR\rvisionRequestB\0\x12\x14\n\x04tags\x18\x02\x20\x03(\
2507 \tR\x04tagsB\0\x12^\n\x13feature_descriptors\x18\x03\x20\x03(\x0b2+.matr\
2508 ix_io.recognition.v1.FeatureDescriptorR\x12featureDescriptorsB\0\x12\x1d\
2509 \n\tdevice_id\x18\x04\x20\x03(\tR\x08deviceIdB\0:\0\";\n\x1fStoreFeature\
2510 DescriptorsResponse\x12\x16\n\x05uuids\x18\x01\x20\x03(\tR\x05uuidsB\0:\
2511 \0\"\x97\x01\n\x1cGetFeatureDescriptorsRequest\x12\x16\n\x05uuids\x18\
2512 \x01\x20\x03(\tR\x05uuidsB\0\x12\x14\n\x04tags\x18\x02\x20\x03(\tR\x04ta\
2513 gsB\0\x12\x1d\n\tdevice_id\x18\x03\x20\x01(\tR\x08deviceIdB\0\x12(\n\x0f\
2514 next_page_token\x18\x04\x20\x01(\tR\rnextPageTokenB\0:\0\"\xb6\x01\n\x1d\
2515 GetFeatureDescriptorsResponse\x12i\n\x17feature_descriptor_list\x18\x01\
2516 \x20\x01(\x0b2/.matrix_io.recognition.v1.FeatureDescriptorListR\x15featu\
2517 reDescriptorListB\0\x12(\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextP\
2518 ageTokenB\0:\0\"Q\n\x1fDeleteFeatureDescriptorsRequest\x12\x16\n\x05uuid\
2519 s\x18\x01\x20\x03(\tR\x05uuidsB\0\x12\x14\n\x04tags\x18\x02\x20\x03(\tR\
2520 \x04tagsB\0:\0\"<\n\x20DeleteFeatureDescriptorsResponse\x12\x16\n\x05uui\
2521 ds\x18\x01\x20\x03(\tR\x05uuidsB\0:\0\"\x8c\x02\n\x10RecognizeRequest\
2522 \x12K\n\x0evision_request\x18\x01\x20\x01(\x0b2\".matrix_io.vision.v1.Vi\
2523 sionRequestR\rvisionRequestB\0\x12i\n\x17feature_descriptor_list\x18\x02\
2524 \x20\x01(\x0b2/.matrix_io.recognition.v1.FeatureDescriptorListR\x15featu\
2525 reDescriptorListB\0\x12>\n\x1amatching_algorithm_version\x18\x03\x20\x01\
2526 (\tR\x18matchingAlgorithmVersionB\0:\0\"H\n\x16FeatureDescriptorMatch\
2527 \x12\x14\n\x04tags\x18\x01\x20\x03(\tR\x04tagsB\0\x12\x16\n\x05score\x18\
2528 \x02\x20\x01(\x02R\x05scoreB\0:\0\"c\n\x11RecognizeResponse\x12L\n\x07ma\
2529 tches\x18\x01\x20\x03(\x0b20.matrix_io.recognition.v1.FeatureDescriptorM\
2530 atchR\x07matchesB\0:\0\"B\n\x1fGetFeatureDescriptorTagsRequest\x12\x1d\n\
2531 \tdevice_id\x18\x01\x20\x03(\tR\x08deviceIdB\0:\0\"W\n\x1eFeatureDescrip\
2532 torTagsForDevice\x12\x14\n\x04tags\x18\x01\x20\x03(\tR\x04tagsB\0\x12\
2533 \x1d\n\tdevice_id\x18\x02\x20\x01(\tR\x08deviceIdB\0:\0\"\x97\x01\n\x20G\
2534 etFeatureDescriptorTagsResponse\x12q\n\x17feature_tags_for_device\x18\
2535 \x01\x20\x03(\x0b28.matrix_io.recognition.v1.FeatureDescriptorTagsForDev\
2536 iceR\x14featureTagsForDeviceB\0:\0B\0b\x06proto3\
2537";
2538
2539static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
2540
2541fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
2542 ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
2543}
2544
2545pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
2546 file_descriptor_proto_lazy.get(|| {
2547 parse_descriptor_proto()
2548 })
2549}