1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: opencv-onnx.proto
3 
4 #ifndef PROTOBUF_opencv_2donnx_2eproto__INCLUDED
5 #define PROTOBUF_opencv_2donnx_2eproto__INCLUDED
6 
7 #include <string>
8 
9 #include <google/protobuf/stubs/common.h>
10 
11 #if GOOGLE_PROTOBUF_VERSION < 3005000
12 #error This file was generated by a newer version of protoc which is
13 #error incompatible with your Protocol Buffer headers.  Please update
14 #error your headers.
15 #endif
16 #if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
17 #error This file was generated by an older version of protoc which is
18 #error incompatible with your Protocol Buffer headers.  Please
19 #error regenerate this file with a newer version of protoc.
20 #endif
21 
22 #include <google/protobuf/io/coded_stream.h>
23 #include <google/protobuf/arena.h>
24 #include <google/protobuf/arenastring.h>
25 #include <google/protobuf/generated_message_table_driven.h>
26 #include <google/protobuf/generated_message_util.h>
27 #include <google/protobuf/metadata.h>
28 #include <google/protobuf/message.h>
29 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
30 #include <google/protobuf/extension_set.h>  // IWYU pragma: export
31 #include <google/protobuf/generated_enum_reflection.h>
32 #include <google/protobuf/unknown_field_set.h>
33 // @@protoc_insertion_point(includes)
34 
35 namespace protobuf_opencv_2donnx_2eproto {
36 // Internal implementation detail -- do not use these members.
37 struct TableStruct {
38   static const ::google::protobuf::internal::ParseTableField entries[];
39   static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
40   static const ::google::protobuf::internal::ParseTable schema[13];
41   static const ::google::protobuf::internal::FieldMetadata field_metadata[];
42   static const ::google::protobuf::internal::SerializationTable serialization_table[];
43   static const ::google::protobuf::uint32 offsets[];
44 };
45 void AddDescriptors();
46 void InitDefaultsAttributeProtoImpl();
47 void InitDefaultsAttributeProto();
48 void InitDefaultsValueInfoProtoImpl();
49 void InitDefaultsValueInfoProto();
50 void InitDefaultsModelProtoImpl();
51 void InitDefaultsModelProto();
52 void InitDefaultsStringStringEntryProtoImpl();
53 void InitDefaultsStringStringEntryProto();
54 void InitDefaultsTensorProto_SegmentImpl();
55 void InitDefaultsTensorProto_Segment();
56 void InitDefaultsTensorProtoImpl();
57 void InitDefaultsTensorProto();
58 void InitDefaultsTensorShapeProto_DimensionImpl();
59 void InitDefaultsTensorShapeProto_Dimension();
60 void InitDefaultsTensorShapeProtoImpl();
61 void InitDefaultsTensorShapeProto();
62 void InitDefaultsTypeProto_TensorImpl();
63 void InitDefaultsTypeProto_Tensor();
64 void InitDefaultsTypeProtoImpl();
65 void InitDefaultsTypeProto();
66 void InitDefaultsOperatorSetIdProtoImpl();
67 void InitDefaultsOperatorSetIdProto();
InitDefaults()68 inline void InitDefaults() {
69   InitDefaultsAttributeProto();
70   InitDefaultsValueInfoProto();
71   InitDefaultsModelProto();
72   InitDefaultsStringStringEntryProto();
73   InitDefaultsTensorProto_Segment();
74   InitDefaultsTensorProto();
75   InitDefaultsTensorShapeProto_Dimension();
76   InitDefaultsTensorShapeProto();
77   InitDefaultsTypeProto_Tensor();
78   InitDefaultsTypeProto();
79   InitDefaultsOperatorSetIdProto();
80 }
81 }  // namespace protobuf_opencv_2donnx_2eproto
82 namespace opencv_onnx {
83 class AttributeProto;
84 class AttributeProtoDefaultTypeInternal;
85 extern AttributeProtoDefaultTypeInternal _AttributeProto_default_instance_;
86 class GraphProto;
87 class GraphProtoDefaultTypeInternal;
88 extern GraphProtoDefaultTypeInternal _GraphProto_default_instance_;
89 class ModelProto;
90 class ModelProtoDefaultTypeInternal;
91 extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_;
92 class NodeProto;
93 class NodeProtoDefaultTypeInternal;
94 extern NodeProtoDefaultTypeInternal _NodeProto_default_instance_;
95 class OperatorSetIdProto;
96 class OperatorSetIdProtoDefaultTypeInternal;
97 extern OperatorSetIdProtoDefaultTypeInternal _OperatorSetIdProto_default_instance_;
98 class StringStringEntryProto;
99 class StringStringEntryProtoDefaultTypeInternal;
100 extern StringStringEntryProtoDefaultTypeInternal _StringStringEntryProto_default_instance_;
101 class TensorProto;
102 class TensorProtoDefaultTypeInternal;
103 extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
104 class TensorProto_Segment;
105 class TensorProto_SegmentDefaultTypeInternal;
106 extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_;
107 class TensorShapeProto;
108 class TensorShapeProtoDefaultTypeInternal;
109 extern TensorShapeProtoDefaultTypeInternal _TensorShapeProto_default_instance_;
110 class TensorShapeProto_Dimension;
111 class TensorShapeProto_DimensionDefaultTypeInternal;
112 extern TensorShapeProto_DimensionDefaultTypeInternal _TensorShapeProto_Dimension_default_instance_;
113 class TypeProto;
114 class TypeProtoDefaultTypeInternal;
115 extern TypeProtoDefaultTypeInternal _TypeProto_default_instance_;
116 class TypeProto_Tensor;
117 class TypeProto_TensorDefaultTypeInternal;
118 extern TypeProto_TensorDefaultTypeInternal _TypeProto_Tensor_default_instance_;
119 class ValueInfoProto;
120 class ValueInfoProtoDefaultTypeInternal;
121 extern ValueInfoProtoDefaultTypeInternal _ValueInfoProto_default_instance_;
122 }  // namespace opencv_onnx
123 namespace opencv_onnx {
124 
125 enum AttributeProto_AttributeType {
126   AttributeProto_AttributeType_UNDEFINED = 0,
127   AttributeProto_AttributeType_FLOAT = 1,
128   AttributeProto_AttributeType_INT = 2,
129   AttributeProto_AttributeType_STRING = 3,
130   AttributeProto_AttributeType_TENSOR = 4,
131   AttributeProto_AttributeType_GRAPH = 5,
132   AttributeProto_AttributeType_FLOATS = 6,
133   AttributeProto_AttributeType_INTS = 7,
134   AttributeProto_AttributeType_STRINGS = 8,
135   AttributeProto_AttributeType_TENSORS = 9,
136   AttributeProto_AttributeType_GRAPHS = 10
137 };
138 bool AttributeProto_AttributeType_IsValid(int value);
139 const AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MIN = AttributeProto_AttributeType_UNDEFINED;
140 const AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MAX = AttributeProto_AttributeType_GRAPHS;
141 const int AttributeProto_AttributeType_AttributeType_ARRAYSIZE = AttributeProto_AttributeType_AttributeType_MAX + 1;
142 
143 const ::google::protobuf::EnumDescriptor* AttributeProto_AttributeType_descriptor();
AttributeProto_AttributeType_Name(AttributeProto_AttributeType value)144 inline const ::std::string& AttributeProto_AttributeType_Name(AttributeProto_AttributeType value) {
145   return ::google::protobuf::internal::NameOfEnum(
146     AttributeProto_AttributeType_descriptor(), value);
147 }
AttributeProto_AttributeType_Parse(const::std::string & name,AttributeProto_AttributeType * value)148 inline bool AttributeProto_AttributeType_Parse(
149     const ::std::string& name, AttributeProto_AttributeType* value) {
150   return ::google::protobuf::internal::ParseNamedEnum<AttributeProto_AttributeType>(
151     AttributeProto_AttributeType_descriptor(), name, value);
152 }
153 enum TensorProto_DataType {
154   TensorProto_DataType_UNDEFINED = 0,
155   TensorProto_DataType_FLOAT = 1,
156   TensorProto_DataType_UINT8 = 2,
157   TensorProto_DataType_INT8 = 3,
158   TensorProto_DataType_UINT16 = 4,
159   TensorProto_DataType_INT16 = 5,
160   TensorProto_DataType_INT32 = 6,
161   TensorProto_DataType_INT64 = 7,
162   TensorProto_DataType_STRING = 8,
163   TensorProto_DataType_BOOL = 9,
164   TensorProto_DataType_FLOAT16 = 10,
165   TensorProto_DataType_DOUBLE = 11,
166   TensorProto_DataType_UINT32 = 12,
167   TensorProto_DataType_UINT64 = 13,
168   TensorProto_DataType_COMPLEX64 = 14,
169   TensorProto_DataType_COMPLEX128 = 15
170 };
171 bool TensorProto_DataType_IsValid(int value);
172 const TensorProto_DataType TensorProto_DataType_DataType_MIN = TensorProto_DataType_UNDEFINED;
173 const TensorProto_DataType TensorProto_DataType_DataType_MAX = TensorProto_DataType_COMPLEX128;
174 const int TensorProto_DataType_DataType_ARRAYSIZE = TensorProto_DataType_DataType_MAX + 1;
175 
176 const ::google::protobuf::EnumDescriptor* TensorProto_DataType_descriptor();
TensorProto_DataType_Name(TensorProto_DataType value)177 inline const ::std::string& TensorProto_DataType_Name(TensorProto_DataType value) {
178   return ::google::protobuf::internal::NameOfEnum(
179     TensorProto_DataType_descriptor(), value);
180 }
TensorProto_DataType_Parse(const::std::string & name,TensorProto_DataType * value)181 inline bool TensorProto_DataType_Parse(
182     const ::std::string& name, TensorProto_DataType* value) {
183   return ::google::protobuf::internal::ParseNamedEnum<TensorProto_DataType>(
184     TensorProto_DataType_descriptor(), name, value);
185 }
186 enum Version {
187   _START_VERSION = 0,
188   IR_VERSION_2017_10_10 = 1,
189   IR_VERSION_2017_10_30 = 2,
190   IR_VERSION = 3
191 };
192 bool Version_IsValid(int value);
193 const Version Version_MIN = _START_VERSION;
194 const Version Version_MAX = IR_VERSION;
195 const int Version_ARRAYSIZE = Version_MAX + 1;
196 
197 const ::google::protobuf::EnumDescriptor* Version_descriptor();
Version_Name(Version value)198 inline const ::std::string& Version_Name(Version value) {
199   return ::google::protobuf::internal::NameOfEnum(
200     Version_descriptor(), value);
201 }
Version_Parse(const::std::string & name,Version * value)202 inline bool Version_Parse(
203     const ::std::string& name, Version* value) {
204   return ::google::protobuf::internal::ParseNamedEnum<Version>(
205     Version_descriptor(), name, value);
206 }
207 // ===================================================================
208 
209 class AttributeProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.AttributeProto) */ {
210  public:
211   AttributeProto();
212   virtual ~AttributeProto();
213 
214   AttributeProto(const AttributeProto& from);
215 
216   inline AttributeProto& operator=(const AttributeProto& from) {
217     CopyFrom(from);
218     return *this;
219   }
220   #if LANG_CXX11
AttributeProto(AttributeProto && from)221   AttributeProto(AttributeProto&& from) noexcept
222     : AttributeProto() {
223     *this = ::std::move(from);
224   }
225 
226   inline AttributeProto& operator=(AttributeProto&& from) noexcept {
227     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
228       if (this != &from) InternalSwap(&from);
229     } else {
230       CopyFrom(from);
231     }
232     return *this;
233   }
234   #endif
unknown_fields()235   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
236     return _internal_metadata_.unknown_fields();
237   }
mutable_unknown_fields()238   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
239     return _internal_metadata_.mutable_unknown_fields();
240   }
241 
242   static const ::google::protobuf::Descriptor* descriptor();
243   static const AttributeProto& default_instance();
244 
245   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
internal_default_instance()246   static inline const AttributeProto* internal_default_instance() {
247     return reinterpret_cast<const AttributeProto*>(
248                &_AttributeProto_default_instance_);
249   }
250   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
251     0;
252 
253   void Swap(AttributeProto* other);
swap(AttributeProto & a,AttributeProto & b)254   friend void swap(AttributeProto& a, AttributeProto& b) {
255     a.Swap(&b);
256   }
257 
258   // implements Message ----------------------------------------------
259 
New()260   inline AttributeProto* New() const PROTOBUF_FINAL { return New(NULL); }
261 
262   AttributeProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
263   void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
264   void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
265   void CopyFrom(const AttributeProto& from);
266   void MergeFrom(const AttributeProto& from);
267   void Clear() PROTOBUF_FINAL;
268   bool IsInitialized() const PROTOBUF_FINAL;
269 
270   size_t ByteSizeLong() const PROTOBUF_FINAL;
271   bool MergePartialFromCodedStream(
272       ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
273   void SerializeWithCachedSizes(
274       ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
275   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
276       bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
GetCachedSize()277   int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
278   private:
279   void SharedCtor();
280   void SharedDtor();
281   void SetCachedSize(int size) const PROTOBUF_FINAL;
282   void InternalSwap(AttributeProto* other);
283   private:
GetArenaNoVirtual()284   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
285     return NULL;
286   }
MaybeArenaPtr()287   inline void* MaybeArenaPtr() const {
288     return NULL;
289   }
290   public:
291 
292   ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
293 
294   // nested types ----------------------------------------------------
295 
296   typedef AttributeProto_AttributeType AttributeType;
297   static const AttributeType UNDEFINED =
298     AttributeProto_AttributeType_UNDEFINED;
299   static const AttributeType FLOAT =
300     AttributeProto_AttributeType_FLOAT;
301   static const AttributeType INT =
302     AttributeProto_AttributeType_INT;
303   static const AttributeType STRING =
304     AttributeProto_AttributeType_STRING;
305   static const AttributeType TENSOR =
306     AttributeProto_AttributeType_TENSOR;
307   static const AttributeType GRAPH =
308     AttributeProto_AttributeType_GRAPH;
309   static const AttributeType FLOATS =
310     AttributeProto_AttributeType_FLOATS;
311   static const AttributeType INTS =
312     AttributeProto_AttributeType_INTS;
313   static const AttributeType STRINGS =
314     AttributeProto_AttributeType_STRINGS;
315   static const AttributeType TENSORS =
316     AttributeProto_AttributeType_TENSORS;
317   static const AttributeType GRAPHS =
318     AttributeProto_AttributeType_GRAPHS;
AttributeType_IsValid(int value)319   static inline bool AttributeType_IsValid(int value) {
320     return AttributeProto_AttributeType_IsValid(value);
321   }
322   static const AttributeType AttributeType_MIN =
323     AttributeProto_AttributeType_AttributeType_MIN;
324   static const AttributeType AttributeType_MAX =
325     AttributeProto_AttributeType_AttributeType_MAX;
326   static const int AttributeType_ARRAYSIZE =
327     AttributeProto_AttributeType_AttributeType_ARRAYSIZE;
328   static inline const ::google::protobuf::EnumDescriptor*
AttributeType_descriptor()329   AttributeType_descriptor() {
330     return AttributeProto_AttributeType_descriptor();
331   }
AttributeType_Name(AttributeType value)332   static inline const ::std::string& AttributeType_Name(AttributeType value) {
333     return AttributeProto_AttributeType_Name(value);
334   }
AttributeType_Parse(const::std::string & name,AttributeType * value)335   static inline bool AttributeType_Parse(const ::std::string& name,
336       AttributeType* value) {
337     return AttributeProto_AttributeType_Parse(name, value);
338   }
339 
340   // accessors -------------------------------------------------------
341 
342   // repeated float floats = 7;
343   int floats_size() const;
344   void clear_floats();
345   static const int kFloatsFieldNumber = 7;
346   float floats(int index) const;
347   void set_floats(int index, float value);
348   void add_floats(float value);
349   const ::google::protobuf::RepeatedField< float >&
350       floats() const;
351   ::google::protobuf::RepeatedField< float >*
352       mutable_floats();
353 
354   // repeated int64 ints = 8;
355   int ints_size() const;
356   void clear_ints();
357   static const int kIntsFieldNumber = 8;
358   ::google::protobuf::int64 ints(int index) const;
359   void set_ints(int index, ::google::protobuf::int64 value);
360   void add_ints(::google::protobuf::int64 value);
361   const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
362       ints() const;
363   ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
364       mutable_ints();
365 
366   // repeated bytes strings = 9;
367   int strings_size() const;
368   void clear_strings();
369   static const int kStringsFieldNumber = 9;
370   const ::std::string& strings(int index) const;
371   ::std::string* mutable_strings(int index);
372   void set_strings(int index, const ::std::string& value);
373   #if LANG_CXX11
374   void set_strings(int index, ::std::string&& value);
375   #endif
376   void set_strings(int index, const char* value);
377   void set_strings(int index, const void* value, size_t size);
378   ::std::string* add_strings();
379   void add_strings(const ::std::string& value);
380   #if LANG_CXX11
381   void add_strings(::std::string&& value);
382   #endif
383   void add_strings(const char* value);
384   void add_strings(const void* value, size_t size);
385   const ::google::protobuf::RepeatedPtrField< ::std::string>& strings() const;
386   ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_strings();
387 
388   // repeated .opencv_onnx.TensorProto tensors = 10;
389   int tensors_size() const;
390   void clear_tensors();
391   static const int kTensorsFieldNumber = 10;
392   const ::opencv_onnx::TensorProto& tensors(int index) const;
393   ::opencv_onnx::TensorProto* mutable_tensors(int index);
394   ::opencv_onnx::TensorProto* add_tensors();
395   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >*
396       mutable_tensors();
397   const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >&
398       tensors() const;
399 
400   // repeated .opencv_onnx.GraphProto graphs = 11;
401   int graphs_size() const;
402   void clear_graphs();
403   static const int kGraphsFieldNumber = 11;
404   const ::opencv_onnx::GraphProto& graphs(int index) const;
405   ::opencv_onnx::GraphProto* mutable_graphs(int index);
406   ::opencv_onnx::GraphProto* add_graphs();
407   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::GraphProto >*
408       mutable_graphs();
409   const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::GraphProto >&
410       graphs() const;
411 
412   // optional string name = 1;
413   bool has_name() const;
414   void clear_name();
415   static const int kNameFieldNumber = 1;
416   const ::std::string& name() const;
417   void set_name(const ::std::string& value);
418   #if LANG_CXX11
419   void set_name(::std::string&& value);
420   #endif
421   void set_name(const char* value);
422   void set_name(const char* value, size_t size);
423   ::std::string* mutable_name();
424   ::std::string* release_name();
425   void set_allocated_name(::std::string* name);
426 
427   // optional bytes s = 4;
428   bool has_s() const;
429   void clear_s();
430   static const int kSFieldNumber = 4;
431   const ::std::string& s() const;
432   void set_s(const ::std::string& value);
433   #if LANG_CXX11
434   void set_s(::std::string&& value);
435   #endif
436   void set_s(const char* value);
437   void set_s(const void* value, size_t size);
438   ::std::string* mutable_s();
439   ::std::string* release_s();
440   void set_allocated_s(::std::string* s);
441 
442   // optional string doc_string = 13;
443   bool has_doc_string() const;
444   void clear_doc_string();
445   static const int kDocStringFieldNumber = 13;
446   const ::std::string& doc_string() const;
447   void set_doc_string(const ::std::string& value);
448   #if LANG_CXX11
449   void set_doc_string(::std::string&& value);
450   #endif
451   void set_doc_string(const char* value);
452   void set_doc_string(const char* value, size_t size);
453   ::std::string* mutable_doc_string();
454   ::std::string* release_doc_string();
455   void set_allocated_doc_string(::std::string* doc_string);
456 
457   // optional string ref_attr_name = 21;
458   bool has_ref_attr_name() const;
459   void clear_ref_attr_name();
460   static const int kRefAttrNameFieldNumber = 21;
461   const ::std::string& ref_attr_name() const;
462   void set_ref_attr_name(const ::std::string& value);
463   #if LANG_CXX11
464   void set_ref_attr_name(::std::string&& value);
465   #endif
466   void set_ref_attr_name(const char* value);
467   void set_ref_attr_name(const char* value, size_t size);
468   ::std::string* mutable_ref_attr_name();
469   ::std::string* release_ref_attr_name();
470   void set_allocated_ref_attr_name(::std::string* ref_attr_name);
471 
472   // optional .opencv_onnx.TensorProto t = 5;
473   bool has_t() const;
474   void clear_t();
475   static const int kTFieldNumber = 5;
476   const ::opencv_onnx::TensorProto& t() const;
477   ::opencv_onnx::TensorProto* release_t();
478   ::opencv_onnx::TensorProto* mutable_t();
479   void set_allocated_t(::opencv_onnx::TensorProto* t);
480 
481   // optional .opencv_onnx.GraphProto g = 6;
482   bool has_g() const;
483   void clear_g();
484   static const int kGFieldNumber = 6;
485   const ::opencv_onnx::GraphProto& g() const;
486   ::opencv_onnx::GraphProto* release_g();
487   ::opencv_onnx::GraphProto* mutable_g();
488   void set_allocated_g(::opencv_onnx::GraphProto* g);
489 
490   // optional int64 i = 3;
491   bool has_i() const;
492   void clear_i();
493   static const int kIFieldNumber = 3;
494   ::google::protobuf::int64 i() const;
495   void set_i(::google::protobuf::int64 value);
496 
497   // optional float f = 2;
498   bool has_f() const;
499   void clear_f();
500   static const int kFFieldNumber = 2;
501   float f() const;
502   void set_f(float value);
503 
504   // optional .opencv_onnx.AttributeProto.AttributeType type = 20;
505   bool has_type() const;
506   void clear_type();
507   static const int kTypeFieldNumber = 20;
508   ::opencv_onnx::AttributeProto_AttributeType type() const;
509   void set_type(::opencv_onnx::AttributeProto_AttributeType value);
510 
511   // @@protoc_insertion_point(class_scope:opencv_onnx.AttributeProto)
512  private:
513   void set_has_name();
514   void clear_has_name();
515   void set_has_ref_attr_name();
516   void clear_has_ref_attr_name();
517   void set_has_doc_string();
518   void clear_has_doc_string();
519   void set_has_type();
520   void clear_has_type();
521   void set_has_f();
522   void clear_has_f();
523   void set_has_i();
524   void clear_has_i();
525   void set_has_s();
526   void clear_has_s();
527   void set_has_t();
528   void clear_has_t();
529   void set_has_g();
530   void clear_has_g();
531 
532   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
533   ::google::protobuf::internal::HasBits<1> _has_bits_;
534   mutable int _cached_size_;
535   ::google::protobuf::RepeatedField< float > floats_;
536   ::google::protobuf::RepeatedField< ::google::protobuf::int64 > ints_;
537   ::google::protobuf::RepeatedPtrField< ::std::string> strings_;
538   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto > tensors_;
539   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::GraphProto > graphs_;
540   ::google::protobuf::internal::ArenaStringPtr name_;
541   ::google::protobuf::internal::ArenaStringPtr s_;
542   ::google::protobuf::internal::ArenaStringPtr doc_string_;
543   ::google::protobuf::internal::ArenaStringPtr ref_attr_name_;
544   ::opencv_onnx::TensorProto* t_;
545   ::opencv_onnx::GraphProto* g_;
546   ::google::protobuf::int64 i_;
547   float f_;
548   int type_;
549   friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
550   friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsAttributeProtoImpl();
551 };
552 // -------------------------------------------------------------------
553 
554 class ValueInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.ValueInfoProto) */ {
555  public:
556   ValueInfoProto();
557   virtual ~ValueInfoProto();
558 
559   ValueInfoProto(const ValueInfoProto& from);
560 
561   inline ValueInfoProto& operator=(const ValueInfoProto& from) {
562     CopyFrom(from);
563     return *this;
564   }
565   #if LANG_CXX11
ValueInfoProto(ValueInfoProto && from)566   ValueInfoProto(ValueInfoProto&& from) noexcept
567     : ValueInfoProto() {
568     *this = ::std::move(from);
569   }
570 
571   inline ValueInfoProto& operator=(ValueInfoProto&& from) noexcept {
572     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
573       if (this != &from) InternalSwap(&from);
574     } else {
575       CopyFrom(from);
576     }
577     return *this;
578   }
579   #endif
unknown_fields()580   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
581     return _internal_metadata_.unknown_fields();
582   }
mutable_unknown_fields()583   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
584     return _internal_metadata_.mutable_unknown_fields();
585   }
586 
587   static const ::google::protobuf::Descriptor* descriptor();
588   static const ValueInfoProto& default_instance();
589 
590   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
internal_default_instance()591   static inline const ValueInfoProto* internal_default_instance() {
592     return reinterpret_cast<const ValueInfoProto*>(
593                &_ValueInfoProto_default_instance_);
594   }
595   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
596     1;
597 
598   void Swap(ValueInfoProto* other);
swap(ValueInfoProto & a,ValueInfoProto & b)599   friend void swap(ValueInfoProto& a, ValueInfoProto& b) {
600     a.Swap(&b);
601   }
602 
603   // implements Message ----------------------------------------------
604 
New()605   inline ValueInfoProto* New() const PROTOBUF_FINAL { return New(NULL); }
606 
607   ValueInfoProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
608   void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
609   void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
610   void CopyFrom(const ValueInfoProto& from);
611   void MergeFrom(const ValueInfoProto& from);
612   void Clear() PROTOBUF_FINAL;
613   bool IsInitialized() const PROTOBUF_FINAL;
614 
615   size_t ByteSizeLong() const PROTOBUF_FINAL;
616   bool MergePartialFromCodedStream(
617       ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
618   void SerializeWithCachedSizes(
619       ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
620   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
621       bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
GetCachedSize()622   int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
623   private:
624   void SharedCtor();
625   void SharedDtor();
626   void SetCachedSize(int size) const PROTOBUF_FINAL;
627   void InternalSwap(ValueInfoProto* other);
628   private:
GetArenaNoVirtual()629   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
630     return NULL;
631   }
MaybeArenaPtr()632   inline void* MaybeArenaPtr() const {
633     return NULL;
634   }
635   public:
636 
637   ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
638 
639   // nested types ----------------------------------------------------
640 
641   // accessors -------------------------------------------------------
642 
643   // optional string name = 1;
644   bool has_name() const;
645   void clear_name();
646   static const int kNameFieldNumber = 1;
647   const ::std::string& name() const;
648   void set_name(const ::std::string& value);
649   #if LANG_CXX11
650   void set_name(::std::string&& value);
651   #endif
652   void set_name(const char* value);
653   void set_name(const char* value, size_t size);
654   ::std::string* mutable_name();
655   ::std::string* release_name();
656   void set_allocated_name(::std::string* name);
657 
658   // optional string doc_string = 3;
659   bool has_doc_string() const;
660   void clear_doc_string();
661   static const int kDocStringFieldNumber = 3;
662   const ::std::string& doc_string() const;
663   void set_doc_string(const ::std::string& value);
664   #if LANG_CXX11
665   void set_doc_string(::std::string&& value);
666   #endif
667   void set_doc_string(const char* value);
668   void set_doc_string(const char* value, size_t size);
669   ::std::string* mutable_doc_string();
670   ::std::string* release_doc_string();
671   void set_allocated_doc_string(::std::string* doc_string);
672 
673   // optional .opencv_onnx.TypeProto type = 2;
674   bool has_type() const;
675   void clear_type();
676   static const int kTypeFieldNumber = 2;
677   const ::opencv_onnx::TypeProto& type() const;
678   ::opencv_onnx::TypeProto* release_type();
679   ::opencv_onnx::TypeProto* mutable_type();
680   void set_allocated_type(::opencv_onnx::TypeProto* type);
681 
682   // @@protoc_insertion_point(class_scope:opencv_onnx.ValueInfoProto)
683  private:
684   void set_has_name();
685   void clear_has_name();
686   void set_has_type();
687   void clear_has_type();
688   void set_has_doc_string();
689   void clear_has_doc_string();
690 
691   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
692   ::google::protobuf::internal::HasBits<1> _has_bits_;
693   mutable int _cached_size_;
694   ::google::protobuf::internal::ArenaStringPtr name_;
695   ::google::protobuf::internal::ArenaStringPtr doc_string_;
696   ::opencv_onnx::TypeProto* type_;
697   friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
698   friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsValueInfoProtoImpl();
699 };
700 // -------------------------------------------------------------------
701 
702 class NodeProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.NodeProto) */ {
703  public:
704   NodeProto();
705   virtual ~NodeProto();
706 
707   NodeProto(const NodeProto& from);
708 
709   inline NodeProto& operator=(const NodeProto& from) {
710     CopyFrom(from);
711     return *this;
712   }
713   #if LANG_CXX11
NodeProto(NodeProto && from)714   NodeProto(NodeProto&& from) noexcept
715     : NodeProto() {
716     *this = ::std::move(from);
717   }
718 
719   inline NodeProto& operator=(NodeProto&& from) noexcept {
720     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
721       if (this != &from) InternalSwap(&from);
722     } else {
723       CopyFrom(from);
724     }
725     return *this;
726   }
727   #endif
unknown_fields()728   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
729     return _internal_metadata_.unknown_fields();
730   }
mutable_unknown_fields()731   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
732     return _internal_metadata_.mutable_unknown_fields();
733   }
734 
735   static const ::google::protobuf::Descriptor* descriptor();
736   static const NodeProto& default_instance();
737 
738   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
internal_default_instance()739   static inline const NodeProto* internal_default_instance() {
740     return reinterpret_cast<const NodeProto*>(
741                &_NodeProto_default_instance_);
742   }
743   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
744     2;
745 
746   void Swap(NodeProto* other);
swap(NodeProto & a,NodeProto & b)747   friend void swap(NodeProto& a, NodeProto& b) {
748     a.Swap(&b);
749   }
750 
751   // implements Message ----------------------------------------------
752 
New()753   inline NodeProto* New() const PROTOBUF_FINAL { return New(NULL); }
754 
755   NodeProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
756   void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
757   void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
758   void CopyFrom(const NodeProto& from);
759   void MergeFrom(const NodeProto& from);
760   void Clear() PROTOBUF_FINAL;
761   bool IsInitialized() const PROTOBUF_FINAL;
762 
763   size_t ByteSizeLong() const PROTOBUF_FINAL;
764   bool MergePartialFromCodedStream(
765       ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
766   void SerializeWithCachedSizes(
767       ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
768   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
769       bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
GetCachedSize()770   int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
771   private:
772   void SharedCtor();
773   void SharedDtor();
774   void SetCachedSize(int size) const PROTOBUF_FINAL;
775   void InternalSwap(NodeProto* other);
776   private:
GetArenaNoVirtual()777   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
778     return NULL;
779   }
MaybeArenaPtr()780   inline void* MaybeArenaPtr() const {
781     return NULL;
782   }
783   public:
784 
785   ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
786 
787   // nested types ----------------------------------------------------
788 
789   // accessors -------------------------------------------------------
790 
791   // repeated string input = 1;
792   int input_size() const;
793   void clear_input();
794   static const int kInputFieldNumber = 1;
795   const ::std::string& input(int index) const;
796   ::std::string* mutable_input(int index);
797   void set_input(int index, const ::std::string& value);
798   #if LANG_CXX11
799   void set_input(int index, ::std::string&& value);
800   #endif
801   void set_input(int index, const char* value);
802   void set_input(int index, const char* value, size_t size);
803   ::std::string* add_input();
804   void add_input(const ::std::string& value);
805   #if LANG_CXX11
806   void add_input(::std::string&& value);
807   #endif
808   void add_input(const char* value);
809   void add_input(const char* value, size_t size);
810   const ::google::protobuf::RepeatedPtrField< ::std::string>& input() const;
811   ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_input();
812 
813   // repeated string output = 2;
814   int output_size() const;
815   void clear_output();
816   static const int kOutputFieldNumber = 2;
817   const ::std::string& output(int index) const;
818   ::std::string* mutable_output(int index);
819   void set_output(int index, const ::std::string& value);
820   #if LANG_CXX11
821   void set_output(int index, ::std::string&& value);
822   #endif
823   void set_output(int index, const char* value);
824   void set_output(int index, const char* value, size_t size);
825   ::std::string* add_output();
826   void add_output(const ::std::string& value);
827   #if LANG_CXX11
828   void add_output(::std::string&& value);
829   #endif
830   void add_output(const char* value);
831   void add_output(const char* value, size_t size);
832   const ::google::protobuf::RepeatedPtrField< ::std::string>& output() const;
833   ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_output();
834 
835   // repeated .opencv_onnx.AttributeProto attribute = 5;
836   int attribute_size() const;
837   void clear_attribute();
838   static const int kAttributeFieldNumber = 5;
839   const ::opencv_onnx::AttributeProto& attribute(int index) const;
840   ::opencv_onnx::AttributeProto* mutable_attribute(int index);
841   ::opencv_onnx::AttributeProto* add_attribute();
842   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::AttributeProto >*
843       mutable_attribute();
844   const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::AttributeProto >&
845       attribute() const;
846 
847   // optional string name = 3;
848   bool has_name() const;
849   void clear_name();
850   static const int kNameFieldNumber = 3;
851   const ::std::string& name() const;
852   void set_name(const ::std::string& value);
853   #if LANG_CXX11
854   void set_name(::std::string&& value);
855   #endif
856   void set_name(const char* value);
857   void set_name(const char* value, size_t size);
858   ::std::string* mutable_name();
859   ::std::string* release_name();
860   void set_allocated_name(::std::string* name);
861 
862   // optional string op_type = 4;
863   bool has_op_type() const;
864   void clear_op_type();
865   static const int kOpTypeFieldNumber = 4;
866   const ::std::string& op_type() const;
867   void set_op_type(const ::std::string& value);
868   #if LANG_CXX11
869   void set_op_type(::std::string&& value);
870   #endif
871   void set_op_type(const char* value);
872   void set_op_type(const char* value, size_t size);
873   ::std::string* mutable_op_type();
874   ::std::string* release_op_type();
875   void set_allocated_op_type(::std::string* op_type);
876 
877   // optional string doc_string = 6;
878   bool has_doc_string() const;
879   void clear_doc_string();
880   static const int kDocStringFieldNumber = 6;
881   const ::std::string& doc_string() const;
882   void set_doc_string(const ::std::string& value);
883   #if LANG_CXX11
884   void set_doc_string(::std::string&& value);
885   #endif
886   void set_doc_string(const char* value);
887   void set_doc_string(const char* value, size_t size);
888   ::std::string* mutable_doc_string();
889   ::std::string* release_doc_string();
890   void set_allocated_doc_string(::std::string* doc_string);
891 
892   // optional string domain = 7;
893   bool has_domain() const;
894   void clear_domain();
895   static const int kDomainFieldNumber = 7;
896   const ::std::string& domain() const;
897   void set_domain(const ::std::string& value);
898   #if LANG_CXX11
899   void set_domain(::std::string&& value);
900   #endif
901   void set_domain(const char* value);
902   void set_domain(const char* value, size_t size);
903   ::std::string* mutable_domain();
904   ::std::string* release_domain();
905   void set_allocated_domain(::std::string* domain);
906 
907   // @@protoc_insertion_point(class_scope:opencv_onnx.NodeProto)
908  private:
909   void set_has_name();
910   void clear_has_name();
911   void set_has_op_type();
912   void clear_has_op_type();
913   void set_has_domain();
914   void clear_has_domain();
915   void set_has_doc_string();
916   void clear_has_doc_string();
917 
918   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
919   ::google::protobuf::internal::HasBits<1> _has_bits_;
920   mutable int _cached_size_;
921   ::google::protobuf::RepeatedPtrField< ::std::string> input_;
922   ::google::protobuf::RepeatedPtrField< ::std::string> output_;
923   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::AttributeProto > attribute_;
924   ::google::protobuf::internal::ArenaStringPtr name_;
925   ::google::protobuf::internal::ArenaStringPtr op_type_;
926   ::google::protobuf::internal::ArenaStringPtr doc_string_;
927   ::google::protobuf::internal::ArenaStringPtr domain_;
928   friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
929   friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsAttributeProtoImpl();
930 };
931 // -------------------------------------------------------------------
932 
933 class ModelProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.ModelProto) */ {
934  public:
935   ModelProto();
936   virtual ~ModelProto();
937 
938   ModelProto(const ModelProto& from);
939 
940   inline ModelProto& operator=(const ModelProto& from) {
941     CopyFrom(from);
942     return *this;
943   }
944   #if LANG_CXX11
ModelProto(ModelProto && from)945   ModelProto(ModelProto&& from) noexcept
946     : ModelProto() {
947     *this = ::std::move(from);
948   }
949 
950   inline ModelProto& operator=(ModelProto&& from) noexcept {
951     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
952       if (this != &from) InternalSwap(&from);
953     } else {
954       CopyFrom(from);
955     }
956     return *this;
957   }
958   #endif
unknown_fields()959   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
960     return _internal_metadata_.unknown_fields();
961   }
mutable_unknown_fields()962   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
963     return _internal_metadata_.mutable_unknown_fields();
964   }
965 
966   static const ::google::protobuf::Descriptor* descriptor();
967   static const ModelProto& default_instance();
968 
969   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
internal_default_instance()970   static inline const ModelProto* internal_default_instance() {
971     return reinterpret_cast<const ModelProto*>(
972                &_ModelProto_default_instance_);
973   }
974   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
975     3;
976 
977   void Swap(ModelProto* other);
swap(ModelProto & a,ModelProto & b)978   friend void swap(ModelProto& a, ModelProto& b) {
979     a.Swap(&b);
980   }
981 
982   // implements Message ----------------------------------------------
983 
New()984   inline ModelProto* New() const PROTOBUF_FINAL { return New(NULL); }
985 
986   ModelProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
987   void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
988   void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
989   void CopyFrom(const ModelProto& from);
990   void MergeFrom(const ModelProto& from);
991   void Clear() PROTOBUF_FINAL;
992   bool IsInitialized() const PROTOBUF_FINAL;
993 
994   size_t ByteSizeLong() const PROTOBUF_FINAL;
995   bool MergePartialFromCodedStream(
996       ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
997   void SerializeWithCachedSizes(
998       ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
999   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1000       bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
GetCachedSize()1001   int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
1002   private:
1003   void SharedCtor();
1004   void SharedDtor();
1005   void SetCachedSize(int size) const PROTOBUF_FINAL;
1006   void InternalSwap(ModelProto* other);
1007   private:
GetArenaNoVirtual()1008   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1009     return NULL;
1010   }
MaybeArenaPtr()1011   inline void* MaybeArenaPtr() const {
1012     return NULL;
1013   }
1014   public:
1015 
1016   ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
1017 
1018   // nested types ----------------------------------------------------
1019 
1020   // accessors -------------------------------------------------------
1021 
1022   // repeated .opencv_onnx.OperatorSetIdProto opset_import = 8;
1023   int opset_import_size() const;
1024   void clear_opset_import();
1025   static const int kOpsetImportFieldNumber = 8;
1026   const ::opencv_onnx::OperatorSetIdProto& opset_import(int index) const;
1027   ::opencv_onnx::OperatorSetIdProto* mutable_opset_import(int index);
1028   ::opencv_onnx::OperatorSetIdProto* add_opset_import();
1029   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >*
1030       mutable_opset_import();
1031   const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >&
1032       opset_import() const;
1033 
1034   // repeated .opencv_onnx.StringStringEntryProto metadata_props = 14;
1035   int metadata_props_size() const;
1036   void clear_metadata_props();
1037   static const int kMetadataPropsFieldNumber = 14;
1038   const ::opencv_onnx::StringStringEntryProto& metadata_props(int index) const;
1039   ::opencv_onnx::StringStringEntryProto* mutable_metadata_props(int index);
1040   ::opencv_onnx::StringStringEntryProto* add_metadata_props();
1041   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
1042       mutable_metadata_props();
1043   const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
1044       metadata_props() const;
1045 
1046   // optional string producer_name = 2;
1047   bool has_producer_name() const;
1048   void clear_producer_name();
1049   static const int kProducerNameFieldNumber = 2;
1050   const ::std::string& producer_name() const;
1051   void set_producer_name(const ::std::string& value);
1052   #if LANG_CXX11
1053   void set_producer_name(::std::string&& value);
1054   #endif
1055   void set_producer_name(const char* value);
1056   void set_producer_name(const char* value, size_t size);
1057   ::std::string* mutable_producer_name();
1058   ::std::string* release_producer_name();
1059   void set_allocated_producer_name(::std::string* producer_name);
1060 
1061   // optional string producer_version = 3;
1062   bool has_producer_version() const;
1063   void clear_producer_version();
1064   static const int kProducerVersionFieldNumber = 3;
1065   const ::std::string& producer_version() const;
1066   void set_producer_version(const ::std::string& value);
1067   #if LANG_CXX11
1068   void set_producer_version(::std::string&& value);
1069   #endif
1070   void set_producer_version(const char* value);
1071   void set_producer_version(const char* value, size_t size);
1072   ::std::string* mutable_producer_version();
1073   ::std::string* release_producer_version();
1074   void set_allocated_producer_version(::std::string* producer_version);
1075 
1076   // optional string domain = 4;
1077   bool has_domain() const;
1078   void clear_domain();
1079   static const int kDomainFieldNumber = 4;
1080   const ::std::string& domain() const;
1081   void set_domain(const ::std::string& value);
1082   #if LANG_CXX11
1083   void set_domain(::std::string&& value);
1084   #endif
1085   void set_domain(const char* value);
1086   void set_domain(const char* value, size_t size);
1087   ::std::string* mutable_domain();
1088   ::std::string* release_domain();
1089   void set_allocated_domain(::std::string* domain);
1090 
1091   // optional string doc_string = 6;
1092   bool has_doc_string() const;
1093   void clear_doc_string();
1094   static const int kDocStringFieldNumber = 6;
1095   const ::std::string& doc_string() const;
1096   void set_doc_string(const ::std::string& value);
1097   #if LANG_CXX11
1098   void set_doc_string(::std::string&& value);
1099   #endif
1100   void set_doc_string(const char* value);
1101   void set_doc_string(const char* value, size_t size);
1102   ::std::string* mutable_doc_string();
1103   ::std::string* release_doc_string();
1104   void set_allocated_doc_string(::std::string* doc_string);
1105 
1106   // optional .opencv_onnx.GraphProto graph = 7;
1107   bool has_graph() const;
1108   void clear_graph();
1109   static const int kGraphFieldNumber = 7;
1110   const ::opencv_onnx::GraphProto& graph() const;
1111   ::opencv_onnx::GraphProto* release_graph();
1112   ::opencv_onnx::GraphProto* mutable_graph();
1113   void set_allocated_graph(::opencv_onnx::GraphProto* graph);
1114 
1115   // optional int64 ir_version = 1;
1116   bool has_ir_version() const;
1117   void clear_ir_version();
1118   static const int kIrVersionFieldNumber = 1;
1119   ::google::protobuf::int64 ir_version() const;
1120   void set_ir_version(::google::protobuf::int64 value);
1121 
1122   // optional int64 model_version = 5;
1123   bool has_model_version() const;
1124   void clear_model_version();
1125   static const int kModelVersionFieldNumber = 5;
1126   ::google::protobuf::int64 model_version() const;
1127   void set_model_version(::google::protobuf::int64 value);
1128 
1129   // @@protoc_insertion_point(class_scope:opencv_onnx.ModelProto)
1130  private:
1131   void set_has_ir_version();
1132   void clear_has_ir_version();
1133   void set_has_producer_name();
1134   void clear_has_producer_name();
1135   void set_has_producer_version();
1136   void clear_has_producer_version();
1137   void set_has_domain();
1138   void clear_has_domain();
1139   void set_has_model_version();
1140   void clear_has_model_version();
1141   void set_has_doc_string();
1142   void clear_has_doc_string();
1143   void set_has_graph();
1144   void clear_has_graph();
1145 
1146   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1147   ::google::protobuf::internal::HasBits<1> _has_bits_;
1148   mutable int _cached_size_;
1149   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto > opset_import_;
1150   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto > metadata_props_;
1151   ::google::protobuf::internal::ArenaStringPtr producer_name_;
1152   ::google::protobuf::internal::ArenaStringPtr producer_version_;
1153   ::google::protobuf::internal::ArenaStringPtr domain_;
1154   ::google::protobuf::internal::ArenaStringPtr doc_string_;
1155   ::opencv_onnx::GraphProto* graph_;
1156   ::google::protobuf::int64 ir_version_;
1157   ::google::protobuf::int64 model_version_;
1158   friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
1159   friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsModelProtoImpl();
1160 };
1161 // -------------------------------------------------------------------
1162 
1163 class StringStringEntryProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.StringStringEntryProto) */ {
1164  public:
1165   StringStringEntryProto();
1166   virtual ~StringStringEntryProto();
1167 
1168   StringStringEntryProto(const StringStringEntryProto& from);
1169 
1170   inline StringStringEntryProto& operator=(const StringStringEntryProto& from) {
1171     CopyFrom(from);
1172     return *this;
1173   }
1174   #if LANG_CXX11
StringStringEntryProto(StringStringEntryProto && from)1175   StringStringEntryProto(StringStringEntryProto&& from) noexcept
1176     : StringStringEntryProto() {
1177     *this = ::std::move(from);
1178   }
1179 
1180   inline StringStringEntryProto& operator=(StringStringEntryProto&& from) noexcept {
1181     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1182       if (this != &from) InternalSwap(&from);
1183     } else {
1184       CopyFrom(from);
1185     }
1186     return *this;
1187   }
1188   #endif
unknown_fields()1189   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1190     return _internal_metadata_.unknown_fields();
1191   }
mutable_unknown_fields()1192   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1193     return _internal_metadata_.mutable_unknown_fields();
1194   }
1195 
1196   static const ::google::protobuf::Descriptor* descriptor();
1197   static const StringStringEntryProto& default_instance();
1198 
1199   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
internal_default_instance()1200   static inline const StringStringEntryProto* internal_default_instance() {
1201     return reinterpret_cast<const StringStringEntryProto*>(
1202                &_StringStringEntryProto_default_instance_);
1203   }
1204   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
1205     4;
1206 
1207   void Swap(StringStringEntryProto* other);
swap(StringStringEntryProto & a,StringStringEntryProto & b)1208   friend void swap(StringStringEntryProto& a, StringStringEntryProto& b) {
1209     a.Swap(&b);
1210   }
1211 
1212   // implements Message ----------------------------------------------
1213 
New()1214   inline StringStringEntryProto* New() const PROTOBUF_FINAL { return New(NULL); }
1215 
1216   StringStringEntryProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
1217   void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
1218   void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
1219   void CopyFrom(const StringStringEntryProto& from);
1220   void MergeFrom(const StringStringEntryProto& from);
1221   void Clear() PROTOBUF_FINAL;
1222   bool IsInitialized() const PROTOBUF_FINAL;
1223 
1224   size_t ByteSizeLong() const PROTOBUF_FINAL;
1225   bool MergePartialFromCodedStream(
1226       ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
1227   void SerializeWithCachedSizes(
1228       ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
1229   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1230       bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
GetCachedSize()1231   int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
1232   private:
1233   void SharedCtor();
1234   void SharedDtor();
1235   void SetCachedSize(int size) const PROTOBUF_FINAL;
1236   void InternalSwap(StringStringEntryProto* other);
1237   private:
GetArenaNoVirtual()1238   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1239     return NULL;
1240   }
MaybeArenaPtr()1241   inline void* MaybeArenaPtr() const {
1242     return NULL;
1243   }
1244   public:
1245 
1246   ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
1247 
1248   // nested types ----------------------------------------------------
1249 
1250   // accessors -------------------------------------------------------
1251 
1252   // optional string key = 1;
1253   bool has_key() const;
1254   void clear_key();
1255   static const int kKeyFieldNumber = 1;
1256   const ::std::string& key() const;
1257   void set_key(const ::std::string& value);
1258   #if LANG_CXX11
1259   void set_key(::std::string&& value);
1260   #endif
1261   void set_key(const char* value);
1262   void set_key(const char* value, size_t size);
1263   ::std::string* mutable_key();
1264   ::std::string* release_key();
1265   void set_allocated_key(::std::string* key);
1266 
1267   // optional string value = 2;
1268   bool has_value() const;
1269   void clear_value();
1270   static const int kValueFieldNumber = 2;
1271   const ::std::string& value() const;
1272   void set_value(const ::std::string& value);
1273   #if LANG_CXX11
1274   void set_value(::std::string&& value);
1275   #endif
1276   void set_value(const char* value);
1277   void set_value(const char* value, size_t size);
1278   ::std::string* mutable_value();
1279   ::std::string* release_value();
1280   void set_allocated_value(::std::string* value);
1281 
1282   // @@protoc_insertion_point(class_scope:opencv_onnx.StringStringEntryProto)
1283  private:
1284   void set_has_key();
1285   void clear_has_key();
1286   void set_has_value();
1287   void clear_has_value();
1288 
1289   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1290   ::google::protobuf::internal::HasBits<1> _has_bits_;
1291   mutable int _cached_size_;
1292   ::google::protobuf::internal::ArenaStringPtr key_;
1293   ::google::protobuf::internal::ArenaStringPtr value_;
1294   friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
1295   friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsStringStringEntryProtoImpl();
1296 };
1297 // -------------------------------------------------------------------
1298 
1299 class GraphProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.GraphProto) */ {
1300  public:
1301   GraphProto();
1302   virtual ~GraphProto();
1303 
1304   GraphProto(const GraphProto& from);
1305 
1306   inline GraphProto& operator=(const GraphProto& from) {
1307     CopyFrom(from);
1308     return *this;
1309   }
1310   #if LANG_CXX11
GraphProto(GraphProto && from)1311   GraphProto(GraphProto&& from) noexcept
1312     : GraphProto() {
1313     *this = ::std::move(from);
1314   }
1315 
1316   inline GraphProto& operator=(GraphProto&& from) noexcept {
1317     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1318       if (this != &from) InternalSwap(&from);
1319     } else {
1320       CopyFrom(from);
1321     }
1322     return *this;
1323   }
1324   #endif
unknown_fields()1325   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1326     return _internal_metadata_.unknown_fields();
1327   }
mutable_unknown_fields()1328   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1329     return _internal_metadata_.mutable_unknown_fields();
1330   }
1331 
1332   static const ::google::protobuf::Descriptor* descriptor();
1333   static const GraphProto& default_instance();
1334 
1335   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
internal_default_instance()1336   static inline const GraphProto* internal_default_instance() {
1337     return reinterpret_cast<const GraphProto*>(
1338                &_GraphProto_default_instance_);
1339   }
1340   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
1341     5;
1342 
1343   void Swap(GraphProto* other);
swap(GraphProto & a,GraphProto & b)1344   friend void swap(GraphProto& a, GraphProto& b) {
1345     a.Swap(&b);
1346   }
1347 
1348   // implements Message ----------------------------------------------
1349 
New()1350   inline GraphProto* New() const PROTOBUF_FINAL { return New(NULL); }
1351 
1352   GraphProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
1353   void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
1354   void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
1355   void CopyFrom(const GraphProto& from);
1356   void MergeFrom(const GraphProto& from);
1357   void Clear() PROTOBUF_FINAL;
1358   bool IsInitialized() const PROTOBUF_FINAL;
1359 
1360   size_t ByteSizeLong() const PROTOBUF_FINAL;
1361   bool MergePartialFromCodedStream(
1362       ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
1363   void SerializeWithCachedSizes(
1364       ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
1365   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1366       bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
GetCachedSize()1367   int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
1368   private:
1369   void SharedCtor();
1370   void SharedDtor();
1371   void SetCachedSize(int size) const PROTOBUF_FINAL;
1372   void InternalSwap(GraphProto* other);
1373   private:
GetArenaNoVirtual()1374   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1375     return NULL;
1376   }
MaybeArenaPtr()1377   inline void* MaybeArenaPtr() const {
1378     return NULL;
1379   }
1380   public:
1381 
1382   ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
1383 
1384   // nested types ----------------------------------------------------
1385 
1386   // accessors -------------------------------------------------------
1387 
1388   // repeated .opencv_onnx.NodeProto node = 1;
1389   int node_size() const;
1390   void clear_node();
1391   static const int kNodeFieldNumber = 1;
1392   const ::opencv_onnx::NodeProto& node(int index) const;
1393   ::opencv_onnx::NodeProto* mutable_node(int index);
1394   ::opencv_onnx::NodeProto* add_node();
1395   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::NodeProto >*
1396       mutable_node();
1397   const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::NodeProto >&
1398       node() const;
1399 
1400   // repeated .opencv_onnx.TensorProto initializer = 5;
1401   int initializer_size() const;
1402   void clear_initializer();
1403   static const int kInitializerFieldNumber = 5;
1404   const ::opencv_onnx::TensorProto& initializer(int index) const;
1405   ::opencv_onnx::TensorProto* mutable_initializer(int index);
1406   ::opencv_onnx::TensorProto* add_initializer();
1407   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >*
1408       mutable_initializer();
1409   const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >&
1410       initializer() const;
1411 
1412   // repeated .opencv_onnx.ValueInfoProto input = 11;
1413   int input_size() const;
1414   void clear_input();
1415   static const int kInputFieldNumber = 11;
1416   const ::opencv_onnx::ValueInfoProto& input(int index) const;
1417   ::opencv_onnx::ValueInfoProto* mutable_input(int index);
1418   ::opencv_onnx::ValueInfoProto* add_input();
1419   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
1420       mutable_input();
1421   const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
1422       input() const;
1423 
1424   // repeated .opencv_onnx.ValueInfoProto output = 12;
1425   int output_size() const;
1426   void clear_output();
1427   static const int kOutputFieldNumber = 12;
1428   const ::opencv_onnx::ValueInfoProto& output(int index) const;
1429   ::opencv_onnx::ValueInfoProto* mutable_output(int index);
1430   ::opencv_onnx::ValueInfoProto* add_output();
1431   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
1432       mutable_output();
1433   const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
1434       output() const;
1435 
1436   // repeated .opencv_onnx.ValueInfoProto value_info = 13;
1437   int value_info_size() const;
1438   void clear_value_info();
1439   static const int kValueInfoFieldNumber = 13;
1440   const ::opencv_onnx::ValueInfoProto& value_info(int index) const;
1441   ::opencv_onnx::ValueInfoProto* mutable_value_info(int index);
1442   ::opencv_onnx::ValueInfoProto* add_value_info();
1443   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
1444       mutable_value_info();
1445   const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
1446       value_info() const;
1447 
1448   // optional string name = 2;
1449   bool has_name() const;
1450   void clear_name();
1451   static const int kNameFieldNumber = 2;
1452   const ::std::string& name() const;
1453   void set_name(const ::std::string& value);
1454   #if LANG_CXX11
1455   void set_name(::std::string&& value);
1456   #endif
1457   void set_name(const char* value);
1458   void set_name(const char* value, size_t size);
1459   ::std::string* mutable_name();
1460   ::std::string* release_name();
1461   void set_allocated_name(::std::string* name);
1462 
1463   // optional string doc_string = 10;
1464   bool has_doc_string() const;
1465   void clear_doc_string();
1466   static const int kDocStringFieldNumber = 10;
1467   const ::std::string& doc_string() const;
1468   void set_doc_string(const ::std::string& value);
1469   #if LANG_CXX11
1470   void set_doc_string(::std::string&& value);
1471   #endif
1472   void set_doc_string(const char* value);
1473   void set_doc_string(const char* value, size_t size);
1474   ::std::string* mutable_doc_string();
1475   ::std::string* release_doc_string();
1476   void set_allocated_doc_string(::std::string* doc_string);
1477 
1478   // @@protoc_insertion_point(class_scope:opencv_onnx.GraphProto)
1479  private:
1480   void set_has_name();
1481   void clear_has_name();
1482   void set_has_doc_string();
1483   void clear_has_doc_string();
1484 
1485   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1486   ::google::protobuf::internal::HasBits<1> _has_bits_;
1487   mutable int _cached_size_;
1488   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::NodeProto > node_;
1489   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto > initializer_;
1490   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto > input_;
1491   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto > output_;
1492   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto > value_info_;
1493   ::google::protobuf::internal::ArenaStringPtr name_;
1494   ::google::protobuf::internal::ArenaStringPtr doc_string_;
1495   friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
1496   friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsAttributeProtoImpl();
1497 };
1498 // -------------------------------------------------------------------
1499 
1500 class TensorProto_Segment : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorProto.Segment) */ {
1501  public:
1502   TensorProto_Segment();
1503   virtual ~TensorProto_Segment();
1504 
1505   TensorProto_Segment(const TensorProto_Segment& from);
1506 
1507   inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
1508     CopyFrom(from);
1509     return *this;
1510   }
1511   #if LANG_CXX11
TensorProto_Segment(TensorProto_Segment && from)1512   TensorProto_Segment(TensorProto_Segment&& from) noexcept
1513     : TensorProto_Segment() {
1514     *this = ::std::move(from);
1515   }
1516 
1517   inline TensorProto_Segment& operator=(TensorProto_Segment&& from) noexcept {
1518     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1519       if (this != &from) InternalSwap(&from);
1520     } else {
1521       CopyFrom(from);
1522     }
1523     return *this;
1524   }
1525   #endif
unknown_fields()1526   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1527     return _internal_metadata_.unknown_fields();
1528   }
mutable_unknown_fields()1529   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1530     return _internal_metadata_.mutable_unknown_fields();
1531   }
1532 
1533   static const ::google::protobuf::Descriptor* descriptor();
1534   static const TensorProto_Segment& default_instance();
1535 
1536   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
internal_default_instance()1537   static inline const TensorProto_Segment* internal_default_instance() {
1538     return reinterpret_cast<const TensorProto_Segment*>(
1539                &_TensorProto_Segment_default_instance_);
1540   }
1541   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
1542     6;
1543 
1544   void Swap(TensorProto_Segment* other);
swap(TensorProto_Segment & a,TensorProto_Segment & b)1545   friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) {
1546     a.Swap(&b);
1547   }
1548 
1549   // implements Message ----------------------------------------------
1550 
New()1551   inline TensorProto_Segment* New() const PROTOBUF_FINAL { return New(NULL); }
1552 
1553   TensorProto_Segment* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
1554   void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
1555   void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
1556   void CopyFrom(const TensorProto_Segment& from);
1557   void MergeFrom(const TensorProto_Segment& from);
1558   void Clear() PROTOBUF_FINAL;
1559   bool IsInitialized() const PROTOBUF_FINAL;
1560 
1561   size_t ByteSizeLong() const PROTOBUF_FINAL;
1562   bool MergePartialFromCodedStream(
1563       ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
1564   void SerializeWithCachedSizes(
1565       ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
1566   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1567       bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
GetCachedSize()1568   int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
1569   private:
1570   void SharedCtor();
1571   void SharedDtor();
1572   void SetCachedSize(int size) const PROTOBUF_FINAL;
1573   void InternalSwap(TensorProto_Segment* other);
1574   private:
GetArenaNoVirtual()1575   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1576     return NULL;
1577   }
MaybeArenaPtr()1578   inline void* MaybeArenaPtr() const {
1579     return NULL;
1580   }
1581   public:
1582 
1583   ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
1584 
1585   // nested types ----------------------------------------------------
1586 
1587   // accessors -------------------------------------------------------
1588 
1589   // optional int64 begin = 1;
1590   bool has_begin() const;
1591   void clear_begin();
1592   static const int kBeginFieldNumber = 1;
1593   ::google::protobuf::int64 begin() const;
1594   void set_begin(::google::protobuf::int64 value);
1595 
1596   // optional int64 end = 2;
1597   bool has_end() const;
1598   void clear_end();
1599   static const int kEndFieldNumber = 2;
1600   ::google::protobuf::int64 end() const;
1601   void set_end(::google::protobuf::int64 value);
1602 
1603   // @@protoc_insertion_point(class_scope:opencv_onnx.TensorProto.Segment)
1604  private:
1605   void set_has_begin();
1606   void clear_has_begin();
1607   void set_has_end();
1608   void clear_has_end();
1609 
1610   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1611   ::google::protobuf::internal::HasBits<1> _has_bits_;
1612   mutable int _cached_size_;
1613   ::google::protobuf::int64 begin_;
1614   ::google::protobuf::int64 end_;
1615   friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
1616   friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorProto_SegmentImpl();
1617 };
1618 // -------------------------------------------------------------------
1619 
1620 class TensorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorProto) */ {
1621  public:
1622   TensorProto();
1623   virtual ~TensorProto();
1624 
1625   TensorProto(const TensorProto& from);
1626 
1627   inline TensorProto& operator=(const TensorProto& from) {
1628     CopyFrom(from);
1629     return *this;
1630   }
1631   #if LANG_CXX11
TensorProto(TensorProto && from)1632   TensorProto(TensorProto&& from) noexcept
1633     : TensorProto() {
1634     *this = ::std::move(from);
1635   }
1636 
1637   inline TensorProto& operator=(TensorProto&& from) noexcept {
1638     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1639       if (this != &from) InternalSwap(&from);
1640     } else {
1641       CopyFrom(from);
1642     }
1643     return *this;
1644   }
1645   #endif
unknown_fields()1646   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1647     return _internal_metadata_.unknown_fields();
1648   }
mutable_unknown_fields()1649   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1650     return _internal_metadata_.mutable_unknown_fields();
1651   }
1652 
1653   static const ::google::protobuf::Descriptor* descriptor();
1654   static const TensorProto& default_instance();
1655 
1656   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
internal_default_instance()1657   static inline const TensorProto* internal_default_instance() {
1658     return reinterpret_cast<const TensorProto*>(
1659                &_TensorProto_default_instance_);
1660   }
1661   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
1662     7;
1663 
1664   void Swap(TensorProto* other);
swap(TensorProto & a,TensorProto & b)1665   friend void swap(TensorProto& a, TensorProto& b) {
1666     a.Swap(&b);
1667   }
1668 
1669   // implements Message ----------------------------------------------
1670 
New()1671   inline TensorProto* New() const PROTOBUF_FINAL { return New(NULL); }
1672 
1673   TensorProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
1674   void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
1675   void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
1676   void CopyFrom(const TensorProto& from);
1677   void MergeFrom(const TensorProto& from);
1678   void Clear() PROTOBUF_FINAL;
1679   bool IsInitialized() const PROTOBUF_FINAL;
1680 
1681   size_t ByteSizeLong() const PROTOBUF_FINAL;
1682   bool MergePartialFromCodedStream(
1683       ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
1684   void SerializeWithCachedSizes(
1685       ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
1686   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
1687       bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
GetCachedSize()1688   int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
1689   private:
1690   void SharedCtor();
1691   void SharedDtor();
1692   void SetCachedSize(int size) const PROTOBUF_FINAL;
1693   void InternalSwap(TensorProto* other);
1694   private:
GetArenaNoVirtual()1695   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1696     return NULL;
1697   }
MaybeArenaPtr()1698   inline void* MaybeArenaPtr() const {
1699     return NULL;
1700   }
1701   public:
1702 
1703   ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
1704 
1705   // nested types ----------------------------------------------------
1706 
1707   typedef TensorProto_Segment Segment;
1708 
1709   typedef TensorProto_DataType DataType;
1710   static const DataType UNDEFINED =
1711     TensorProto_DataType_UNDEFINED;
1712   static const DataType FLOAT =
1713     TensorProto_DataType_FLOAT;
1714   static const DataType UINT8 =
1715     TensorProto_DataType_UINT8;
1716   static const DataType INT8 =
1717     TensorProto_DataType_INT8;
1718   static const DataType UINT16 =
1719     TensorProto_DataType_UINT16;
1720   static const DataType INT16 =
1721     TensorProto_DataType_INT16;
1722   static const DataType INT32 =
1723     TensorProto_DataType_INT32;
1724   static const DataType INT64 =
1725     TensorProto_DataType_INT64;
1726   static const DataType STRING =
1727     TensorProto_DataType_STRING;
1728   static const DataType BOOL =
1729     TensorProto_DataType_BOOL;
1730   static const DataType FLOAT16 =
1731     TensorProto_DataType_FLOAT16;
1732   static const DataType DOUBLE =
1733     TensorProto_DataType_DOUBLE;
1734   static const DataType UINT32 =
1735     TensorProto_DataType_UINT32;
1736   static const DataType UINT64 =
1737     TensorProto_DataType_UINT64;
1738   static const DataType COMPLEX64 =
1739     TensorProto_DataType_COMPLEX64;
1740   static const DataType COMPLEX128 =
1741     TensorProto_DataType_COMPLEX128;
DataType_IsValid(int value)1742   static inline bool DataType_IsValid(int value) {
1743     return TensorProto_DataType_IsValid(value);
1744   }
1745   static const DataType DataType_MIN =
1746     TensorProto_DataType_DataType_MIN;
1747   static const DataType DataType_MAX =
1748     TensorProto_DataType_DataType_MAX;
1749   static const int DataType_ARRAYSIZE =
1750     TensorProto_DataType_DataType_ARRAYSIZE;
1751   static inline const ::google::protobuf::EnumDescriptor*
DataType_descriptor()1752   DataType_descriptor() {
1753     return TensorProto_DataType_descriptor();
1754   }
DataType_Name(DataType value)1755   static inline const ::std::string& DataType_Name(DataType value) {
1756     return TensorProto_DataType_Name(value);
1757   }
DataType_Parse(const::std::string & name,DataType * value)1758   static inline bool DataType_Parse(const ::std::string& name,
1759       DataType* value) {
1760     return TensorProto_DataType_Parse(name, value);
1761   }
1762 
1763   // accessors -------------------------------------------------------
1764 
1765   // repeated int64 dims = 1;
1766   int dims_size() const;
1767   void clear_dims();
1768   static const int kDimsFieldNumber = 1;
1769   ::google::protobuf::int64 dims(int index) const;
1770   void set_dims(int index, ::google::protobuf::int64 value);
1771   void add_dims(::google::protobuf::int64 value);
1772   const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
1773       dims() const;
1774   ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
1775       mutable_dims();
1776 
1777   // repeated float float_data = 4 [packed = true];
1778   int float_data_size() const;
1779   void clear_float_data();
1780   static const int kFloatDataFieldNumber = 4;
1781   float float_data(int index) const;
1782   void set_float_data(int index, float value);
1783   void add_float_data(float value);
1784   const ::google::protobuf::RepeatedField< float >&
1785       float_data() const;
1786   ::google::protobuf::RepeatedField< float >*
1787       mutable_float_data();
1788 
1789   // repeated int32 int32_data = 5 [packed = true];
1790   int int32_data_size() const;
1791   void clear_int32_data();
1792   static const int kInt32DataFieldNumber = 5;
1793   ::google::protobuf::int32 int32_data(int index) const;
1794   void set_int32_data(int index, ::google::protobuf::int32 value);
1795   void add_int32_data(::google::protobuf::int32 value);
1796   const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
1797       int32_data() const;
1798   ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
1799       mutable_int32_data();
1800 
1801   // repeated bytes string_data = 6;
1802   int string_data_size() const;
1803   void clear_string_data();
1804   static const int kStringDataFieldNumber = 6;
1805   const ::std::string& string_data(int index) const;
1806   ::std::string* mutable_string_data(int index);
1807   void set_string_data(int index, const ::std::string& value);
1808   #if LANG_CXX11
1809   void set_string_data(int index, ::std::string&& value);
1810   #endif
1811   void set_string_data(int index, const char* value);
1812   void set_string_data(int index, const void* value, size_t size);
1813   ::std::string* add_string_data();
1814   void add_string_data(const ::std::string& value);
1815   #if LANG_CXX11
1816   void add_string_data(::std::string&& value);
1817   #endif
1818   void add_string_data(const char* value);
1819   void add_string_data(const void* value, size_t size);
1820   const ::google::protobuf::RepeatedPtrField< ::std::string>& string_data() const;
1821   ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_string_data();
1822 
1823   // repeated int64 int64_data = 7 [packed = true];
1824   int int64_data_size() const;
1825   void clear_int64_data();
1826   static const int kInt64DataFieldNumber = 7;
1827   ::google::protobuf::int64 int64_data(int index) const;
1828   void set_int64_data(int index, ::google::protobuf::int64 value);
1829   void add_int64_data(::google::protobuf::int64 value);
1830   const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
1831       int64_data() const;
1832   ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
1833       mutable_int64_data();
1834 
1835   // repeated double double_data = 10 [packed = true];
1836   int double_data_size() const;
1837   void clear_double_data();
1838   static const int kDoubleDataFieldNumber = 10;
1839   double double_data(int index) const;
1840   void set_double_data(int index, double value);
1841   void add_double_data(double value);
1842   const ::google::protobuf::RepeatedField< double >&
1843       double_data() const;
1844   ::google::protobuf::RepeatedField< double >*
1845       mutable_double_data();
1846 
1847   // repeated uint64 uint64_data = 11 [packed = true];
1848   int uint64_data_size() const;
1849   void clear_uint64_data();
1850   static const int kUint64DataFieldNumber = 11;
1851   ::google::protobuf::uint64 uint64_data(int index) const;
1852   void set_uint64_data(int index, ::google::protobuf::uint64 value);
1853   void add_uint64_data(::google::protobuf::uint64 value);
1854   const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
1855       uint64_data() const;
1856   ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
1857       mutable_uint64_data();
1858 
1859   // optional string name = 8;
1860   bool has_name() const;
1861   void clear_name();
1862   static const int kNameFieldNumber = 8;
1863   const ::std::string& name() const;
1864   void set_name(const ::std::string& value);
1865   #if LANG_CXX11
1866   void set_name(::std::string&& value);
1867   #endif
1868   void set_name(const char* value);
1869   void set_name(const char* value, size_t size);
1870   ::std::string* mutable_name();
1871   ::std::string* release_name();
1872   void set_allocated_name(::std::string* name);
1873 
1874   // optional bytes raw_data = 9;
1875   bool has_raw_data() const;
1876   void clear_raw_data();
1877   static const int kRawDataFieldNumber = 9;
1878   const ::std::string& raw_data() const;
1879   void set_raw_data(const ::std::string& value);
1880   #if LANG_CXX11
1881   void set_raw_data(::std::string&& value);
1882   #endif
1883   void set_raw_data(const char* value);
1884   void set_raw_data(const void* value, size_t size);
1885   ::std::string* mutable_raw_data();
1886   ::std::string* release_raw_data();
1887   void set_allocated_raw_data(::std::string* raw_data);
1888 
1889   // optional string doc_string = 12;
1890   bool has_doc_string() const;
1891   void clear_doc_string();
1892   static const int kDocStringFieldNumber = 12;
1893   const ::std::string& doc_string() const;
1894   void set_doc_string(const ::std::string& value);
1895   #if LANG_CXX11
1896   void set_doc_string(::std::string&& value);
1897   #endif
1898   void set_doc_string(const char* value);
1899   void set_doc_string(const char* value, size_t size);
1900   ::std::string* mutable_doc_string();
1901   ::std::string* release_doc_string();
1902   void set_allocated_doc_string(::std::string* doc_string);
1903 
1904   // optional .opencv_onnx.TensorProto.Segment segment = 3;
1905   bool has_segment() const;
1906   void clear_segment();
1907   static const int kSegmentFieldNumber = 3;
1908   const ::opencv_onnx::TensorProto_Segment& segment() const;
1909   ::opencv_onnx::TensorProto_Segment* release_segment();
1910   ::opencv_onnx::TensorProto_Segment* mutable_segment();
1911   void set_allocated_segment(::opencv_onnx::TensorProto_Segment* segment);
1912 
1913   // optional .opencv_onnx.TensorProto.DataType data_type = 2;
1914   bool has_data_type() const;
1915   void clear_data_type();
1916   static const int kDataTypeFieldNumber = 2;
1917   ::opencv_onnx::TensorProto_DataType data_type() const;
1918   void set_data_type(::opencv_onnx::TensorProto_DataType value);
1919 
1920   // @@protoc_insertion_point(class_scope:opencv_onnx.TensorProto)
1921  private:
1922   void set_has_data_type();
1923   void clear_has_data_type();
1924   void set_has_segment();
1925   void clear_has_segment();
1926   void set_has_name();
1927   void clear_has_name();
1928   void set_has_doc_string();
1929   void clear_has_doc_string();
1930   void set_has_raw_data();
1931   void clear_has_raw_data();
1932 
1933   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
1934   ::google::protobuf::internal::HasBits<1> _has_bits_;
1935   mutable int _cached_size_;
1936   ::google::protobuf::RepeatedField< ::google::protobuf::int64 > dims_;
1937   ::google::protobuf::RepeatedField< float > float_data_;
1938   mutable int _float_data_cached_byte_size_;
1939   ::google::protobuf::RepeatedField< ::google::protobuf::int32 > int32_data_;
1940   mutable int _int32_data_cached_byte_size_;
1941   ::google::protobuf::RepeatedPtrField< ::std::string> string_data_;
1942   ::google::protobuf::RepeatedField< ::google::protobuf::int64 > int64_data_;
1943   mutable int _int64_data_cached_byte_size_;
1944   ::google::protobuf::RepeatedField< double > double_data_;
1945   mutable int _double_data_cached_byte_size_;
1946   ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > uint64_data_;
1947   mutable int _uint64_data_cached_byte_size_;
1948   ::google::protobuf::internal::ArenaStringPtr name_;
1949   ::google::protobuf::internal::ArenaStringPtr raw_data_;
1950   ::google::protobuf::internal::ArenaStringPtr doc_string_;
1951   ::opencv_onnx::TensorProto_Segment* segment_;
1952   int data_type_;
1953   friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
1954   friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorProtoImpl();
1955 };
1956 // -------------------------------------------------------------------
1957 
1958 class TensorShapeProto_Dimension : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorShapeProto.Dimension) */ {
1959  public:
1960   TensorShapeProto_Dimension();
1961   virtual ~TensorShapeProto_Dimension();
1962 
1963   TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from);
1964 
1965   inline TensorShapeProto_Dimension& operator=(const TensorShapeProto_Dimension& from) {
1966     CopyFrom(from);
1967     return *this;
1968   }
1969   #if LANG_CXX11
TensorShapeProto_Dimension(TensorShapeProto_Dimension && from)1970   TensorShapeProto_Dimension(TensorShapeProto_Dimension&& from) noexcept
1971     : TensorShapeProto_Dimension() {
1972     *this = ::std::move(from);
1973   }
1974 
1975   inline TensorShapeProto_Dimension& operator=(TensorShapeProto_Dimension&& from) noexcept {
1976     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1977       if (this != &from) InternalSwap(&from);
1978     } else {
1979       CopyFrom(from);
1980     }
1981     return *this;
1982   }
1983   #endif
unknown_fields()1984   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1985     return _internal_metadata_.unknown_fields();
1986   }
mutable_unknown_fields()1987   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1988     return _internal_metadata_.mutable_unknown_fields();
1989   }
1990 
1991   static const ::google::protobuf::Descriptor* descriptor();
1992   static const TensorShapeProto_Dimension& default_instance();
1993 
1994   enum ValueCase {
1995     kDimValue = 1,
1996     kDimParam = 2,
1997     VALUE_NOT_SET = 0,
1998   };
1999 
2000   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
internal_default_instance()2001   static inline const TensorShapeProto_Dimension* internal_default_instance() {
2002     return reinterpret_cast<const TensorShapeProto_Dimension*>(
2003                &_TensorShapeProto_Dimension_default_instance_);
2004   }
2005   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
2006     8;
2007 
2008   void Swap(TensorShapeProto_Dimension* other);
swap(TensorShapeProto_Dimension & a,TensorShapeProto_Dimension & b)2009   friend void swap(TensorShapeProto_Dimension& a, TensorShapeProto_Dimension& b) {
2010     a.Swap(&b);
2011   }
2012 
2013   // implements Message ----------------------------------------------
2014 
New()2015   inline TensorShapeProto_Dimension* New() const PROTOBUF_FINAL { return New(NULL); }
2016 
2017   TensorShapeProto_Dimension* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
2018   void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
2019   void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
2020   void CopyFrom(const TensorShapeProto_Dimension& from);
2021   void MergeFrom(const TensorShapeProto_Dimension& from);
2022   void Clear() PROTOBUF_FINAL;
2023   bool IsInitialized() const PROTOBUF_FINAL;
2024 
2025   size_t ByteSizeLong() const PROTOBUF_FINAL;
2026   bool MergePartialFromCodedStream(
2027       ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
2028   void SerializeWithCachedSizes(
2029       ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
2030   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2031       bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
GetCachedSize()2032   int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
2033   private:
2034   void SharedCtor();
2035   void SharedDtor();
2036   void SetCachedSize(int size) const PROTOBUF_FINAL;
2037   void InternalSwap(TensorShapeProto_Dimension* other);
2038   private:
GetArenaNoVirtual()2039   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2040     return NULL;
2041   }
MaybeArenaPtr()2042   inline void* MaybeArenaPtr() const {
2043     return NULL;
2044   }
2045   public:
2046 
2047   ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
2048 
2049   // nested types ----------------------------------------------------
2050 
2051   // accessors -------------------------------------------------------
2052 
2053   // optional string denotation = 3;
2054   bool has_denotation() const;
2055   void clear_denotation();
2056   static const int kDenotationFieldNumber = 3;
2057   const ::std::string& denotation() const;
2058   void set_denotation(const ::std::string& value);
2059   #if LANG_CXX11
2060   void set_denotation(::std::string&& value);
2061   #endif
2062   void set_denotation(const char* value);
2063   void set_denotation(const char* value, size_t size);
2064   ::std::string* mutable_denotation();
2065   ::std::string* release_denotation();
2066   void set_allocated_denotation(::std::string* denotation);
2067 
2068   // optional int64 dim_value = 1;
2069   bool has_dim_value() const;
2070   void clear_dim_value();
2071   static const int kDimValueFieldNumber = 1;
2072   ::google::protobuf::int64 dim_value() const;
2073   void set_dim_value(::google::protobuf::int64 value);
2074 
2075   // optional string dim_param = 2;
2076   bool has_dim_param() const;
2077   void clear_dim_param();
2078   static const int kDimParamFieldNumber = 2;
2079   const ::std::string& dim_param() const;
2080   void set_dim_param(const ::std::string& value);
2081   #if LANG_CXX11
2082   void set_dim_param(::std::string&& value);
2083   #endif
2084   void set_dim_param(const char* value);
2085   void set_dim_param(const char* value, size_t size);
2086   ::std::string* mutable_dim_param();
2087   ::std::string* release_dim_param();
2088   void set_allocated_dim_param(::std::string* dim_param);
2089 
2090   ValueCase value_case() const;
2091   // @@protoc_insertion_point(class_scope:opencv_onnx.TensorShapeProto.Dimension)
2092  private:
2093   void set_has_dim_value();
2094   void set_has_dim_param();
2095   void set_has_denotation();
2096   void clear_has_denotation();
2097 
2098   inline bool has_value() const;
2099   void clear_value();
2100   inline void clear_has_value();
2101 
2102   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2103   ::google::protobuf::internal::HasBits<1> _has_bits_;
2104   mutable int _cached_size_;
2105   ::google::protobuf::internal::ArenaStringPtr denotation_;
2106   union ValueUnion {
ValueUnion()2107     ValueUnion() {}
2108     ::google::protobuf::int64 dim_value_;
2109     ::google::protobuf::internal::ArenaStringPtr dim_param_;
2110   } value_;
2111   ::google::protobuf::uint32 _oneof_case_[1];
2112 
2113   friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
2114   friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorShapeProto_DimensionImpl();
2115 };
2116 // -------------------------------------------------------------------
2117 
2118 class TensorShapeProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorShapeProto) */ {
2119  public:
2120   TensorShapeProto();
2121   virtual ~TensorShapeProto();
2122 
2123   TensorShapeProto(const TensorShapeProto& from);
2124 
2125   inline TensorShapeProto& operator=(const TensorShapeProto& from) {
2126     CopyFrom(from);
2127     return *this;
2128   }
2129   #if LANG_CXX11
TensorShapeProto(TensorShapeProto && from)2130   TensorShapeProto(TensorShapeProto&& from) noexcept
2131     : TensorShapeProto() {
2132     *this = ::std::move(from);
2133   }
2134 
2135   inline TensorShapeProto& operator=(TensorShapeProto&& from) noexcept {
2136     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2137       if (this != &from) InternalSwap(&from);
2138     } else {
2139       CopyFrom(from);
2140     }
2141     return *this;
2142   }
2143   #endif
unknown_fields()2144   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2145     return _internal_metadata_.unknown_fields();
2146   }
mutable_unknown_fields()2147   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2148     return _internal_metadata_.mutable_unknown_fields();
2149   }
2150 
2151   static const ::google::protobuf::Descriptor* descriptor();
2152   static const TensorShapeProto& default_instance();
2153 
2154   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
internal_default_instance()2155   static inline const TensorShapeProto* internal_default_instance() {
2156     return reinterpret_cast<const TensorShapeProto*>(
2157                &_TensorShapeProto_default_instance_);
2158   }
2159   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
2160     9;
2161 
2162   void Swap(TensorShapeProto* other);
swap(TensorShapeProto & a,TensorShapeProto & b)2163   friend void swap(TensorShapeProto& a, TensorShapeProto& b) {
2164     a.Swap(&b);
2165   }
2166 
2167   // implements Message ----------------------------------------------
2168 
New()2169   inline TensorShapeProto* New() const PROTOBUF_FINAL { return New(NULL); }
2170 
2171   TensorShapeProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
2172   void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
2173   void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
2174   void CopyFrom(const TensorShapeProto& from);
2175   void MergeFrom(const TensorShapeProto& from);
2176   void Clear() PROTOBUF_FINAL;
2177   bool IsInitialized() const PROTOBUF_FINAL;
2178 
2179   size_t ByteSizeLong() const PROTOBUF_FINAL;
2180   bool MergePartialFromCodedStream(
2181       ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
2182   void SerializeWithCachedSizes(
2183       ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
2184   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2185       bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
GetCachedSize()2186   int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
2187   private:
2188   void SharedCtor();
2189   void SharedDtor();
2190   void SetCachedSize(int size) const PROTOBUF_FINAL;
2191   void InternalSwap(TensorShapeProto* other);
2192   private:
GetArenaNoVirtual()2193   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2194     return NULL;
2195   }
MaybeArenaPtr()2196   inline void* MaybeArenaPtr() const {
2197     return NULL;
2198   }
2199   public:
2200 
2201   ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
2202 
2203   // nested types ----------------------------------------------------
2204 
2205   typedef TensorShapeProto_Dimension Dimension;
2206 
2207   // accessors -------------------------------------------------------
2208 
2209   // repeated .opencv_onnx.TensorShapeProto.Dimension dim = 1;
2210   int dim_size() const;
2211   void clear_dim();
2212   static const int kDimFieldNumber = 1;
2213   const ::opencv_onnx::TensorShapeProto_Dimension& dim(int index) const;
2214   ::opencv_onnx::TensorShapeProto_Dimension* mutable_dim(int index);
2215   ::opencv_onnx::TensorShapeProto_Dimension* add_dim();
2216   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >*
2217       mutable_dim();
2218   const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >&
2219       dim() const;
2220 
2221   // @@protoc_insertion_point(class_scope:opencv_onnx.TensorShapeProto)
2222  private:
2223 
2224   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2225   ::google::protobuf::internal::HasBits<1> _has_bits_;
2226   mutable int _cached_size_;
2227   ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension > dim_;
2228   friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
2229   friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorShapeProtoImpl();
2230 };
2231 // -------------------------------------------------------------------
2232 
2233 class TypeProto_Tensor : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TypeProto.Tensor) */ {
2234  public:
2235   TypeProto_Tensor();
2236   virtual ~TypeProto_Tensor();
2237 
2238   TypeProto_Tensor(const TypeProto_Tensor& from);
2239 
2240   inline TypeProto_Tensor& operator=(const TypeProto_Tensor& from) {
2241     CopyFrom(from);
2242     return *this;
2243   }
2244   #if LANG_CXX11
TypeProto_Tensor(TypeProto_Tensor && from)2245   TypeProto_Tensor(TypeProto_Tensor&& from) noexcept
2246     : TypeProto_Tensor() {
2247     *this = ::std::move(from);
2248   }
2249 
2250   inline TypeProto_Tensor& operator=(TypeProto_Tensor&& from) noexcept {
2251     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2252       if (this != &from) InternalSwap(&from);
2253     } else {
2254       CopyFrom(from);
2255     }
2256     return *this;
2257   }
2258   #endif
unknown_fields()2259   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2260     return _internal_metadata_.unknown_fields();
2261   }
mutable_unknown_fields()2262   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2263     return _internal_metadata_.mutable_unknown_fields();
2264   }
2265 
2266   static const ::google::protobuf::Descriptor* descriptor();
2267   static const TypeProto_Tensor& default_instance();
2268 
2269   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
internal_default_instance()2270   static inline const TypeProto_Tensor* internal_default_instance() {
2271     return reinterpret_cast<const TypeProto_Tensor*>(
2272                &_TypeProto_Tensor_default_instance_);
2273   }
2274   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
2275     10;
2276 
2277   void Swap(TypeProto_Tensor* other);
swap(TypeProto_Tensor & a,TypeProto_Tensor & b)2278   friend void swap(TypeProto_Tensor& a, TypeProto_Tensor& b) {
2279     a.Swap(&b);
2280   }
2281 
2282   // implements Message ----------------------------------------------
2283 
New()2284   inline TypeProto_Tensor* New() const PROTOBUF_FINAL { return New(NULL); }
2285 
2286   TypeProto_Tensor* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
2287   void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
2288   void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
2289   void CopyFrom(const TypeProto_Tensor& from);
2290   void MergeFrom(const TypeProto_Tensor& from);
2291   void Clear() PROTOBUF_FINAL;
2292   bool IsInitialized() const PROTOBUF_FINAL;
2293 
2294   size_t ByteSizeLong() const PROTOBUF_FINAL;
2295   bool MergePartialFromCodedStream(
2296       ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
2297   void SerializeWithCachedSizes(
2298       ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
2299   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2300       bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
GetCachedSize()2301   int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
2302   private:
2303   void SharedCtor();
2304   void SharedDtor();
2305   void SetCachedSize(int size) const PROTOBUF_FINAL;
2306   void InternalSwap(TypeProto_Tensor* other);
2307   private:
GetArenaNoVirtual()2308   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2309     return NULL;
2310   }
MaybeArenaPtr()2311   inline void* MaybeArenaPtr() const {
2312     return NULL;
2313   }
2314   public:
2315 
2316   ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
2317 
2318   // nested types ----------------------------------------------------
2319 
2320   // accessors -------------------------------------------------------
2321 
2322   // optional .opencv_onnx.TensorShapeProto shape = 2;
2323   bool has_shape() const;
2324   void clear_shape();
2325   static const int kShapeFieldNumber = 2;
2326   const ::opencv_onnx::TensorShapeProto& shape() const;
2327   ::opencv_onnx::TensorShapeProto* release_shape();
2328   ::opencv_onnx::TensorShapeProto* mutable_shape();
2329   void set_allocated_shape(::opencv_onnx::TensorShapeProto* shape);
2330 
2331   // optional .opencv_onnx.TensorProto.DataType elem_type = 1;
2332   bool has_elem_type() const;
2333   void clear_elem_type();
2334   static const int kElemTypeFieldNumber = 1;
2335   ::opencv_onnx::TensorProto_DataType elem_type() const;
2336   void set_elem_type(::opencv_onnx::TensorProto_DataType value);
2337 
2338   // @@protoc_insertion_point(class_scope:opencv_onnx.TypeProto.Tensor)
2339  private:
2340   void set_has_elem_type();
2341   void clear_has_elem_type();
2342   void set_has_shape();
2343   void clear_has_shape();
2344 
2345   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2346   ::google::protobuf::internal::HasBits<1> _has_bits_;
2347   mutable int _cached_size_;
2348   ::opencv_onnx::TensorShapeProto* shape_;
2349   int elem_type_;
2350   friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
2351   friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsTypeProto_TensorImpl();
2352 };
2353 // -------------------------------------------------------------------
2354 
2355 class TypeProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TypeProto) */ {
2356  public:
2357   TypeProto();
2358   virtual ~TypeProto();
2359 
2360   TypeProto(const TypeProto& from);
2361 
2362   inline TypeProto& operator=(const TypeProto& from) {
2363     CopyFrom(from);
2364     return *this;
2365   }
2366   #if LANG_CXX11
TypeProto(TypeProto && from)2367   TypeProto(TypeProto&& from) noexcept
2368     : TypeProto() {
2369     *this = ::std::move(from);
2370   }
2371 
2372   inline TypeProto& operator=(TypeProto&& from) noexcept {
2373     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2374       if (this != &from) InternalSwap(&from);
2375     } else {
2376       CopyFrom(from);
2377     }
2378     return *this;
2379   }
2380   #endif
unknown_fields()2381   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2382     return _internal_metadata_.unknown_fields();
2383   }
mutable_unknown_fields()2384   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2385     return _internal_metadata_.mutable_unknown_fields();
2386   }
2387 
2388   static const ::google::protobuf::Descriptor* descriptor();
2389   static const TypeProto& default_instance();
2390 
2391   enum ValueCase {
2392     kTensorType = 1,
2393     VALUE_NOT_SET = 0,
2394   };
2395 
2396   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
internal_default_instance()2397   static inline const TypeProto* internal_default_instance() {
2398     return reinterpret_cast<const TypeProto*>(
2399                &_TypeProto_default_instance_);
2400   }
2401   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
2402     11;
2403 
2404   void Swap(TypeProto* other);
swap(TypeProto & a,TypeProto & b)2405   friend void swap(TypeProto& a, TypeProto& b) {
2406     a.Swap(&b);
2407   }
2408 
2409   // implements Message ----------------------------------------------
2410 
New()2411   inline TypeProto* New() const PROTOBUF_FINAL { return New(NULL); }
2412 
2413   TypeProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
2414   void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
2415   void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
2416   void CopyFrom(const TypeProto& from);
2417   void MergeFrom(const TypeProto& from);
2418   void Clear() PROTOBUF_FINAL;
2419   bool IsInitialized() const PROTOBUF_FINAL;
2420 
2421   size_t ByteSizeLong() const PROTOBUF_FINAL;
2422   bool MergePartialFromCodedStream(
2423       ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
2424   void SerializeWithCachedSizes(
2425       ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
2426   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2427       bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
GetCachedSize()2428   int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
2429   private:
2430   void SharedCtor();
2431   void SharedDtor();
2432   void SetCachedSize(int size) const PROTOBUF_FINAL;
2433   void InternalSwap(TypeProto* other);
2434   private:
GetArenaNoVirtual()2435   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2436     return NULL;
2437   }
MaybeArenaPtr()2438   inline void* MaybeArenaPtr() const {
2439     return NULL;
2440   }
2441   public:
2442 
2443   ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
2444 
2445   // nested types ----------------------------------------------------
2446 
2447   typedef TypeProto_Tensor Tensor;
2448 
2449   // accessors -------------------------------------------------------
2450 
2451   // optional string denotation = 6;
2452   bool has_denotation() const;
2453   void clear_denotation();
2454   static const int kDenotationFieldNumber = 6;
2455   const ::std::string& denotation() const;
2456   void set_denotation(const ::std::string& value);
2457   #if LANG_CXX11
2458   void set_denotation(::std::string&& value);
2459   #endif
2460   void set_denotation(const char* value);
2461   void set_denotation(const char* value, size_t size);
2462   ::std::string* mutable_denotation();
2463   ::std::string* release_denotation();
2464   void set_allocated_denotation(::std::string* denotation);
2465 
2466   // optional .opencv_onnx.TypeProto.Tensor tensor_type = 1;
2467   bool has_tensor_type() const;
2468   void clear_tensor_type();
2469   static const int kTensorTypeFieldNumber = 1;
2470   const ::opencv_onnx::TypeProto_Tensor& tensor_type() const;
2471   ::opencv_onnx::TypeProto_Tensor* release_tensor_type();
2472   ::opencv_onnx::TypeProto_Tensor* mutable_tensor_type();
2473   void set_allocated_tensor_type(::opencv_onnx::TypeProto_Tensor* tensor_type);
2474 
2475   ValueCase value_case() const;
2476   // @@protoc_insertion_point(class_scope:opencv_onnx.TypeProto)
2477  private:
2478   void set_has_tensor_type();
2479   void set_has_denotation();
2480   void clear_has_denotation();
2481 
2482   inline bool has_value() const;
2483   void clear_value();
2484   inline void clear_has_value();
2485 
2486   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2487   ::google::protobuf::internal::HasBits<1> _has_bits_;
2488   mutable int _cached_size_;
2489   ::google::protobuf::internal::ArenaStringPtr denotation_;
2490   union ValueUnion {
ValueUnion()2491     ValueUnion() {}
2492     ::opencv_onnx::TypeProto_Tensor* tensor_type_;
2493   } value_;
2494   ::google::protobuf::uint32 _oneof_case_[1];
2495 
2496   friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
2497   friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsTypeProtoImpl();
2498 };
2499 // -------------------------------------------------------------------
2500 
2501 class OperatorSetIdProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.OperatorSetIdProto) */ {
2502  public:
2503   OperatorSetIdProto();
2504   virtual ~OperatorSetIdProto();
2505 
2506   OperatorSetIdProto(const OperatorSetIdProto& from);
2507 
2508   inline OperatorSetIdProto& operator=(const OperatorSetIdProto& from) {
2509     CopyFrom(from);
2510     return *this;
2511   }
2512   #if LANG_CXX11
OperatorSetIdProto(OperatorSetIdProto && from)2513   OperatorSetIdProto(OperatorSetIdProto&& from) noexcept
2514     : OperatorSetIdProto() {
2515     *this = ::std::move(from);
2516   }
2517 
2518   inline OperatorSetIdProto& operator=(OperatorSetIdProto&& from) noexcept {
2519     if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2520       if (this != &from) InternalSwap(&from);
2521     } else {
2522       CopyFrom(from);
2523     }
2524     return *this;
2525   }
2526   #endif
unknown_fields()2527   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2528     return _internal_metadata_.unknown_fields();
2529   }
mutable_unknown_fields()2530   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2531     return _internal_metadata_.mutable_unknown_fields();
2532   }
2533 
2534   static const ::google::protobuf::Descriptor* descriptor();
2535   static const OperatorSetIdProto& default_instance();
2536 
2537   static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
internal_default_instance()2538   static inline const OperatorSetIdProto* internal_default_instance() {
2539     return reinterpret_cast<const OperatorSetIdProto*>(
2540                &_OperatorSetIdProto_default_instance_);
2541   }
2542   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
2543     12;
2544 
2545   void Swap(OperatorSetIdProto* other);
swap(OperatorSetIdProto & a,OperatorSetIdProto & b)2546   friend void swap(OperatorSetIdProto& a, OperatorSetIdProto& b) {
2547     a.Swap(&b);
2548   }
2549 
2550   // implements Message ----------------------------------------------
2551 
New()2552   inline OperatorSetIdProto* New() const PROTOBUF_FINAL { return New(NULL); }
2553 
2554   OperatorSetIdProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
2555   void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
2556   void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
2557   void CopyFrom(const OperatorSetIdProto& from);
2558   void MergeFrom(const OperatorSetIdProto& from);
2559   void Clear() PROTOBUF_FINAL;
2560   bool IsInitialized() const PROTOBUF_FINAL;
2561 
2562   size_t ByteSizeLong() const PROTOBUF_FINAL;
2563   bool MergePartialFromCodedStream(
2564       ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
2565   void SerializeWithCachedSizes(
2566       ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
2567   ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
2568       bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
GetCachedSize()2569   int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
2570   private:
2571   void SharedCtor();
2572   void SharedDtor();
2573   void SetCachedSize(int size) const PROTOBUF_FINAL;
2574   void InternalSwap(OperatorSetIdProto* other);
2575   private:
GetArenaNoVirtual()2576   inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2577     return NULL;
2578   }
MaybeArenaPtr()2579   inline void* MaybeArenaPtr() const {
2580     return NULL;
2581   }
2582   public:
2583 
2584   ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
2585 
2586   // nested types ----------------------------------------------------
2587 
2588   // accessors -------------------------------------------------------
2589 
2590   // optional string domain = 1;
2591   bool has_domain() const;
2592   void clear_domain();
2593   static const int kDomainFieldNumber = 1;
2594   const ::std::string& domain() const;
2595   void set_domain(const ::std::string& value);
2596   #if LANG_CXX11
2597   void set_domain(::std::string&& value);
2598   #endif
2599   void set_domain(const char* value);
2600   void set_domain(const char* value, size_t size);
2601   ::std::string* mutable_domain();
2602   ::std::string* release_domain();
2603   void set_allocated_domain(::std::string* domain);
2604 
2605   // optional int64 version = 2;
2606   bool has_version() const;
2607   void clear_version();
2608   static const int kVersionFieldNumber = 2;
2609   ::google::protobuf::int64 version() const;
2610   void set_version(::google::protobuf::int64 value);
2611 
2612   // @@protoc_insertion_point(class_scope:opencv_onnx.OperatorSetIdProto)
2613  private:
2614   void set_has_domain();
2615   void clear_has_domain();
2616   void set_has_version();
2617   void clear_has_version();
2618 
2619   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
2620   ::google::protobuf::internal::HasBits<1> _has_bits_;
2621   mutable int _cached_size_;
2622   ::google::protobuf::internal::ArenaStringPtr domain_;
2623   ::google::protobuf::int64 version_;
2624   friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
2625   friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsOperatorSetIdProtoImpl();
2626 };
2627 // ===================================================================
2628 
2629 
2630 // ===================================================================
2631 
2632 #ifdef __GNUC__
2633   #pragma GCC diagnostic push
2634   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
2635 #endif  // __GNUC__
2636 // AttributeProto
2637 
2638 // optional string name = 1;
has_name()2639 inline bool AttributeProto::has_name() const {
2640   return (_has_bits_[0] & 0x00000001u) != 0;
2641 }
set_has_name()2642 inline void AttributeProto::set_has_name() {
2643   _has_bits_[0] |= 0x00000001u;
2644 }
clear_has_name()2645 inline void AttributeProto::clear_has_name() {
2646   _has_bits_[0] &= ~0x00000001u;
2647 }
clear_name()2648 inline void AttributeProto::clear_name() {
2649   name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2650   clear_has_name();
2651 }
name()2652 inline const ::std::string& AttributeProto::name() const {
2653   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.name)
2654   return name_.GetNoArena();
2655 }
set_name(const::std::string & value)2656 inline void AttributeProto::set_name(const ::std::string& value) {
2657   set_has_name();
2658   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2659   // @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.name)
2660 }
2661 #if LANG_CXX11
set_name(::std::string && value)2662 inline void AttributeProto::set_name(::std::string&& value) {
2663   set_has_name();
2664   name_.SetNoArena(
2665     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2666   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.AttributeProto.name)
2667 }
2668 #endif
set_name(const char * value)2669 inline void AttributeProto::set_name(const char* value) {
2670   GOOGLE_DCHECK(value != NULL);
2671   set_has_name();
2672   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2673   // @@protoc_insertion_point(field_set_char:opencv_onnx.AttributeProto.name)
2674 }
set_name(const char * value,size_t size)2675 inline void AttributeProto::set_name(const char* value, size_t size) {
2676   set_has_name();
2677   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2678       ::std::string(reinterpret_cast<const char*>(value), size));
2679   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.AttributeProto.name)
2680 }
mutable_name()2681 inline ::std::string* AttributeProto::mutable_name() {
2682   set_has_name();
2683   // @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.name)
2684   return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2685 }
release_name()2686 inline ::std::string* AttributeProto::release_name() {
2687   // @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.name)
2688   clear_has_name();
2689   return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2690 }
set_allocated_name(::std::string * name)2691 inline void AttributeProto::set_allocated_name(::std::string* name) {
2692   if (name != NULL) {
2693     set_has_name();
2694   } else {
2695     clear_has_name();
2696   }
2697   name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
2698   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.name)
2699 }
2700 
2701 // optional string ref_attr_name = 21;
has_ref_attr_name()2702 inline bool AttributeProto::has_ref_attr_name() const {
2703   return (_has_bits_[0] & 0x00000008u) != 0;
2704 }
set_has_ref_attr_name()2705 inline void AttributeProto::set_has_ref_attr_name() {
2706   _has_bits_[0] |= 0x00000008u;
2707 }
clear_has_ref_attr_name()2708 inline void AttributeProto::clear_has_ref_attr_name() {
2709   _has_bits_[0] &= ~0x00000008u;
2710 }
clear_ref_attr_name()2711 inline void AttributeProto::clear_ref_attr_name() {
2712   ref_attr_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2713   clear_has_ref_attr_name();
2714 }
ref_attr_name()2715 inline const ::std::string& AttributeProto::ref_attr_name() const {
2716   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.ref_attr_name)
2717   return ref_attr_name_.GetNoArena();
2718 }
set_ref_attr_name(const::std::string & value)2719 inline void AttributeProto::set_ref_attr_name(const ::std::string& value) {
2720   set_has_ref_attr_name();
2721   ref_attr_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2722   // @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.ref_attr_name)
2723 }
2724 #if LANG_CXX11
set_ref_attr_name(::std::string && value)2725 inline void AttributeProto::set_ref_attr_name(::std::string&& value) {
2726   set_has_ref_attr_name();
2727   ref_attr_name_.SetNoArena(
2728     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2729   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.AttributeProto.ref_attr_name)
2730 }
2731 #endif
set_ref_attr_name(const char * value)2732 inline void AttributeProto::set_ref_attr_name(const char* value) {
2733   GOOGLE_DCHECK(value != NULL);
2734   set_has_ref_attr_name();
2735   ref_attr_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2736   // @@protoc_insertion_point(field_set_char:opencv_onnx.AttributeProto.ref_attr_name)
2737 }
set_ref_attr_name(const char * value,size_t size)2738 inline void AttributeProto::set_ref_attr_name(const char* value, size_t size) {
2739   set_has_ref_attr_name();
2740   ref_attr_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2741       ::std::string(reinterpret_cast<const char*>(value), size));
2742   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.AttributeProto.ref_attr_name)
2743 }
mutable_ref_attr_name()2744 inline ::std::string* AttributeProto::mutable_ref_attr_name() {
2745   set_has_ref_attr_name();
2746   // @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.ref_attr_name)
2747   return ref_attr_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2748 }
release_ref_attr_name()2749 inline ::std::string* AttributeProto::release_ref_attr_name() {
2750   // @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.ref_attr_name)
2751   clear_has_ref_attr_name();
2752   return ref_attr_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2753 }
set_allocated_ref_attr_name(::std::string * ref_attr_name)2754 inline void AttributeProto::set_allocated_ref_attr_name(::std::string* ref_attr_name) {
2755   if (ref_attr_name != NULL) {
2756     set_has_ref_attr_name();
2757   } else {
2758     clear_has_ref_attr_name();
2759   }
2760   ref_attr_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ref_attr_name);
2761   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.ref_attr_name)
2762 }
2763 
2764 // optional string doc_string = 13;
has_doc_string()2765 inline bool AttributeProto::has_doc_string() const {
2766   return (_has_bits_[0] & 0x00000004u) != 0;
2767 }
set_has_doc_string()2768 inline void AttributeProto::set_has_doc_string() {
2769   _has_bits_[0] |= 0x00000004u;
2770 }
clear_has_doc_string()2771 inline void AttributeProto::clear_has_doc_string() {
2772   _has_bits_[0] &= ~0x00000004u;
2773 }
clear_doc_string()2774 inline void AttributeProto::clear_doc_string() {
2775   doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2776   clear_has_doc_string();
2777 }
doc_string()2778 inline const ::std::string& AttributeProto::doc_string() const {
2779   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.doc_string)
2780   return doc_string_.GetNoArena();
2781 }
set_doc_string(const::std::string & value)2782 inline void AttributeProto::set_doc_string(const ::std::string& value) {
2783   set_has_doc_string();
2784   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2785   // @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.doc_string)
2786 }
2787 #if LANG_CXX11
set_doc_string(::std::string && value)2788 inline void AttributeProto::set_doc_string(::std::string&& value) {
2789   set_has_doc_string();
2790   doc_string_.SetNoArena(
2791     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2792   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.AttributeProto.doc_string)
2793 }
2794 #endif
set_doc_string(const char * value)2795 inline void AttributeProto::set_doc_string(const char* value) {
2796   GOOGLE_DCHECK(value != NULL);
2797   set_has_doc_string();
2798   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2799   // @@protoc_insertion_point(field_set_char:opencv_onnx.AttributeProto.doc_string)
2800 }
set_doc_string(const char * value,size_t size)2801 inline void AttributeProto::set_doc_string(const char* value, size_t size) {
2802   set_has_doc_string();
2803   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2804       ::std::string(reinterpret_cast<const char*>(value), size));
2805   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.AttributeProto.doc_string)
2806 }
mutable_doc_string()2807 inline ::std::string* AttributeProto::mutable_doc_string() {
2808   set_has_doc_string();
2809   // @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.doc_string)
2810   return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2811 }
release_doc_string()2812 inline ::std::string* AttributeProto::release_doc_string() {
2813   // @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.doc_string)
2814   clear_has_doc_string();
2815   return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2816 }
set_allocated_doc_string(::std::string * doc_string)2817 inline void AttributeProto::set_allocated_doc_string(::std::string* doc_string) {
2818   if (doc_string != NULL) {
2819     set_has_doc_string();
2820   } else {
2821     clear_has_doc_string();
2822   }
2823   doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
2824   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.doc_string)
2825 }
2826 
2827 // optional .opencv_onnx.AttributeProto.AttributeType type = 20;
has_type()2828 inline bool AttributeProto::has_type() const {
2829   return (_has_bits_[0] & 0x00000100u) != 0;
2830 }
set_has_type()2831 inline void AttributeProto::set_has_type() {
2832   _has_bits_[0] |= 0x00000100u;
2833 }
clear_has_type()2834 inline void AttributeProto::clear_has_type() {
2835   _has_bits_[0] &= ~0x00000100u;
2836 }
clear_type()2837 inline void AttributeProto::clear_type() {
2838   type_ = 0;
2839   clear_has_type();
2840 }
type()2841 inline ::opencv_onnx::AttributeProto_AttributeType AttributeProto::type() const {
2842   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.type)
2843   return static_cast< ::opencv_onnx::AttributeProto_AttributeType >(type_);
2844 }
set_type(::opencv_onnx::AttributeProto_AttributeType value)2845 inline void AttributeProto::set_type(::opencv_onnx::AttributeProto_AttributeType value) {
2846   assert(::opencv_onnx::AttributeProto_AttributeType_IsValid(value));
2847   set_has_type();
2848   type_ = value;
2849   // @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.type)
2850 }
2851 
2852 // optional float f = 2;
has_f()2853 inline bool AttributeProto::has_f() const {
2854   return (_has_bits_[0] & 0x00000080u) != 0;
2855 }
set_has_f()2856 inline void AttributeProto::set_has_f() {
2857   _has_bits_[0] |= 0x00000080u;
2858 }
clear_has_f()2859 inline void AttributeProto::clear_has_f() {
2860   _has_bits_[0] &= ~0x00000080u;
2861 }
clear_f()2862 inline void AttributeProto::clear_f() {
2863   f_ = 0;
2864   clear_has_f();
2865 }
f()2866 inline float AttributeProto::f() const {
2867   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.f)
2868   return f_;
2869 }
set_f(float value)2870 inline void AttributeProto::set_f(float value) {
2871   set_has_f();
2872   f_ = value;
2873   // @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.f)
2874 }
2875 
2876 // optional int64 i = 3;
has_i()2877 inline bool AttributeProto::has_i() const {
2878   return (_has_bits_[0] & 0x00000040u) != 0;
2879 }
set_has_i()2880 inline void AttributeProto::set_has_i() {
2881   _has_bits_[0] |= 0x00000040u;
2882 }
clear_has_i()2883 inline void AttributeProto::clear_has_i() {
2884   _has_bits_[0] &= ~0x00000040u;
2885 }
clear_i()2886 inline void AttributeProto::clear_i() {
2887   i_ = GOOGLE_LONGLONG(0);
2888   clear_has_i();
2889 }
i()2890 inline ::google::protobuf::int64 AttributeProto::i() const {
2891   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.i)
2892   return i_;
2893 }
set_i(::google::protobuf::int64 value)2894 inline void AttributeProto::set_i(::google::protobuf::int64 value) {
2895   set_has_i();
2896   i_ = value;
2897   // @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.i)
2898 }
2899 
2900 // optional bytes s = 4;
has_s()2901 inline bool AttributeProto::has_s() const {
2902   return (_has_bits_[0] & 0x00000002u) != 0;
2903 }
set_has_s()2904 inline void AttributeProto::set_has_s() {
2905   _has_bits_[0] |= 0x00000002u;
2906 }
clear_has_s()2907 inline void AttributeProto::clear_has_s() {
2908   _has_bits_[0] &= ~0x00000002u;
2909 }
clear_s()2910 inline void AttributeProto::clear_s() {
2911   s_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2912   clear_has_s();
2913 }
s()2914 inline const ::std::string& AttributeProto::s() const {
2915   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.s)
2916   return s_.GetNoArena();
2917 }
set_s(const::std::string & value)2918 inline void AttributeProto::set_s(const ::std::string& value) {
2919   set_has_s();
2920   s_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
2921   // @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.s)
2922 }
2923 #if LANG_CXX11
set_s(::std::string && value)2924 inline void AttributeProto::set_s(::std::string&& value) {
2925   set_has_s();
2926   s_.SetNoArena(
2927     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
2928   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.AttributeProto.s)
2929 }
2930 #endif
set_s(const char * value)2931 inline void AttributeProto::set_s(const char* value) {
2932   GOOGLE_DCHECK(value != NULL);
2933   set_has_s();
2934   s_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
2935   // @@protoc_insertion_point(field_set_char:opencv_onnx.AttributeProto.s)
2936 }
set_s(const void * value,size_t size)2937 inline void AttributeProto::set_s(const void* value, size_t size) {
2938   set_has_s();
2939   s_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
2940       ::std::string(reinterpret_cast<const char*>(value), size));
2941   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.AttributeProto.s)
2942 }
mutable_s()2943 inline ::std::string* AttributeProto::mutable_s() {
2944   set_has_s();
2945   // @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.s)
2946   return s_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2947 }
release_s()2948 inline ::std::string* AttributeProto::release_s() {
2949   // @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.s)
2950   clear_has_s();
2951   return s_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2952 }
set_allocated_s(::std::string * s)2953 inline void AttributeProto::set_allocated_s(::std::string* s) {
2954   if (s != NULL) {
2955     set_has_s();
2956   } else {
2957     clear_has_s();
2958   }
2959   s_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), s);
2960   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.s)
2961 }
2962 
2963 // optional .opencv_onnx.TensorProto t = 5;
has_t()2964 inline bool AttributeProto::has_t() const {
2965   return (_has_bits_[0] & 0x00000010u) != 0;
2966 }
set_has_t()2967 inline void AttributeProto::set_has_t() {
2968   _has_bits_[0] |= 0x00000010u;
2969 }
clear_has_t()2970 inline void AttributeProto::clear_has_t() {
2971   _has_bits_[0] &= ~0x00000010u;
2972 }
clear_t()2973 inline void AttributeProto::clear_t() {
2974   if (t_ != NULL) t_->Clear();
2975   clear_has_t();
2976 }
t()2977 inline const ::opencv_onnx::TensorProto& AttributeProto::t() const {
2978   const ::opencv_onnx::TensorProto* p = t_;
2979   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.t)
2980   return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::TensorProto*>(
2981       &::opencv_onnx::_TensorProto_default_instance_);
2982 }
release_t()2983 inline ::opencv_onnx::TensorProto* AttributeProto::release_t() {
2984   // @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.t)
2985   clear_has_t();
2986   ::opencv_onnx::TensorProto* temp = t_;
2987   t_ = NULL;
2988   return temp;
2989 }
mutable_t()2990 inline ::opencv_onnx::TensorProto* AttributeProto::mutable_t() {
2991   set_has_t();
2992   if (t_ == NULL) {
2993     t_ = new ::opencv_onnx::TensorProto;
2994   }
2995   // @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.t)
2996   return t_;
2997 }
set_allocated_t(::opencv_onnx::TensorProto * t)2998 inline void AttributeProto::set_allocated_t(::opencv_onnx::TensorProto* t) {
2999   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3000   if (message_arena == NULL) {
3001     delete t_;
3002   }
3003   if (t) {
3004     ::google::protobuf::Arena* submessage_arena = NULL;
3005     if (message_arena != submessage_arena) {
3006       t = ::google::protobuf::internal::GetOwnedMessage(
3007           message_arena, t, submessage_arena);
3008     }
3009     set_has_t();
3010   } else {
3011     clear_has_t();
3012   }
3013   t_ = t;
3014   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.t)
3015 }
3016 
3017 // optional .opencv_onnx.GraphProto g = 6;
has_g()3018 inline bool AttributeProto::has_g() const {
3019   return (_has_bits_[0] & 0x00000020u) != 0;
3020 }
set_has_g()3021 inline void AttributeProto::set_has_g() {
3022   _has_bits_[0] |= 0x00000020u;
3023 }
clear_has_g()3024 inline void AttributeProto::clear_has_g() {
3025   _has_bits_[0] &= ~0x00000020u;
3026 }
clear_g()3027 inline void AttributeProto::clear_g() {
3028   if (g_ != NULL) g_->Clear();
3029   clear_has_g();
3030 }
g()3031 inline const ::opencv_onnx::GraphProto& AttributeProto::g() const {
3032   const ::opencv_onnx::GraphProto* p = g_;
3033   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.g)
3034   return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::GraphProto*>(
3035       &::opencv_onnx::_GraphProto_default_instance_);
3036 }
release_g()3037 inline ::opencv_onnx::GraphProto* AttributeProto::release_g() {
3038   // @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.g)
3039   clear_has_g();
3040   ::opencv_onnx::GraphProto* temp = g_;
3041   g_ = NULL;
3042   return temp;
3043 }
mutable_g()3044 inline ::opencv_onnx::GraphProto* AttributeProto::mutable_g() {
3045   set_has_g();
3046   if (g_ == NULL) {
3047     g_ = new ::opencv_onnx::GraphProto;
3048   }
3049   // @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.g)
3050   return g_;
3051 }
set_allocated_g(::opencv_onnx::GraphProto * g)3052 inline void AttributeProto::set_allocated_g(::opencv_onnx::GraphProto* g) {
3053   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3054   if (message_arena == NULL) {
3055     delete g_;
3056   }
3057   if (g) {
3058     ::google::protobuf::Arena* submessage_arena = NULL;
3059     if (message_arena != submessage_arena) {
3060       g = ::google::protobuf::internal::GetOwnedMessage(
3061           message_arena, g, submessage_arena);
3062     }
3063     set_has_g();
3064   } else {
3065     clear_has_g();
3066   }
3067   g_ = g;
3068   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.g)
3069 }
3070 
3071 // repeated float floats = 7;
floats_size()3072 inline int AttributeProto::floats_size() const {
3073   return floats_.size();
3074 }
clear_floats()3075 inline void AttributeProto::clear_floats() {
3076   floats_.Clear();
3077 }
floats(int index)3078 inline float AttributeProto::floats(int index) const {
3079   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.floats)
3080   return floats_.Get(index);
3081 }
set_floats(int index,float value)3082 inline void AttributeProto::set_floats(int index, float value) {
3083   floats_.Set(index, value);
3084   // @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.floats)
3085 }
add_floats(float value)3086 inline void AttributeProto::add_floats(float value) {
3087   floats_.Add(value);
3088   // @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.floats)
3089 }
3090 inline const ::google::protobuf::RepeatedField< float >&
floats()3091 AttributeProto::floats() const {
3092   // @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.floats)
3093   return floats_;
3094 }
3095 inline ::google::protobuf::RepeatedField< float >*
mutable_floats()3096 AttributeProto::mutable_floats() {
3097   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.floats)
3098   return &floats_;
3099 }
3100 
3101 // repeated int64 ints = 8;
ints_size()3102 inline int AttributeProto::ints_size() const {
3103   return ints_.size();
3104 }
clear_ints()3105 inline void AttributeProto::clear_ints() {
3106   ints_.Clear();
3107 }
ints(int index)3108 inline ::google::protobuf::int64 AttributeProto::ints(int index) const {
3109   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.ints)
3110   return ints_.Get(index);
3111 }
set_ints(int index,::google::protobuf::int64 value)3112 inline void AttributeProto::set_ints(int index, ::google::protobuf::int64 value) {
3113   ints_.Set(index, value);
3114   // @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.ints)
3115 }
add_ints(::google::protobuf::int64 value)3116 inline void AttributeProto::add_ints(::google::protobuf::int64 value) {
3117   ints_.Add(value);
3118   // @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.ints)
3119 }
3120 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
ints()3121 AttributeProto::ints() const {
3122   // @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.ints)
3123   return ints_;
3124 }
3125 inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
mutable_ints()3126 AttributeProto::mutable_ints() {
3127   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.ints)
3128   return &ints_;
3129 }
3130 
3131 // repeated bytes strings = 9;
strings_size()3132 inline int AttributeProto::strings_size() const {
3133   return strings_.size();
3134 }
clear_strings()3135 inline void AttributeProto::clear_strings() {
3136   strings_.Clear();
3137 }
strings(int index)3138 inline const ::std::string& AttributeProto::strings(int index) const {
3139   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.strings)
3140   return strings_.Get(index);
3141 }
mutable_strings(int index)3142 inline ::std::string* AttributeProto::mutable_strings(int index) {
3143   // @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.strings)
3144   return strings_.Mutable(index);
3145 }
set_strings(int index,const::std::string & value)3146 inline void AttributeProto::set_strings(int index, const ::std::string& value) {
3147   // @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.strings)
3148   strings_.Mutable(index)->assign(value);
3149 }
3150 #if LANG_CXX11
set_strings(int index,::std::string && value)3151 inline void AttributeProto::set_strings(int index, ::std::string&& value) {
3152   // @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.strings)
3153   strings_.Mutable(index)->assign(std::move(value));
3154 }
3155 #endif
set_strings(int index,const char * value)3156 inline void AttributeProto::set_strings(int index, const char* value) {
3157   GOOGLE_DCHECK(value != NULL);
3158   strings_.Mutable(index)->assign(value);
3159   // @@protoc_insertion_point(field_set_char:opencv_onnx.AttributeProto.strings)
3160 }
set_strings(int index,const void * value,size_t size)3161 inline void AttributeProto::set_strings(int index, const void* value, size_t size) {
3162   strings_.Mutable(index)->assign(
3163     reinterpret_cast<const char*>(value), size);
3164   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.AttributeProto.strings)
3165 }
add_strings()3166 inline ::std::string* AttributeProto::add_strings() {
3167   // @@protoc_insertion_point(field_add_mutable:opencv_onnx.AttributeProto.strings)
3168   return strings_.Add();
3169 }
add_strings(const::std::string & value)3170 inline void AttributeProto::add_strings(const ::std::string& value) {
3171   strings_.Add()->assign(value);
3172   // @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.strings)
3173 }
3174 #if LANG_CXX11
add_strings(::std::string && value)3175 inline void AttributeProto::add_strings(::std::string&& value) {
3176   strings_.Add(std::move(value));
3177   // @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.strings)
3178 }
3179 #endif
add_strings(const char * value)3180 inline void AttributeProto::add_strings(const char* value) {
3181   GOOGLE_DCHECK(value != NULL);
3182   strings_.Add()->assign(value);
3183   // @@protoc_insertion_point(field_add_char:opencv_onnx.AttributeProto.strings)
3184 }
add_strings(const void * value,size_t size)3185 inline void AttributeProto::add_strings(const void* value, size_t size) {
3186   strings_.Add()->assign(reinterpret_cast<const char*>(value), size);
3187   // @@protoc_insertion_point(field_add_pointer:opencv_onnx.AttributeProto.strings)
3188 }
3189 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
strings()3190 AttributeProto::strings() const {
3191   // @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.strings)
3192   return strings_;
3193 }
3194 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
mutable_strings()3195 AttributeProto::mutable_strings() {
3196   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.strings)
3197   return &strings_;
3198 }
3199 
3200 // repeated .opencv_onnx.TensorProto tensors = 10;
tensors_size()3201 inline int AttributeProto::tensors_size() const {
3202   return tensors_.size();
3203 }
clear_tensors()3204 inline void AttributeProto::clear_tensors() {
3205   tensors_.Clear();
3206 }
tensors(int index)3207 inline const ::opencv_onnx::TensorProto& AttributeProto::tensors(int index) const {
3208   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.tensors)
3209   return tensors_.Get(index);
3210 }
mutable_tensors(int index)3211 inline ::opencv_onnx::TensorProto* AttributeProto::mutable_tensors(int index) {
3212   // @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.tensors)
3213   return tensors_.Mutable(index);
3214 }
add_tensors()3215 inline ::opencv_onnx::TensorProto* AttributeProto::add_tensors() {
3216   // @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.tensors)
3217   return tensors_.Add();
3218 }
3219 inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >*
mutable_tensors()3220 AttributeProto::mutable_tensors() {
3221   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.tensors)
3222   return &tensors_;
3223 }
3224 inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >&
tensors()3225 AttributeProto::tensors() const {
3226   // @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.tensors)
3227   return tensors_;
3228 }
3229 
3230 // repeated .opencv_onnx.GraphProto graphs = 11;
graphs_size()3231 inline int AttributeProto::graphs_size() const {
3232   return graphs_.size();
3233 }
clear_graphs()3234 inline void AttributeProto::clear_graphs() {
3235   graphs_.Clear();
3236 }
graphs(int index)3237 inline const ::opencv_onnx::GraphProto& AttributeProto::graphs(int index) const {
3238   // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.graphs)
3239   return graphs_.Get(index);
3240 }
mutable_graphs(int index)3241 inline ::opencv_onnx::GraphProto* AttributeProto::mutable_graphs(int index) {
3242   // @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.graphs)
3243   return graphs_.Mutable(index);
3244 }
add_graphs()3245 inline ::opencv_onnx::GraphProto* AttributeProto::add_graphs() {
3246   // @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.graphs)
3247   return graphs_.Add();
3248 }
3249 inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::GraphProto >*
mutable_graphs()3250 AttributeProto::mutable_graphs() {
3251   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.graphs)
3252   return &graphs_;
3253 }
3254 inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::GraphProto >&
graphs()3255 AttributeProto::graphs() const {
3256   // @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.graphs)
3257   return graphs_;
3258 }
3259 
3260 // -------------------------------------------------------------------
3261 
3262 // ValueInfoProto
3263 
3264 // optional string name = 1;
has_name()3265 inline bool ValueInfoProto::has_name() const {
3266   return (_has_bits_[0] & 0x00000001u) != 0;
3267 }
set_has_name()3268 inline void ValueInfoProto::set_has_name() {
3269   _has_bits_[0] |= 0x00000001u;
3270 }
clear_has_name()3271 inline void ValueInfoProto::clear_has_name() {
3272   _has_bits_[0] &= ~0x00000001u;
3273 }
clear_name()3274 inline void ValueInfoProto::clear_name() {
3275   name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3276   clear_has_name();
3277 }
name()3278 inline const ::std::string& ValueInfoProto::name() const {
3279   // @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.name)
3280   return name_.GetNoArena();
3281 }
set_name(const::std::string & value)3282 inline void ValueInfoProto::set_name(const ::std::string& value) {
3283   set_has_name();
3284   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3285   // @@protoc_insertion_point(field_set:opencv_onnx.ValueInfoProto.name)
3286 }
3287 #if LANG_CXX11
set_name(::std::string && value)3288 inline void ValueInfoProto::set_name(::std::string&& value) {
3289   set_has_name();
3290   name_.SetNoArena(
3291     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3292   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.ValueInfoProto.name)
3293 }
3294 #endif
set_name(const char * value)3295 inline void ValueInfoProto::set_name(const char* value) {
3296   GOOGLE_DCHECK(value != NULL);
3297   set_has_name();
3298   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3299   // @@protoc_insertion_point(field_set_char:opencv_onnx.ValueInfoProto.name)
3300 }
set_name(const char * value,size_t size)3301 inline void ValueInfoProto::set_name(const char* value, size_t size) {
3302   set_has_name();
3303   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3304       ::std::string(reinterpret_cast<const char*>(value), size));
3305   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.ValueInfoProto.name)
3306 }
mutable_name()3307 inline ::std::string* ValueInfoProto::mutable_name() {
3308   set_has_name();
3309   // @@protoc_insertion_point(field_mutable:opencv_onnx.ValueInfoProto.name)
3310   return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3311 }
release_name()3312 inline ::std::string* ValueInfoProto::release_name() {
3313   // @@protoc_insertion_point(field_release:opencv_onnx.ValueInfoProto.name)
3314   clear_has_name();
3315   return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3316 }
set_allocated_name(::std::string * name)3317 inline void ValueInfoProto::set_allocated_name(::std::string* name) {
3318   if (name != NULL) {
3319     set_has_name();
3320   } else {
3321     clear_has_name();
3322   }
3323   name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
3324   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.ValueInfoProto.name)
3325 }
3326 
3327 // optional .opencv_onnx.TypeProto type = 2;
has_type()3328 inline bool ValueInfoProto::has_type() const {
3329   return (_has_bits_[0] & 0x00000004u) != 0;
3330 }
set_has_type()3331 inline void ValueInfoProto::set_has_type() {
3332   _has_bits_[0] |= 0x00000004u;
3333 }
clear_has_type()3334 inline void ValueInfoProto::clear_has_type() {
3335   _has_bits_[0] &= ~0x00000004u;
3336 }
clear_type()3337 inline void ValueInfoProto::clear_type() {
3338   if (type_ != NULL) type_->Clear();
3339   clear_has_type();
3340 }
type()3341 inline const ::opencv_onnx::TypeProto& ValueInfoProto::type() const {
3342   const ::opencv_onnx::TypeProto* p = type_;
3343   // @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.type)
3344   return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::TypeProto*>(
3345       &::opencv_onnx::_TypeProto_default_instance_);
3346 }
release_type()3347 inline ::opencv_onnx::TypeProto* ValueInfoProto::release_type() {
3348   // @@protoc_insertion_point(field_release:opencv_onnx.ValueInfoProto.type)
3349   clear_has_type();
3350   ::opencv_onnx::TypeProto* temp = type_;
3351   type_ = NULL;
3352   return temp;
3353 }
mutable_type()3354 inline ::opencv_onnx::TypeProto* ValueInfoProto::mutable_type() {
3355   set_has_type();
3356   if (type_ == NULL) {
3357     type_ = new ::opencv_onnx::TypeProto;
3358   }
3359   // @@protoc_insertion_point(field_mutable:opencv_onnx.ValueInfoProto.type)
3360   return type_;
3361 }
set_allocated_type(::opencv_onnx::TypeProto * type)3362 inline void ValueInfoProto::set_allocated_type(::opencv_onnx::TypeProto* type) {
3363   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
3364   if (message_arena == NULL) {
3365     delete type_;
3366   }
3367   if (type) {
3368     ::google::protobuf::Arena* submessage_arena = NULL;
3369     if (message_arena != submessage_arena) {
3370       type = ::google::protobuf::internal::GetOwnedMessage(
3371           message_arena, type, submessage_arena);
3372     }
3373     set_has_type();
3374   } else {
3375     clear_has_type();
3376   }
3377   type_ = type;
3378   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.ValueInfoProto.type)
3379 }
3380 
3381 // optional string doc_string = 3;
has_doc_string()3382 inline bool ValueInfoProto::has_doc_string() const {
3383   return (_has_bits_[0] & 0x00000002u) != 0;
3384 }
set_has_doc_string()3385 inline void ValueInfoProto::set_has_doc_string() {
3386   _has_bits_[0] |= 0x00000002u;
3387 }
clear_has_doc_string()3388 inline void ValueInfoProto::clear_has_doc_string() {
3389   _has_bits_[0] &= ~0x00000002u;
3390 }
clear_doc_string()3391 inline void ValueInfoProto::clear_doc_string() {
3392   doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3393   clear_has_doc_string();
3394 }
doc_string()3395 inline const ::std::string& ValueInfoProto::doc_string() const {
3396   // @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.doc_string)
3397   return doc_string_.GetNoArena();
3398 }
set_doc_string(const::std::string & value)3399 inline void ValueInfoProto::set_doc_string(const ::std::string& value) {
3400   set_has_doc_string();
3401   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3402   // @@protoc_insertion_point(field_set:opencv_onnx.ValueInfoProto.doc_string)
3403 }
3404 #if LANG_CXX11
set_doc_string(::std::string && value)3405 inline void ValueInfoProto::set_doc_string(::std::string&& value) {
3406   set_has_doc_string();
3407   doc_string_.SetNoArena(
3408     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3409   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.ValueInfoProto.doc_string)
3410 }
3411 #endif
set_doc_string(const char * value)3412 inline void ValueInfoProto::set_doc_string(const char* value) {
3413   GOOGLE_DCHECK(value != NULL);
3414   set_has_doc_string();
3415   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3416   // @@protoc_insertion_point(field_set_char:opencv_onnx.ValueInfoProto.doc_string)
3417 }
set_doc_string(const char * value,size_t size)3418 inline void ValueInfoProto::set_doc_string(const char* value, size_t size) {
3419   set_has_doc_string();
3420   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3421       ::std::string(reinterpret_cast<const char*>(value), size));
3422   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.ValueInfoProto.doc_string)
3423 }
mutable_doc_string()3424 inline ::std::string* ValueInfoProto::mutable_doc_string() {
3425   set_has_doc_string();
3426   // @@protoc_insertion_point(field_mutable:opencv_onnx.ValueInfoProto.doc_string)
3427   return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3428 }
release_doc_string()3429 inline ::std::string* ValueInfoProto::release_doc_string() {
3430   // @@protoc_insertion_point(field_release:opencv_onnx.ValueInfoProto.doc_string)
3431   clear_has_doc_string();
3432   return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3433 }
set_allocated_doc_string(::std::string * doc_string)3434 inline void ValueInfoProto::set_allocated_doc_string(::std::string* doc_string) {
3435   if (doc_string != NULL) {
3436     set_has_doc_string();
3437   } else {
3438     clear_has_doc_string();
3439   }
3440   doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
3441   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.ValueInfoProto.doc_string)
3442 }
3443 
3444 // -------------------------------------------------------------------
3445 
3446 // NodeProto
3447 
3448 // repeated string input = 1;
input_size()3449 inline int NodeProto::input_size() const {
3450   return input_.size();
3451 }
clear_input()3452 inline void NodeProto::clear_input() {
3453   input_.Clear();
3454 }
input(int index)3455 inline const ::std::string& NodeProto::input(int index) const {
3456   // @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.input)
3457   return input_.Get(index);
3458 }
mutable_input(int index)3459 inline ::std::string* NodeProto::mutable_input(int index) {
3460   // @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.input)
3461   return input_.Mutable(index);
3462 }
set_input(int index,const::std::string & value)3463 inline void NodeProto::set_input(int index, const ::std::string& value) {
3464   // @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.input)
3465   input_.Mutable(index)->assign(value);
3466 }
3467 #if LANG_CXX11
set_input(int index,::std::string && value)3468 inline void NodeProto::set_input(int index, ::std::string&& value) {
3469   // @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.input)
3470   input_.Mutable(index)->assign(std::move(value));
3471 }
3472 #endif
set_input(int index,const char * value)3473 inline void NodeProto::set_input(int index, const char* value) {
3474   GOOGLE_DCHECK(value != NULL);
3475   input_.Mutable(index)->assign(value);
3476   // @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.input)
3477 }
set_input(int index,const char * value,size_t size)3478 inline void NodeProto::set_input(int index, const char* value, size_t size) {
3479   input_.Mutable(index)->assign(
3480     reinterpret_cast<const char*>(value), size);
3481   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.input)
3482 }
add_input()3483 inline ::std::string* NodeProto::add_input() {
3484   // @@protoc_insertion_point(field_add_mutable:opencv_onnx.NodeProto.input)
3485   return input_.Add();
3486 }
add_input(const::std::string & value)3487 inline void NodeProto::add_input(const ::std::string& value) {
3488   input_.Add()->assign(value);
3489   // @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.input)
3490 }
3491 #if LANG_CXX11
add_input(::std::string && value)3492 inline void NodeProto::add_input(::std::string&& value) {
3493   input_.Add(std::move(value));
3494   // @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.input)
3495 }
3496 #endif
add_input(const char * value)3497 inline void NodeProto::add_input(const char* value) {
3498   GOOGLE_DCHECK(value != NULL);
3499   input_.Add()->assign(value);
3500   // @@protoc_insertion_point(field_add_char:opencv_onnx.NodeProto.input)
3501 }
add_input(const char * value,size_t size)3502 inline void NodeProto::add_input(const char* value, size_t size) {
3503   input_.Add()->assign(reinterpret_cast<const char*>(value), size);
3504   // @@protoc_insertion_point(field_add_pointer:opencv_onnx.NodeProto.input)
3505 }
3506 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
input()3507 NodeProto::input() const {
3508   // @@protoc_insertion_point(field_list:opencv_onnx.NodeProto.input)
3509   return input_;
3510 }
3511 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
mutable_input()3512 NodeProto::mutable_input() {
3513   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.NodeProto.input)
3514   return &input_;
3515 }
3516 
3517 // repeated string output = 2;
output_size()3518 inline int NodeProto::output_size() const {
3519   return output_.size();
3520 }
clear_output()3521 inline void NodeProto::clear_output() {
3522   output_.Clear();
3523 }
output(int index)3524 inline const ::std::string& NodeProto::output(int index) const {
3525   // @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.output)
3526   return output_.Get(index);
3527 }
mutable_output(int index)3528 inline ::std::string* NodeProto::mutable_output(int index) {
3529   // @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.output)
3530   return output_.Mutable(index);
3531 }
set_output(int index,const::std::string & value)3532 inline void NodeProto::set_output(int index, const ::std::string& value) {
3533   // @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.output)
3534   output_.Mutable(index)->assign(value);
3535 }
3536 #if LANG_CXX11
set_output(int index,::std::string && value)3537 inline void NodeProto::set_output(int index, ::std::string&& value) {
3538   // @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.output)
3539   output_.Mutable(index)->assign(std::move(value));
3540 }
3541 #endif
set_output(int index,const char * value)3542 inline void NodeProto::set_output(int index, const char* value) {
3543   GOOGLE_DCHECK(value != NULL);
3544   output_.Mutable(index)->assign(value);
3545   // @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.output)
3546 }
set_output(int index,const char * value,size_t size)3547 inline void NodeProto::set_output(int index, const char* value, size_t size) {
3548   output_.Mutable(index)->assign(
3549     reinterpret_cast<const char*>(value), size);
3550   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.output)
3551 }
add_output()3552 inline ::std::string* NodeProto::add_output() {
3553   // @@protoc_insertion_point(field_add_mutable:opencv_onnx.NodeProto.output)
3554   return output_.Add();
3555 }
add_output(const::std::string & value)3556 inline void NodeProto::add_output(const ::std::string& value) {
3557   output_.Add()->assign(value);
3558   // @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.output)
3559 }
3560 #if LANG_CXX11
add_output(::std::string && value)3561 inline void NodeProto::add_output(::std::string&& value) {
3562   output_.Add(std::move(value));
3563   // @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.output)
3564 }
3565 #endif
add_output(const char * value)3566 inline void NodeProto::add_output(const char* value) {
3567   GOOGLE_DCHECK(value != NULL);
3568   output_.Add()->assign(value);
3569   // @@protoc_insertion_point(field_add_char:opencv_onnx.NodeProto.output)
3570 }
add_output(const char * value,size_t size)3571 inline void NodeProto::add_output(const char* value, size_t size) {
3572   output_.Add()->assign(reinterpret_cast<const char*>(value), size);
3573   // @@protoc_insertion_point(field_add_pointer:opencv_onnx.NodeProto.output)
3574 }
3575 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
output()3576 NodeProto::output() const {
3577   // @@protoc_insertion_point(field_list:opencv_onnx.NodeProto.output)
3578   return output_;
3579 }
3580 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
mutable_output()3581 NodeProto::mutable_output() {
3582   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.NodeProto.output)
3583   return &output_;
3584 }
3585 
3586 // optional string name = 3;
has_name()3587 inline bool NodeProto::has_name() const {
3588   return (_has_bits_[0] & 0x00000001u) != 0;
3589 }
set_has_name()3590 inline void NodeProto::set_has_name() {
3591   _has_bits_[0] |= 0x00000001u;
3592 }
clear_has_name()3593 inline void NodeProto::clear_has_name() {
3594   _has_bits_[0] &= ~0x00000001u;
3595 }
clear_name()3596 inline void NodeProto::clear_name() {
3597   name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3598   clear_has_name();
3599 }
name()3600 inline const ::std::string& NodeProto::name() const {
3601   // @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.name)
3602   return name_.GetNoArena();
3603 }
set_name(const::std::string & value)3604 inline void NodeProto::set_name(const ::std::string& value) {
3605   set_has_name();
3606   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3607   // @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.name)
3608 }
3609 #if LANG_CXX11
set_name(::std::string && value)3610 inline void NodeProto::set_name(::std::string&& value) {
3611   set_has_name();
3612   name_.SetNoArena(
3613     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3614   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.NodeProto.name)
3615 }
3616 #endif
set_name(const char * value)3617 inline void NodeProto::set_name(const char* value) {
3618   GOOGLE_DCHECK(value != NULL);
3619   set_has_name();
3620   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3621   // @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.name)
3622 }
set_name(const char * value,size_t size)3623 inline void NodeProto::set_name(const char* value, size_t size) {
3624   set_has_name();
3625   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3626       ::std::string(reinterpret_cast<const char*>(value), size));
3627   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.name)
3628 }
mutable_name()3629 inline ::std::string* NodeProto::mutable_name() {
3630   set_has_name();
3631   // @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.name)
3632   return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3633 }
release_name()3634 inline ::std::string* NodeProto::release_name() {
3635   // @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.name)
3636   clear_has_name();
3637   return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3638 }
set_allocated_name(::std::string * name)3639 inline void NodeProto::set_allocated_name(::std::string* name) {
3640   if (name != NULL) {
3641     set_has_name();
3642   } else {
3643     clear_has_name();
3644   }
3645   name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
3646   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.name)
3647 }
3648 
3649 // optional string op_type = 4;
has_op_type()3650 inline bool NodeProto::has_op_type() const {
3651   return (_has_bits_[0] & 0x00000002u) != 0;
3652 }
set_has_op_type()3653 inline void NodeProto::set_has_op_type() {
3654   _has_bits_[0] |= 0x00000002u;
3655 }
clear_has_op_type()3656 inline void NodeProto::clear_has_op_type() {
3657   _has_bits_[0] &= ~0x00000002u;
3658 }
clear_op_type()3659 inline void NodeProto::clear_op_type() {
3660   op_type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3661   clear_has_op_type();
3662 }
op_type()3663 inline const ::std::string& NodeProto::op_type() const {
3664   // @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.op_type)
3665   return op_type_.GetNoArena();
3666 }
set_op_type(const::std::string & value)3667 inline void NodeProto::set_op_type(const ::std::string& value) {
3668   set_has_op_type();
3669   op_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3670   // @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.op_type)
3671 }
3672 #if LANG_CXX11
set_op_type(::std::string && value)3673 inline void NodeProto::set_op_type(::std::string&& value) {
3674   set_has_op_type();
3675   op_type_.SetNoArena(
3676     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3677   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.NodeProto.op_type)
3678 }
3679 #endif
set_op_type(const char * value)3680 inline void NodeProto::set_op_type(const char* value) {
3681   GOOGLE_DCHECK(value != NULL);
3682   set_has_op_type();
3683   op_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3684   // @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.op_type)
3685 }
set_op_type(const char * value,size_t size)3686 inline void NodeProto::set_op_type(const char* value, size_t size) {
3687   set_has_op_type();
3688   op_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3689       ::std::string(reinterpret_cast<const char*>(value), size));
3690   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.op_type)
3691 }
mutable_op_type()3692 inline ::std::string* NodeProto::mutable_op_type() {
3693   set_has_op_type();
3694   // @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.op_type)
3695   return op_type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3696 }
release_op_type()3697 inline ::std::string* NodeProto::release_op_type() {
3698   // @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.op_type)
3699   clear_has_op_type();
3700   return op_type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3701 }
set_allocated_op_type(::std::string * op_type)3702 inline void NodeProto::set_allocated_op_type(::std::string* op_type) {
3703   if (op_type != NULL) {
3704     set_has_op_type();
3705   } else {
3706     clear_has_op_type();
3707   }
3708   op_type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), op_type);
3709   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.op_type)
3710 }
3711 
3712 // optional string domain = 7;
has_domain()3713 inline bool NodeProto::has_domain() const {
3714   return (_has_bits_[0] & 0x00000008u) != 0;
3715 }
set_has_domain()3716 inline void NodeProto::set_has_domain() {
3717   _has_bits_[0] |= 0x00000008u;
3718 }
clear_has_domain()3719 inline void NodeProto::clear_has_domain() {
3720   _has_bits_[0] &= ~0x00000008u;
3721 }
clear_domain()3722 inline void NodeProto::clear_domain() {
3723   domain_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3724   clear_has_domain();
3725 }
domain()3726 inline const ::std::string& NodeProto::domain() const {
3727   // @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.domain)
3728   return domain_.GetNoArena();
3729 }
set_domain(const::std::string & value)3730 inline void NodeProto::set_domain(const ::std::string& value) {
3731   set_has_domain();
3732   domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3733   // @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.domain)
3734 }
3735 #if LANG_CXX11
set_domain(::std::string && value)3736 inline void NodeProto::set_domain(::std::string&& value) {
3737   set_has_domain();
3738   domain_.SetNoArena(
3739     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3740   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.NodeProto.domain)
3741 }
3742 #endif
set_domain(const char * value)3743 inline void NodeProto::set_domain(const char* value) {
3744   GOOGLE_DCHECK(value != NULL);
3745   set_has_domain();
3746   domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3747   // @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.domain)
3748 }
set_domain(const char * value,size_t size)3749 inline void NodeProto::set_domain(const char* value, size_t size) {
3750   set_has_domain();
3751   domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3752       ::std::string(reinterpret_cast<const char*>(value), size));
3753   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.domain)
3754 }
mutable_domain()3755 inline ::std::string* NodeProto::mutable_domain() {
3756   set_has_domain();
3757   // @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.domain)
3758   return domain_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3759 }
release_domain()3760 inline ::std::string* NodeProto::release_domain() {
3761   // @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.domain)
3762   clear_has_domain();
3763   return domain_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3764 }
set_allocated_domain(::std::string * domain)3765 inline void NodeProto::set_allocated_domain(::std::string* domain) {
3766   if (domain != NULL) {
3767     set_has_domain();
3768   } else {
3769     clear_has_domain();
3770   }
3771   domain_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), domain);
3772   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.domain)
3773 }
3774 
3775 // repeated .opencv_onnx.AttributeProto attribute = 5;
attribute_size()3776 inline int NodeProto::attribute_size() const {
3777   return attribute_.size();
3778 }
clear_attribute()3779 inline void NodeProto::clear_attribute() {
3780   attribute_.Clear();
3781 }
attribute(int index)3782 inline const ::opencv_onnx::AttributeProto& NodeProto::attribute(int index) const {
3783   // @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.attribute)
3784   return attribute_.Get(index);
3785 }
mutable_attribute(int index)3786 inline ::opencv_onnx::AttributeProto* NodeProto::mutable_attribute(int index) {
3787   // @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.attribute)
3788   return attribute_.Mutable(index);
3789 }
add_attribute()3790 inline ::opencv_onnx::AttributeProto* NodeProto::add_attribute() {
3791   // @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.attribute)
3792   return attribute_.Add();
3793 }
3794 inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::AttributeProto >*
mutable_attribute()3795 NodeProto::mutable_attribute() {
3796   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.NodeProto.attribute)
3797   return &attribute_;
3798 }
3799 inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::AttributeProto >&
attribute()3800 NodeProto::attribute() const {
3801   // @@protoc_insertion_point(field_list:opencv_onnx.NodeProto.attribute)
3802   return attribute_;
3803 }
3804 
3805 // optional string doc_string = 6;
has_doc_string()3806 inline bool NodeProto::has_doc_string() const {
3807   return (_has_bits_[0] & 0x00000004u) != 0;
3808 }
set_has_doc_string()3809 inline void NodeProto::set_has_doc_string() {
3810   _has_bits_[0] |= 0x00000004u;
3811 }
clear_has_doc_string()3812 inline void NodeProto::clear_has_doc_string() {
3813   _has_bits_[0] &= ~0x00000004u;
3814 }
clear_doc_string()3815 inline void NodeProto::clear_doc_string() {
3816   doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3817   clear_has_doc_string();
3818 }
doc_string()3819 inline const ::std::string& NodeProto::doc_string() const {
3820   // @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.doc_string)
3821   return doc_string_.GetNoArena();
3822 }
set_doc_string(const::std::string & value)3823 inline void NodeProto::set_doc_string(const ::std::string& value) {
3824   set_has_doc_string();
3825   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3826   // @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.doc_string)
3827 }
3828 #if LANG_CXX11
set_doc_string(::std::string && value)3829 inline void NodeProto::set_doc_string(::std::string&& value) {
3830   set_has_doc_string();
3831   doc_string_.SetNoArena(
3832     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3833   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.NodeProto.doc_string)
3834 }
3835 #endif
set_doc_string(const char * value)3836 inline void NodeProto::set_doc_string(const char* value) {
3837   GOOGLE_DCHECK(value != NULL);
3838   set_has_doc_string();
3839   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3840   // @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.doc_string)
3841 }
set_doc_string(const char * value,size_t size)3842 inline void NodeProto::set_doc_string(const char* value, size_t size) {
3843   set_has_doc_string();
3844   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3845       ::std::string(reinterpret_cast<const char*>(value), size));
3846   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.doc_string)
3847 }
mutable_doc_string()3848 inline ::std::string* NodeProto::mutable_doc_string() {
3849   set_has_doc_string();
3850   // @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.doc_string)
3851   return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3852 }
release_doc_string()3853 inline ::std::string* NodeProto::release_doc_string() {
3854   // @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.doc_string)
3855   clear_has_doc_string();
3856   return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3857 }
set_allocated_doc_string(::std::string * doc_string)3858 inline void NodeProto::set_allocated_doc_string(::std::string* doc_string) {
3859   if (doc_string != NULL) {
3860     set_has_doc_string();
3861   } else {
3862     clear_has_doc_string();
3863   }
3864   doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
3865   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.doc_string)
3866 }
3867 
3868 // -------------------------------------------------------------------
3869 
3870 // ModelProto
3871 
3872 // optional int64 ir_version = 1;
has_ir_version()3873 inline bool ModelProto::has_ir_version() const {
3874   return (_has_bits_[0] & 0x00000020u) != 0;
3875 }
set_has_ir_version()3876 inline void ModelProto::set_has_ir_version() {
3877   _has_bits_[0] |= 0x00000020u;
3878 }
clear_has_ir_version()3879 inline void ModelProto::clear_has_ir_version() {
3880   _has_bits_[0] &= ~0x00000020u;
3881 }
clear_ir_version()3882 inline void ModelProto::clear_ir_version() {
3883   ir_version_ = GOOGLE_LONGLONG(0);
3884   clear_has_ir_version();
3885 }
ir_version()3886 inline ::google::protobuf::int64 ModelProto::ir_version() const {
3887   // @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.ir_version)
3888   return ir_version_;
3889 }
set_ir_version(::google::protobuf::int64 value)3890 inline void ModelProto::set_ir_version(::google::protobuf::int64 value) {
3891   set_has_ir_version();
3892   ir_version_ = value;
3893   // @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.ir_version)
3894 }
3895 
3896 // repeated .opencv_onnx.OperatorSetIdProto opset_import = 8;
opset_import_size()3897 inline int ModelProto::opset_import_size() const {
3898   return opset_import_.size();
3899 }
clear_opset_import()3900 inline void ModelProto::clear_opset_import() {
3901   opset_import_.Clear();
3902 }
opset_import(int index)3903 inline const ::opencv_onnx::OperatorSetIdProto& ModelProto::opset_import(int index) const {
3904   // @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.opset_import)
3905   return opset_import_.Get(index);
3906 }
mutable_opset_import(int index)3907 inline ::opencv_onnx::OperatorSetIdProto* ModelProto::mutable_opset_import(int index) {
3908   // @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.opset_import)
3909   return opset_import_.Mutable(index);
3910 }
add_opset_import()3911 inline ::opencv_onnx::OperatorSetIdProto* ModelProto::add_opset_import() {
3912   // @@protoc_insertion_point(field_add:opencv_onnx.ModelProto.opset_import)
3913   return opset_import_.Add();
3914 }
3915 inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >*
mutable_opset_import()3916 ModelProto::mutable_opset_import() {
3917   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.ModelProto.opset_import)
3918   return &opset_import_;
3919 }
3920 inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >&
opset_import()3921 ModelProto::opset_import() const {
3922   // @@protoc_insertion_point(field_list:opencv_onnx.ModelProto.opset_import)
3923   return opset_import_;
3924 }
3925 
3926 // optional string producer_name = 2;
has_producer_name()3927 inline bool ModelProto::has_producer_name() const {
3928   return (_has_bits_[0] & 0x00000001u) != 0;
3929 }
set_has_producer_name()3930 inline void ModelProto::set_has_producer_name() {
3931   _has_bits_[0] |= 0x00000001u;
3932 }
clear_has_producer_name()3933 inline void ModelProto::clear_has_producer_name() {
3934   _has_bits_[0] &= ~0x00000001u;
3935 }
clear_producer_name()3936 inline void ModelProto::clear_producer_name() {
3937   producer_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3938   clear_has_producer_name();
3939 }
producer_name()3940 inline const ::std::string& ModelProto::producer_name() const {
3941   // @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.producer_name)
3942   return producer_name_.GetNoArena();
3943 }
set_producer_name(const::std::string & value)3944 inline void ModelProto::set_producer_name(const ::std::string& value) {
3945   set_has_producer_name();
3946   producer_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
3947   // @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.producer_name)
3948 }
3949 #if LANG_CXX11
set_producer_name(::std::string && value)3950 inline void ModelProto::set_producer_name(::std::string&& value) {
3951   set_has_producer_name();
3952   producer_name_.SetNoArena(
3953     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
3954   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.ModelProto.producer_name)
3955 }
3956 #endif
set_producer_name(const char * value)3957 inline void ModelProto::set_producer_name(const char* value) {
3958   GOOGLE_DCHECK(value != NULL);
3959   set_has_producer_name();
3960   producer_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
3961   // @@protoc_insertion_point(field_set_char:opencv_onnx.ModelProto.producer_name)
3962 }
set_producer_name(const char * value,size_t size)3963 inline void ModelProto::set_producer_name(const char* value, size_t size) {
3964   set_has_producer_name();
3965   producer_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
3966       ::std::string(reinterpret_cast<const char*>(value), size));
3967   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.ModelProto.producer_name)
3968 }
mutable_producer_name()3969 inline ::std::string* ModelProto::mutable_producer_name() {
3970   set_has_producer_name();
3971   // @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.producer_name)
3972   return producer_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3973 }
release_producer_name()3974 inline ::std::string* ModelProto::release_producer_name() {
3975   // @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.producer_name)
3976   clear_has_producer_name();
3977   return producer_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3978 }
set_allocated_producer_name(::std::string * producer_name)3979 inline void ModelProto::set_allocated_producer_name(::std::string* producer_name) {
3980   if (producer_name != NULL) {
3981     set_has_producer_name();
3982   } else {
3983     clear_has_producer_name();
3984   }
3985   producer_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), producer_name);
3986   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.producer_name)
3987 }
3988 
3989 // optional string producer_version = 3;
has_producer_version()3990 inline bool ModelProto::has_producer_version() const {
3991   return (_has_bits_[0] & 0x00000002u) != 0;
3992 }
set_has_producer_version()3993 inline void ModelProto::set_has_producer_version() {
3994   _has_bits_[0] |= 0x00000002u;
3995 }
clear_has_producer_version()3996 inline void ModelProto::clear_has_producer_version() {
3997   _has_bits_[0] &= ~0x00000002u;
3998 }
clear_producer_version()3999 inline void ModelProto::clear_producer_version() {
4000   producer_version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4001   clear_has_producer_version();
4002 }
producer_version()4003 inline const ::std::string& ModelProto::producer_version() const {
4004   // @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.producer_version)
4005   return producer_version_.GetNoArena();
4006 }
set_producer_version(const::std::string & value)4007 inline void ModelProto::set_producer_version(const ::std::string& value) {
4008   set_has_producer_version();
4009   producer_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4010   // @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.producer_version)
4011 }
4012 #if LANG_CXX11
set_producer_version(::std::string && value)4013 inline void ModelProto::set_producer_version(::std::string&& value) {
4014   set_has_producer_version();
4015   producer_version_.SetNoArena(
4016     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4017   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.ModelProto.producer_version)
4018 }
4019 #endif
set_producer_version(const char * value)4020 inline void ModelProto::set_producer_version(const char* value) {
4021   GOOGLE_DCHECK(value != NULL);
4022   set_has_producer_version();
4023   producer_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4024   // @@protoc_insertion_point(field_set_char:opencv_onnx.ModelProto.producer_version)
4025 }
set_producer_version(const char * value,size_t size)4026 inline void ModelProto::set_producer_version(const char* value, size_t size) {
4027   set_has_producer_version();
4028   producer_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4029       ::std::string(reinterpret_cast<const char*>(value), size));
4030   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.ModelProto.producer_version)
4031 }
mutable_producer_version()4032 inline ::std::string* ModelProto::mutable_producer_version() {
4033   set_has_producer_version();
4034   // @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.producer_version)
4035   return producer_version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4036 }
release_producer_version()4037 inline ::std::string* ModelProto::release_producer_version() {
4038   // @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.producer_version)
4039   clear_has_producer_version();
4040   return producer_version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4041 }
set_allocated_producer_version(::std::string * producer_version)4042 inline void ModelProto::set_allocated_producer_version(::std::string* producer_version) {
4043   if (producer_version != NULL) {
4044     set_has_producer_version();
4045   } else {
4046     clear_has_producer_version();
4047   }
4048   producer_version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), producer_version);
4049   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.producer_version)
4050 }
4051 
4052 // optional string domain = 4;
has_domain()4053 inline bool ModelProto::has_domain() const {
4054   return (_has_bits_[0] & 0x00000004u) != 0;
4055 }
set_has_domain()4056 inline void ModelProto::set_has_domain() {
4057   _has_bits_[0] |= 0x00000004u;
4058 }
clear_has_domain()4059 inline void ModelProto::clear_has_domain() {
4060   _has_bits_[0] &= ~0x00000004u;
4061 }
clear_domain()4062 inline void ModelProto::clear_domain() {
4063   domain_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4064   clear_has_domain();
4065 }
domain()4066 inline const ::std::string& ModelProto::domain() const {
4067   // @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.domain)
4068   return domain_.GetNoArena();
4069 }
set_domain(const::std::string & value)4070 inline void ModelProto::set_domain(const ::std::string& value) {
4071   set_has_domain();
4072   domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4073   // @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.domain)
4074 }
4075 #if LANG_CXX11
set_domain(::std::string && value)4076 inline void ModelProto::set_domain(::std::string&& value) {
4077   set_has_domain();
4078   domain_.SetNoArena(
4079     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4080   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.ModelProto.domain)
4081 }
4082 #endif
set_domain(const char * value)4083 inline void ModelProto::set_domain(const char* value) {
4084   GOOGLE_DCHECK(value != NULL);
4085   set_has_domain();
4086   domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4087   // @@protoc_insertion_point(field_set_char:opencv_onnx.ModelProto.domain)
4088 }
set_domain(const char * value,size_t size)4089 inline void ModelProto::set_domain(const char* value, size_t size) {
4090   set_has_domain();
4091   domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4092       ::std::string(reinterpret_cast<const char*>(value), size));
4093   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.ModelProto.domain)
4094 }
mutable_domain()4095 inline ::std::string* ModelProto::mutable_domain() {
4096   set_has_domain();
4097   // @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.domain)
4098   return domain_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4099 }
release_domain()4100 inline ::std::string* ModelProto::release_domain() {
4101   // @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.domain)
4102   clear_has_domain();
4103   return domain_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4104 }
set_allocated_domain(::std::string * domain)4105 inline void ModelProto::set_allocated_domain(::std::string* domain) {
4106   if (domain != NULL) {
4107     set_has_domain();
4108   } else {
4109     clear_has_domain();
4110   }
4111   domain_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), domain);
4112   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.domain)
4113 }
4114 
4115 // optional int64 model_version = 5;
has_model_version()4116 inline bool ModelProto::has_model_version() const {
4117   return (_has_bits_[0] & 0x00000040u) != 0;
4118 }
set_has_model_version()4119 inline void ModelProto::set_has_model_version() {
4120   _has_bits_[0] |= 0x00000040u;
4121 }
clear_has_model_version()4122 inline void ModelProto::clear_has_model_version() {
4123   _has_bits_[0] &= ~0x00000040u;
4124 }
clear_model_version()4125 inline void ModelProto::clear_model_version() {
4126   model_version_ = GOOGLE_LONGLONG(0);
4127   clear_has_model_version();
4128 }
model_version()4129 inline ::google::protobuf::int64 ModelProto::model_version() const {
4130   // @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.model_version)
4131   return model_version_;
4132 }
set_model_version(::google::protobuf::int64 value)4133 inline void ModelProto::set_model_version(::google::protobuf::int64 value) {
4134   set_has_model_version();
4135   model_version_ = value;
4136   // @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.model_version)
4137 }
4138 
4139 // optional string doc_string = 6;
has_doc_string()4140 inline bool ModelProto::has_doc_string() const {
4141   return (_has_bits_[0] & 0x00000008u) != 0;
4142 }
set_has_doc_string()4143 inline void ModelProto::set_has_doc_string() {
4144   _has_bits_[0] |= 0x00000008u;
4145 }
clear_has_doc_string()4146 inline void ModelProto::clear_has_doc_string() {
4147   _has_bits_[0] &= ~0x00000008u;
4148 }
clear_doc_string()4149 inline void ModelProto::clear_doc_string() {
4150   doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4151   clear_has_doc_string();
4152 }
doc_string()4153 inline const ::std::string& ModelProto::doc_string() const {
4154   // @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.doc_string)
4155   return doc_string_.GetNoArena();
4156 }
set_doc_string(const::std::string & value)4157 inline void ModelProto::set_doc_string(const ::std::string& value) {
4158   set_has_doc_string();
4159   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4160   // @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.doc_string)
4161 }
4162 #if LANG_CXX11
set_doc_string(::std::string && value)4163 inline void ModelProto::set_doc_string(::std::string&& value) {
4164   set_has_doc_string();
4165   doc_string_.SetNoArena(
4166     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4167   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.ModelProto.doc_string)
4168 }
4169 #endif
set_doc_string(const char * value)4170 inline void ModelProto::set_doc_string(const char* value) {
4171   GOOGLE_DCHECK(value != NULL);
4172   set_has_doc_string();
4173   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4174   // @@protoc_insertion_point(field_set_char:opencv_onnx.ModelProto.doc_string)
4175 }
set_doc_string(const char * value,size_t size)4176 inline void ModelProto::set_doc_string(const char* value, size_t size) {
4177   set_has_doc_string();
4178   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4179       ::std::string(reinterpret_cast<const char*>(value), size));
4180   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.ModelProto.doc_string)
4181 }
mutable_doc_string()4182 inline ::std::string* ModelProto::mutable_doc_string() {
4183   set_has_doc_string();
4184   // @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.doc_string)
4185   return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4186 }
release_doc_string()4187 inline ::std::string* ModelProto::release_doc_string() {
4188   // @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.doc_string)
4189   clear_has_doc_string();
4190   return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4191 }
set_allocated_doc_string(::std::string * doc_string)4192 inline void ModelProto::set_allocated_doc_string(::std::string* doc_string) {
4193   if (doc_string != NULL) {
4194     set_has_doc_string();
4195   } else {
4196     clear_has_doc_string();
4197   }
4198   doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
4199   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.doc_string)
4200 }
4201 
4202 // optional .opencv_onnx.GraphProto graph = 7;
has_graph()4203 inline bool ModelProto::has_graph() const {
4204   return (_has_bits_[0] & 0x00000010u) != 0;
4205 }
set_has_graph()4206 inline void ModelProto::set_has_graph() {
4207   _has_bits_[0] |= 0x00000010u;
4208 }
clear_has_graph()4209 inline void ModelProto::clear_has_graph() {
4210   _has_bits_[0] &= ~0x00000010u;
4211 }
clear_graph()4212 inline void ModelProto::clear_graph() {
4213   if (graph_ != NULL) graph_->Clear();
4214   clear_has_graph();
4215 }
graph()4216 inline const ::opencv_onnx::GraphProto& ModelProto::graph() const {
4217   const ::opencv_onnx::GraphProto* p = graph_;
4218   // @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.graph)
4219   return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::GraphProto*>(
4220       &::opencv_onnx::_GraphProto_default_instance_);
4221 }
release_graph()4222 inline ::opencv_onnx::GraphProto* ModelProto::release_graph() {
4223   // @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.graph)
4224   clear_has_graph();
4225   ::opencv_onnx::GraphProto* temp = graph_;
4226   graph_ = NULL;
4227   return temp;
4228 }
mutable_graph()4229 inline ::opencv_onnx::GraphProto* ModelProto::mutable_graph() {
4230   set_has_graph();
4231   if (graph_ == NULL) {
4232     graph_ = new ::opencv_onnx::GraphProto;
4233   }
4234   // @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.graph)
4235   return graph_;
4236 }
set_allocated_graph(::opencv_onnx::GraphProto * graph)4237 inline void ModelProto::set_allocated_graph(::opencv_onnx::GraphProto* graph) {
4238   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4239   if (message_arena == NULL) {
4240     delete graph_;
4241   }
4242   if (graph) {
4243     ::google::protobuf::Arena* submessage_arena = NULL;
4244     if (message_arena != submessage_arena) {
4245       graph = ::google::protobuf::internal::GetOwnedMessage(
4246           message_arena, graph, submessage_arena);
4247     }
4248     set_has_graph();
4249   } else {
4250     clear_has_graph();
4251   }
4252   graph_ = graph;
4253   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.graph)
4254 }
4255 
4256 // repeated .opencv_onnx.StringStringEntryProto metadata_props = 14;
metadata_props_size()4257 inline int ModelProto::metadata_props_size() const {
4258   return metadata_props_.size();
4259 }
clear_metadata_props()4260 inline void ModelProto::clear_metadata_props() {
4261   metadata_props_.Clear();
4262 }
metadata_props(int index)4263 inline const ::opencv_onnx::StringStringEntryProto& ModelProto::metadata_props(int index) const {
4264   // @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.metadata_props)
4265   return metadata_props_.Get(index);
4266 }
mutable_metadata_props(int index)4267 inline ::opencv_onnx::StringStringEntryProto* ModelProto::mutable_metadata_props(int index) {
4268   // @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.metadata_props)
4269   return metadata_props_.Mutable(index);
4270 }
add_metadata_props()4271 inline ::opencv_onnx::StringStringEntryProto* ModelProto::add_metadata_props() {
4272   // @@protoc_insertion_point(field_add:opencv_onnx.ModelProto.metadata_props)
4273   return metadata_props_.Add();
4274 }
4275 inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
mutable_metadata_props()4276 ModelProto::mutable_metadata_props() {
4277   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.ModelProto.metadata_props)
4278   return &metadata_props_;
4279 }
4280 inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
metadata_props()4281 ModelProto::metadata_props() const {
4282   // @@protoc_insertion_point(field_list:opencv_onnx.ModelProto.metadata_props)
4283   return metadata_props_;
4284 }
4285 
4286 // -------------------------------------------------------------------
4287 
4288 // StringStringEntryProto
4289 
4290 // optional string key = 1;
has_key()4291 inline bool StringStringEntryProto::has_key() const {
4292   return (_has_bits_[0] & 0x00000001u) != 0;
4293 }
set_has_key()4294 inline void StringStringEntryProto::set_has_key() {
4295   _has_bits_[0] |= 0x00000001u;
4296 }
clear_has_key()4297 inline void StringStringEntryProto::clear_has_key() {
4298   _has_bits_[0] &= ~0x00000001u;
4299 }
clear_key()4300 inline void StringStringEntryProto::clear_key() {
4301   key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4302   clear_has_key();
4303 }
key()4304 inline const ::std::string& StringStringEntryProto::key() const {
4305   // @@protoc_insertion_point(field_get:opencv_onnx.StringStringEntryProto.key)
4306   return key_.GetNoArena();
4307 }
set_key(const::std::string & value)4308 inline void StringStringEntryProto::set_key(const ::std::string& value) {
4309   set_has_key();
4310   key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4311   // @@protoc_insertion_point(field_set:opencv_onnx.StringStringEntryProto.key)
4312 }
4313 #if LANG_CXX11
set_key(::std::string && value)4314 inline void StringStringEntryProto::set_key(::std::string&& value) {
4315   set_has_key();
4316   key_.SetNoArena(
4317     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4318   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.StringStringEntryProto.key)
4319 }
4320 #endif
set_key(const char * value)4321 inline void StringStringEntryProto::set_key(const char* value) {
4322   GOOGLE_DCHECK(value != NULL);
4323   set_has_key();
4324   key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4325   // @@protoc_insertion_point(field_set_char:opencv_onnx.StringStringEntryProto.key)
4326 }
set_key(const char * value,size_t size)4327 inline void StringStringEntryProto::set_key(const char* value, size_t size) {
4328   set_has_key();
4329   key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4330       ::std::string(reinterpret_cast<const char*>(value), size));
4331   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.StringStringEntryProto.key)
4332 }
mutable_key()4333 inline ::std::string* StringStringEntryProto::mutable_key() {
4334   set_has_key();
4335   // @@protoc_insertion_point(field_mutable:opencv_onnx.StringStringEntryProto.key)
4336   return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4337 }
release_key()4338 inline ::std::string* StringStringEntryProto::release_key() {
4339   // @@protoc_insertion_point(field_release:opencv_onnx.StringStringEntryProto.key)
4340   clear_has_key();
4341   return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4342 }
set_allocated_key(::std::string * key)4343 inline void StringStringEntryProto::set_allocated_key(::std::string* key) {
4344   if (key != NULL) {
4345     set_has_key();
4346   } else {
4347     clear_has_key();
4348   }
4349   key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
4350   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.StringStringEntryProto.key)
4351 }
4352 
4353 // optional string value = 2;
has_value()4354 inline bool StringStringEntryProto::has_value() const {
4355   return (_has_bits_[0] & 0x00000002u) != 0;
4356 }
set_has_value()4357 inline void StringStringEntryProto::set_has_value() {
4358   _has_bits_[0] |= 0x00000002u;
4359 }
clear_has_value()4360 inline void StringStringEntryProto::clear_has_value() {
4361   _has_bits_[0] &= ~0x00000002u;
4362 }
clear_value()4363 inline void StringStringEntryProto::clear_value() {
4364   value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4365   clear_has_value();
4366 }
value()4367 inline const ::std::string& StringStringEntryProto::value() const {
4368   // @@protoc_insertion_point(field_get:opencv_onnx.StringStringEntryProto.value)
4369   return value_.GetNoArena();
4370 }
set_value(const::std::string & value)4371 inline void StringStringEntryProto::set_value(const ::std::string& value) {
4372   set_has_value();
4373   value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4374   // @@protoc_insertion_point(field_set:opencv_onnx.StringStringEntryProto.value)
4375 }
4376 #if LANG_CXX11
set_value(::std::string && value)4377 inline void StringStringEntryProto::set_value(::std::string&& value) {
4378   set_has_value();
4379   value_.SetNoArena(
4380     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4381   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.StringStringEntryProto.value)
4382 }
4383 #endif
set_value(const char * value)4384 inline void StringStringEntryProto::set_value(const char* value) {
4385   GOOGLE_DCHECK(value != NULL);
4386   set_has_value();
4387   value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4388   // @@protoc_insertion_point(field_set_char:opencv_onnx.StringStringEntryProto.value)
4389 }
set_value(const char * value,size_t size)4390 inline void StringStringEntryProto::set_value(const char* value, size_t size) {
4391   set_has_value();
4392   value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4393       ::std::string(reinterpret_cast<const char*>(value), size));
4394   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.StringStringEntryProto.value)
4395 }
mutable_value()4396 inline ::std::string* StringStringEntryProto::mutable_value() {
4397   set_has_value();
4398   // @@protoc_insertion_point(field_mutable:opencv_onnx.StringStringEntryProto.value)
4399   return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4400 }
release_value()4401 inline ::std::string* StringStringEntryProto::release_value() {
4402   // @@protoc_insertion_point(field_release:opencv_onnx.StringStringEntryProto.value)
4403   clear_has_value();
4404   return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4405 }
set_allocated_value(::std::string * value)4406 inline void StringStringEntryProto::set_allocated_value(::std::string* value) {
4407   if (value != NULL) {
4408     set_has_value();
4409   } else {
4410     clear_has_value();
4411   }
4412   value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4413   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.StringStringEntryProto.value)
4414 }
4415 
4416 // -------------------------------------------------------------------
4417 
4418 // GraphProto
4419 
4420 // repeated .opencv_onnx.NodeProto node = 1;
node_size()4421 inline int GraphProto::node_size() const {
4422   return node_.size();
4423 }
clear_node()4424 inline void GraphProto::clear_node() {
4425   node_.Clear();
4426 }
node(int index)4427 inline const ::opencv_onnx::NodeProto& GraphProto::node(int index) const {
4428   // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.node)
4429   return node_.Get(index);
4430 }
mutable_node(int index)4431 inline ::opencv_onnx::NodeProto* GraphProto::mutable_node(int index) {
4432   // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.node)
4433   return node_.Mutable(index);
4434 }
add_node()4435 inline ::opencv_onnx::NodeProto* GraphProto::add_node() {
4436   // @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.node)
4437   return node_.Add();
4438 }
4439 inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::NodeProto >*
mutable_node()4440 GraphProto::mutable_node() {
4441   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.node)
4442   return &node_;
4443 }
4444 inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::NodeProto >&
node()4445 GraphProto::node() const {
4446   // @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.node)
4447   return node_;
4448 }
4449 
4450 // optional string name = 2;
has_name()4451 inline bool GraphProto::has_name() const {
4452   return (_has_bits_[0] & 0x00000001u) != 0;
4453 }
set_has_name()4454 inline void GraphProto::set_has_name() {
4455   _has_bits_[0] |= 0x00000001u;
4456 }
clear_has_name()4457 inline void GraphProto::clear_has_name() {
4458   _has_bits_[0] &= ~0x00000001u;
4459 }
clear_name()4460 inline void GraphProto::clear_name() {
4461   name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4462   clear_has_name();
4463 }
name()4464 inline const ::std::string& GraphProto::name() const {
4465   // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.name)
4466   return name_.GetNoArena();
4467 }
set_name(const::std::string & value)4468 inline void GraphProto::set_name(const ::std::string& value) {
4469   set_has_name();
4470   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4471   // @@protoc_insertion_point(field_set:opencv_onnx.GraphProto.name)
4472 }
4473 #if LANG_CXX11
set_name(::std::string && value)4474 inline void GraphProto::set_name(::std::string&& value) {
4475   set_has_name();
4476   name_.SetNoArena(
4477     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4478   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.GraphProto.name)
4479 }
4480 #endif
set_name(const char * value)4481 inline void GraphProto::set_name(const char* value) {
4482   GOOGLE_DCHECK(value != NULL);
4483   set_has_name();
4484   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4485   // @@protoc_insertion_point(field_set_char:opencv_onnx.GraphProto.name)
4486 }
set_name(const char * value,size_t size)4487 inline void GraphProto::set_name(const char* value, size_t size) {
4488   set_has_name();
4489   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4490       ::std::string(reinterpret_cast<const char*>(value), size));
4491   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.GraphProto.name)
4492 }
mutable_name()4493 inline ::std::string* GraphProto::mutable_name() {
4494   set_has_name();
4495   // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.name)
4496   return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4497 }
release_name()4498 inline ::std::string* GraphProto::release_name() {
4499   // @@protoc_insertion_point(field_release:opencv_onnx.GraphProto.name)
4500   clear_has_name();
4501   return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4502 }
set_allocated_name(::std::string * name)4503 inline void GraphProto::set_allocated_name(::std::string* name) {
4504   if (name != NULL) {
4505     set_has_name();
4506   } else {
4507     clear_has_name();
4508   }
4509   name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
4510   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.GraphProto.name)
4511 }
4512 
4513 // repeated .opencv_onnx.TensorProto initializer = 5;
initializer_size()4514 inline int GraphProto::initializer_size() const {
4515   return initializer_.size();
4516 }
clear_initializer()4517 inline void GraphProto::clear_initializer() {
4518   initializer_.Clear();
4519 }
initializer(int index)4520 inline const ::opencv_onnx::TensorProto& GraphProto::initializer(int index) const {
4521   // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.initializer)
4522   return initializer_.Get(index);
4523 }
mutable_initializer(int index)4524 inline ::opencv_onnx::TensorProto* GraphProto::mutable_initializer(int index) {
4525   // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.initializer)
4526   return initializer_.Mutable(index);
4527 }
add_initializer()4528 inline ::opencv_onnx::TensorProto* GraphProto::add_initializer() {
4529   // @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.initializer)
4530   return initializer_.Add();
4531 }
4532 inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >*
mutable_initializer()4533 GraphProto::mutable_initializer() {
4534   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.initializer)
4535   return &initializer_;
4536 }
4537 inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >&
initializer()4538 GraphProto::initializer() const {
4539   // @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.initializer)
4540   return initializer_;
4541 }
4542 
4543 // optional string doc_string = 10;
has_doc_string()4544 inline bool GraphProto::has_doc_string() const {
4545   return (_has_bits_[0] & 0x00000002u) != 0;
4546 }
set_has_doc_string()4547 inline void GraphProto::set_has_doc_string() {
4548   _has_bits_[0] |= 0x00000002u;
4549 }
clear_has_doc_string()4550 inline void GraphProto::clear_has_doc_string() {
4551   _has_bits_[0] &= ~0x00000002u;
4552 }
clear_doc_string()4553 inline void GraphProto::clear_doc_string() {
4554   doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4555   clear_has_doc_string();
4556 }
doc_string()4557 inline const ::std::string& GraphProto::doc_string() const {
4558   // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.doc_string)
4559   return doc_string_.GetNoArena();
4560 }
set_doc_string(const::std::string & value)4561 inline void GraphProto::set_doc_string(const ::std::string& value) {
4562   set_has_doc_string();
4563   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4564   // @@protoc_insertion_point(field_set:opencv_onnx.GraphProto.doc_string)
4565 }
4566 #if LANG_CXX11
set_doc_string(::std::string && value)4567 inline void GraphProto::set_doc_string(::std::string&& value) {
4568   set_has_doc_string();
4569   doc_string_.SetNoArena(
4570     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4571   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.GraphProto.doc_string)
4572 }
4573 #endif
set_doc_string(const char * value)4574 inline void GraphProto::set_doc_string(const char* value) {
4575   GOOGLE_DCHECK(value != NULL);
4576   set_has_doc_string();
4577   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4578   // @@protoc_insertion_point(field_set_char:opencv_onnx.GraphProto.doc_string)
4579 }
set_doc_string(const char * value,size_t size)4580 inline void GraphProto::set_doc_string(const char* value, size_t size) {
4581   set_has_doc_string();
4582   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4583       ::std::string(reinterpret_cast<const char*>(value), size));
4584   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.GraphProto.doc_string)
4585 }
mutable_doc_string()4586 inline ::std::string* GraphProto::mutable_doc_string() {
4587   set_has_doc_string();
4588   // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.doc_string)
4589   return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4590 }
release_doc_string()4591 inline ::std::string* GraphProto::release_doc_string() {
4592   // @@protoc_insertion_point(field_release:opencv_onnx.GraphProto.doc_string)
4593   clear_has_doc_string();
4594   return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4595 }
set_allocated_doc_string(::std::string * doc_string)4596 inline void GraphProto::set_allocated_doc_string(::std::string* doc_string) {
4597   if (doc_string != NULL) {
4598     set_has_doc_string();
4599   } else {
4600     clear_has_doc_string();
4601   }
4602   doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
4603   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.GraphProto.doc_string)
4604 }
4605 
4606 // repeated .opencv_onnx.ValueInfoProto input = 11;
input_size()4607 inline int GraphProto::input_size() const {
4608   return input_.size();
4609 }
clear_input()4610 inline void GraphProto::clear_input() {
4611   input_.Clear();
4612 }
input(int index)4613 inline const ::opencv_onnx::ValueInfoProto& GraphProto::input(int index) const {
4614   // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.input)
4615   return input_.Get(index);
4616 }
mutable_input(int index)4617 inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_input(int index) {
4618   // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.input)
4619   return input_.Mutable(index);
4620 }
add_input()4621 inline ::opencv_onnx::ValueInfoProto* GraphProto::add_input() {
4622   // @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.input)
4623   return input_.Add();
4624 }
4625 inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
mutable_input()4626 GraphProto::mutable_input() {
4627   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.input)
4628   return &input_;
4629 }
4630 inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
input()4631 GraphProto::input() const {
4632   // @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.input)
4633   return input_;
4634 }
4635 
4636 // repeated .opencv_onnx.ValueInfoProto output = 12;
output_size()4637 inline int GraphProto::output_size() const {
4638   return output_.size();
4639 }
clear_output()4640 inline void GraphProto::clear_output() {
4641   output_.Clear();
4642 }
output(int index)4643 inline const ::opencv_onnx::ValueInfoProto& GraphProto::output(int index) const {
4644   // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.output)
4645   return output_.Get(index);
4646 }
mutable_output(int index)4647 inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_output(int index) {
4648   // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.output)
4649   return output_.Mutable(index);
4650 }
add_output()4651 inline ::opencv_onnx::ValueInfoProto* GraphProto::add_output() {
4652   // @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.output)
4653   return output_.Add();
4654 }
4655 inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
mutable_output()4656 GraphProto::mutable_output() {
4657   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.output)
4658   return &output_;
4659 }
4660 inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
output()4661 GraphProto::output() const {
4662   // @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.output)
4663   return output_;
4664 }
4665 
4666 // repeated .opencv_onnx.ValueInfoProto value_info = 13;
value_info_size()4667 inline int GraphProto::value_info_size() const {
4668   return value_info_.size();
4669 }
clear_value_info()4670 inline void GraphProto::clear_value_info() {
4671   value_info_.Clear();
4672 }
value_info(int index)4673 inline const ::opencv_onnx::ValueInfoProto& GraphProto::value_info(int index) const {
4674   // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.value_info)
4675   return value_info_.Get(index);
4676 }
mutable_value_info(int index)4677 inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_value_info(int index) {
4678   // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.value_info)
4679   return value_info_.Mutable(index);
4680 }
add_value_info()4681 inline ::opencv_onnx::ValueInfoProto* GraphProto::add_value_info() {
4682   // @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.value_info)
4683   return value_info_.Add();
4684 }
4685 inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
mutable_value_info()4686 GraphProto::mutable_value_info() {
4687   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.value_info)
4688   return &value_info_;
4689 }
4690 inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
value_info()4691 GraphProto::value_info() const {
4692   // @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.value_info)
4693   return value_info_;
4694 }
4695 
4696 // -------------------------------------------------------------------
4697 
4698 // TensorProto_Segment
4699 
4700 // optional int64 begin = 1;
has_begin()4701 inline bool TensorProto_Segment::has_begin() const {
4702   return (_has_bits_[0] & 0x00000001u) != 0;
4703 }
set_has_begin()4704 inline void TensorProto_Segment::set_has_begin() {
4705   _has_bits_[0] |= 0x00000001u;
4706 }
clear_has_begin()4707 inline void TensorProto_Segment::clear_has_begin() {
4708   _has_bits_[0] &= ~0x00000001u;
4709 }
clear_begin()4710 inline void TensorProto_Segment::clear_begin() {
4711   begin_ = GOOGLE_LONGLONG(0);
4712   clear_has_begin();
4713 }
begin()4714 inline ::google::protobuf::int64 TensorProto_Segment::begin() const {
4715   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.Segment.begin)
4716   return begin_;
4717 }
set_begin(::google::protobuf::int64 value)4718 inline void TensorProto_Segment::set_begin(::google::protobuf::int64 value) {
4719   set_has_begin();
4720   begin_ = value;
4721   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.Segment.begin)
4722 }
4723 
4724 // optional int64 end = 2;
has_end()4725 inline bool TensorProto_Segment::has_end() const {
4726   return (_has_bits_[0] & 0x00000002u) != 0;
4727 }
set_has_end()4728 inline void TensorProto_Segment::set_has_end() {
4729   _has_bits_[0] |= 0x00000002u;
4730 }
clear_has_end()4731 inline void TensorProto_Segment::clear_has_end() {
4732   _has_bits_[0] &= ~0x00000002u;
4733 }
clear_end()4734 inline void TensorProto_Segment::clear_end() {
4735   end_ = GOOGLE_LONGLONG(0);
4736   clear_has_end();
4737 }
end()4738 inline ::google::protobuf::int64 TensorProto_Segment::end() const {
4739   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.Segment.end)
4740   return end_;
4741 }
set_end(::google::protobuf::int64 value)4742 inline void TensorProto_Segment::set_end(::google::protobuf::int64 value) {
4743   set_has_end();
4744   end_ = value;
4745   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.Segment.end)
4746 }
4747 
4748 // -------------------------------------------------------------------
4749 
4750 // TensorProto
4751 
4752 // repeated int64 dims = 1;
dims_size()4753 inline int TensorProto::dims_size() const {
4754   return dims_.size();
4755 }
clear_dims()4756 inline void TensorProto::clear_dims() {
4757   dims_.Clear();
4758 }
dims(int index)4759 inline ::google::protobuf::int64 TensorProto::dims(int index) const {
4760   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.dims)
4761   return dims_.Get(index);
4762 }
set_dims(int index,::google::protobuf::int64 value)4763 inline void TensorProto::set_dims(int index, ::google::protobuf::int64 value) {
4764   dims_.Set(index, value);
4765   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.dims)
4766 }
add_dims(::google::protobuf::int64 value)4767 inline void TensorProto::add_dims(::google::protobuf::int64 value) {
4768   dims_.Add(value);
4769   // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.dims)
4770 }
4771 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
dims()4772 TensorProto::dims() const {
4773   // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.dims)
4774   return dims_;
4775 }
4776 inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
mutable_dims()4777 TensorProto::mutable_dims() {
4778   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.dims)
4779   return &dims_;
4780 }
4781 
4782 // optional .opencv_onnx.TensorProto.DataType data_type = 2;
has_data_type()4783 inline bool TensorProto::has_data_type() const {
4784   return (_has_bits_[0] & 0x00000010u) != 0;
4785 }
set_has_data_type()4786 inline void TensorProto::set_has_data_type() {
4787   _has_bits_[0] |= 0x00000010u;
4788 }
clear_has_data_type()4789 inline void TensorProto::clear_has_data_type() {
4790   _has_bits_[0] &= ~0x00000010u;
4791 }
clear_data_type()4792 inline void TensorProto::clear_data_type() {
4793   data_type_ = 0;
4794   clear_has_data_type();
4795 }
data_type()4796 inline ::opencv_onnx::TensorProto_DataType TensorProto::data_type() const {
4797   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.data_type)
4798   return static_cast< ::opencv_onnx::TensorProto_DataType >(data_type_);
4799 }
set_data_type(::opencv_onnx::TensorProto_DataType value)4800 inline void TensorProto::set_data_type(::opencv_onnx::TensorProto_DataType value) {
4801   assert(::opencv_onnx::TensorProto_DataType_IsValid(value));
4802   set_has_data_type();
4803   data_type_ = value;
4804   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.data_type)
4805 }
4806 
4807 // optional .opencv_onnx.TensorProto.Segment segment = 3;
has_segment()4808 inline bool TensorProto::has_segment() const {
4809   return (_has_bits_[0] & 0x00000008u) != 0;
4810 }
set_has_segment()4811 inline void TensorProto::set_has_segment() {
4812   _has_bits_[0] |= 0x00000008u;
4813 }
clear_has_segment()4814 inline void TensorProto::clear_has_segment() {
4815   _has_bits_[0] &= ~0x00000008u;
4816 }
clear_segment()4817 inline void TensorProto::clear_segment() {
4818   if (segment_ != NULL) segment_->Clear();
4819   clear_has_segment();
4820 }
segment()4821 inline const ::opencv_onnx::TensorProto_Segment& TensorProto::segment() const {
4822   const ::opencv_onnx::TensorProto_Segment* p = segment_;
4823   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.segment)
4824   return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::TensorProto_Segment*>(
4825       &::opencv_onnx::_TensorProto_Segment_default_instance_);
4826 }
release_segment()4827 inline ::opencv_onnx::TensorProto_Segment* TensorProto::release_segment() {
4828   // @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.segment)
4829   clear_has_segment();
4830   ::opencv_onnx::TensorProto_Segment* temp = segment_;
4831   segment_ = NULL;
4832   return temp;
4833 }
mutable_segment()4834 inline ::opencv_onnx::TensorProto_Segment* TensorProto::mutable_segment() {
4835   set_has_segment();
4836   if (segment_ == NULL) {
4837     segment_ = new ::opencv_onnx::TensorProto_Segment;
4838   }
4839   // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.segment)
4840   return segment_;
4841 }
set_allocated_segment(::opencv_onnx::TensorProto_Segment * segment)4842 inline void TensorProto::set_allocated_segment(::opencv_onnx::TensorProto_Segment* segment) {
4843   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4844   if (message_arena == NULL) {
4845     delete segment_;
4846   }
4847   if (segment) {
4848     ::google::protobuf::Arena* submessage_arena = NULL;
4849     if (message_arena != submessage_arena) {
4850       segment = ::google::protobuf::internal::GetOwnedMessage(
4851           message_arena, segment, submessage_arena);
4852     }
4853     set_has_segment();
4854   } else {
4855     clear_has_segment();
4856   }
4857   segment_ = segment;
4858   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.segment)
4859 }
4860 
4861 // repeated float float_data = 4 [packed = true];
float_data_size()4862 inline int TensorProto::float_data_size() const {
4863   return float_data_.size();
4864 }
clear_float_data()4865 inline void TensorProto::clear_float_data() {
4866   float_data_.Clear();
4867 }
float_data(int index)4868 inline float TensorProto::float_data(int index) const {
4869   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.float_data)
4870   return float_data_.Get(index);
4871 }
set_float_data(int index,float value)4872 inline void TensorProto::set_float_data(int index, float value) {
4873   float_data_.Set(index, value);
4874   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.float_data)
4875 }
add_float_data(float value)4876 inline void TensorProto::add_float_data(float value) {
4877   float_data_.Add(value);
4878   // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.float_data)
4879 }
4880 inline const ::google::protobuf::RepeatedField< float >&
float_data()4881 TensorProto::float_data() const {
4882   // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.float_data)
4883   return float_data_;
4884 }
4885 inline ::google::protobuf::RepeatedField< float >*
mutable_float_data()4886 TensorProto::mutable_float_data() {
4887   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.float_data)
4888   return &float_data_;
4889 }
4890 
4891 // repeated int32 int32_data = 5 [packed = true];
int32_data_size()4892 inline int TensorProto::int32_data_size() const {
4893   return int32_data_.size();
4894 }
clear_int32_data()4895 inline void TensorProto::clear_int32_data() {
4896   int32_data_.Clear();
4897 }
int32_data(int index)4898 inline ::google::protobuf::int32 TensorProto::int32_data(int index) const {
4899   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.int32_data)
4900   return int32_data_.Get(index);
4901 }
set_int32_data(int index,::google::protobuf::int32 value)4902 inline void TensorProto::set_int32_data(int index, ::google::protobuf::int32 value) {
4903   int32_data_.Set(index, value);
4904   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.int32_data)
4905 }
add_int32_data(::google::protobuf::int32 value)4906 inline void TensorProto::add_int32_data(::google::protobuf::int32 value) {
4907   int32_data_.Add(value);
4908   // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.int32_data)
4909 }
4910 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
int32_data()4911 TensorProto::int32_data() const {
4912   // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.int32_data)
4913   return int32_data_;
4914 }
4915 inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
mutable_int32_data()4916 TensorProto::mutable_int32_data() {
4917   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.int32_data)
4918   return &int32_data_;
4919 }
4920 
4921 // repeated bytes string_data = 6;
string_data_size()4922 inline int TensorProto::string_data_size() const {
4923   return string_data_.size();
4924 }
clear_string_data()4925 inline void TensorProto::clear_string_data() {
4926   string_data_.Clear();
4927 }
string_data(int index)4928 inline const ::std::string& TensorProto::string_data(int index) const {
4929   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.string_data)
4930   return string_data_.Get(index);
4931 }
mutable_string_data(int index)4932 inline ::std::string* TensorProto::mutable_string_data(int index) {
4933   // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.string_data)
4934   return string_data_.Mutable(index);
4935 }
set_string_data(int index,const::std::string & value)4936 inline void TensorProto::set_string_data(int index, const ::std::string& value) {
4937   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.string_data)
4938   string_data_.Mutable(index)->assign(value);
4939 }
4940 #if LANG_CXX11
set_string_data(int index,::std::string && value)4941 inline void TensorProto::set_string_data(int index, ::std::string&& value) {
4942   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.string_data)
4943   string_data_.Mutable(index)->assign(std::move(value));
4944 }
4945 #endif
set_string_data(int index,const char * value)4946 inline void TensorProto::set_string_data(int index, const char* value) {
4947   GOOGLE_DCHECK(value != NULL);
4948   string_data_.Mutable(index)->assign(value);
4949   // @@protoc_insertion_point(field_set_char:opencv_onnx.TensorProto.string_data)
4950 }
set_string_data(int index,const void * value,size_t size)4951 inline void TensorProto::set_string_data(int index, const void* value, size_t size) {
4952   string_data_.Mutable(index)->assign(
4953     reinterpret_cast<const char*>(value), size);
4954   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorProto.string_data)
4955 }
add_string_data()4956 inline ::std::string* TensorProto::add_string_data() {
4957   // @@protoc_insertion_point(field_add_mutable:opencv_onnx.TensorProto.string_data)
4958   return string_data_.Add();
4959 }
add_string_data(const::std::string & value)4960 inline void TensorProto::add_string_data(const ::std::string& value) {
4961   string_data_.Add()->assign(value);
4962   // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.string_data)
4963 }
4964 #if LANG_CXX11
add_string_data(::std::string && value)4965 inline void TensorProto::add_string_data(::std::string&& value) {
4966   string_data_.Add(std::move(value));
4967   // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.string_data)
4968 }
4969 #endif
add_string_data(const char * value)4970 inline void TensorProto::add_string_data(const char* value) {
4971   GOOGLE_DCHECK(value != NULL);
4972   string_data_.Add()->assign(value);
4973   // @@protoc_insertion_point(field_add_char:opencv_onnx.TensorProto.string_data)
4974 }
add_string_data(const void * value,size_t size)4975 inline void TensorProto::add_string_data(const void* value, size_t size) {
4976   string_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
4977   // @@protoc_insertion_point(field_add_pointer:opencv_onnx.TensorProto.string_data)
4978 }
4979 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
string_data()4980 TensorProto::string_data() const {
4981   // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.string_data)
4982   return string_data_;
4983 }
4984 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
mutable_string_data()4985 TensorProto::mutable_string_data() {
4986   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.string_data)
4987   return &string_data_;
4988 }
4989 
4990 // repeated int64 int64_data = 7 [packed = true];
int64_data_size()4991 inline int TensorProto::int64_data_size() const {
4992   return int64_data_.size();
4993 }
clear_int64_data()4994 inline void TensorProto::clear_int64_data() {
4995   int64_data_.Clear();
4996 }
int64_data(int index)4997 inline ::google::protobuf::int64 TensorProto::int64_data(int index) const {
4998   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.int64_data)
4999   return int64_data_.Get(index);
5000 }
set_int64_data(int index,::google::protobuf::int64 value)5001 inline void TensorProto::set_int64_data(int index, ::google::protobuf::int64 value) {
5002   int64_data_.Set(index, value);
5003   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.int64_data)
5004 }
add_int64_data(::google::protobuf::int64 value)5005 inline void TensorProto::add_int64_data(::google::protobuf::int64 value) {
5006   int64_data_.Add(value);
5007   // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.int64_data)
5008 }
5009 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
int64_data()5010 TensorProto::int64_data() const {
5011   // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.int64_data)
5012   return int64_data_;
5013 }
5014 inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
mutable_int64_data()5015 TensorProto::mutable_int64_data() {
5016   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.int64_data)
5017   return &int64_data_;
5018 }
5019 
5020 // optional string name = 8;
has_name()5021 inline bool TensorProto::has_name() const {
5022   return (_has_bits_[0] & 0x00000001u) != 0;
5023 }
set_has_name()5024 inline void TensorProto::set_has_name() {
5025   _has_bits_[0] |= 0x00000001u;
5026 }
clear_has_name()5027 inline void TensorProto::clear_has_name() {
5028   _has_bits_[0] &= ~0x00000001u;
5029 }
clear_name()5030 inline void TensorProto::clear_name() {
5031   name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5032   clear_has_name();
5033 }
name()5034 inline const ::std::string& TensorProto::name() const {
5035   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.name)
5036   return name_.GetNoArena();
5037 }
set_name(const::std::string & value)5038 inline void TensorProto::set_name(const ::std::string& value) {
5039   set_has_name();
5040   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5041   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.name)
5042 }
5043 #if LANG_CXX11
set_name(::std::string && value)5044 inline void TensorProto::set_name(::std::string&& value) {
5045   set_has_name();
5046   name_.SetNoArena(
5047     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5048   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorProto.name)
5049 }
5050 #endif
set_name(const char * value)5051 inline void TensorProto::set_name(const char* value) {
5052   GOOGLE_DCHECK(value != NULL);
5053   set_has_name();
5054   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5055   // @@protoc_insertion_point(field_set_char:opencv_onnx.TensorProto.name)
5056 }
set_name(const char * value,size_t size)5057 inline void TensorProto::set_name(const char* value, size_t size) {
5058   set_has_name();
5059   name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5060       ::std::string(reinterpret_cast<const char*>(value), size));
5061   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorProto.name)
5062 }
mutable_name()5063 inline ::std::string* TensorProto::mutable_name() {
5064   set_has_name();
5065   // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.name)
5066   return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5067 }
release_name()5068 inline ::std::string* TensorProto::release_name() {
5069   // @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.name)
5070   clear_has_name();
5071   return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5072 }
set_allocated_name(::std::string * name)5073 inline void TensorProto::set_allocated_name(::std::string* name) {
5074   if (name != NULL) {
5075     set_has_name();
5076   } else {
5077     clear_has_name();
5078   }
5079   name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
5080   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.name)
5081 }
5082 
5083 // optional string doc_string = 12;
has_doc_string()5084 inline bool TensorProto::has_doc_string() const {
5085   return (_has_bits_[0] & 0x00000004u) != 0;
5086 }
set_has_doc_string()5087 inline void TensorProto::set_has_doc_string() {
5088   _has_bits_[0] |= 0x00000004u;
5089 }
clear_has_doc_string()5090 inline void TensorProto::clear_has_doc_string() {
5091   _has_bits_[0] &= ~0x00000004u;
5092 }
clear_doc_string()5093 inline void TensorProto::clear_doc_string() {
5094   doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5095   clear_has_doc_string();
5096 }
doc_string()5097 inline const ::std::string& TensorProto::doc_string() const {
5098   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.doc_string)
5099   return doc_string_.GetNoArena();
5100 }
set_doc_string(const::std::string & value)5101 inline void TensorProto::set_doc_string(const ::std::string& value) {
5102   set_has_doc_string();
5103   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5104   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.doc_string)
5105 }
5106 #if LANG_CXX11
set_doc_string(::std::string && value)5107 inline void TensorProto::set_doc_string(::std::string&& value) {
5108   set_has_doc_string();
5109   doc_string_.SetNoArena(
5110     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5111   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorProto.doc_string)
5112 }
5113 #endif
set_doc_string(const char * value)5114 inline void TensorProto::set_doc_string(const char* value) {
5115   GOOGLE_DCHECK(value != NULL);
5116   set_has_doc_string();
5117   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5118   // @@protoc_insertion_point(field_set_char:opencv_onnx.TensorProto.doc_string)
5119 }
set_doc_string(const char * value,size_t size)5120 inline void TensorProto::set_doc_string(const char* value, size_t size) {
5121   set_has_doc_string();
5122   doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5123       ::std::string(reinterpret_cast<const char*>(value), size));
5124   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorProto.doc_string)
5125 }
mutable_doc_string()5126 inline ::std::string* TensorProto::mutable_doc_string() {
5127   set_has_doc_string();
5128   // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.doc_string)
5129   return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5130 }
release_doc_string()5131 inline ::std::string* TensorProto::release_doc_string() {
5132   // @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.doc_string)
5133   clear_has_doc_string();
5134   return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5135 }
set_allocated_doc_string(::std::string * doc_string)5136 inline void TensorProto::set_allocated_doc_string(::std::string* doc_string) {
5137   if (doc_string != NULL) {
5138     set_has_doc_string();
5139   } else {
5140     clear_has_doc_string();
5141   }
5142   doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
5143   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.doc_string)
5144 }
5145 
5146 // optional bytes raw_data = 9;
has_raw_data()5147 inline bool TensorProto::has_raw_data() const {
5148   return (_has_bits_[0] & 0x00000002u) != 0;
5149 }
set_has_raw_data()5150 inline void TensorProto::set_has_raw_data() {
5151   _has_bits_[0] |= 0x00000002u;
5152 }
clear_has_raw_data()5153 inline void TensorProto::clear_has_raw_data() {
5154   _has_bits_[0] &= ~0x00000002u;
5155 }
clear_raw_data()5156 inline void TensorProto::clear_raw_data() {
5157   raw_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5158   clear_has_raw_data();
5159 }
raw_data()5160 inline const ::std::string& TensorProto::raw_data() const {
5161   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.raw_data)
5162   return raw_data_.GetNoArena();
5163 }
set_raw_data(const::std::string & value)5164 inline void TensorProto::set_raw_data(const ::std::string& value) {
5165   set_has_raw_data();
5166   raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5167   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.raw_data)
5168 }
5169 #if LANG_CXX11
set_raw_data(::std::string && value)5170 inline void TensorProto::set_raw_data(::std::string&& value) {
5171   set_has_raw_data();
5172   raw_data_.SetNoArena(
5173     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5174   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorProto.raw_data)
5175 }
5176 #endif
set_raw_data(const char * value)5177 inline void TensorProto::set_raw_data(const char* value) {
5178   GOOGLE_DCHECK(value != NULL);
5179   set_has_raw_data();
5180   raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5181   // @@protoc_insertion_point(field_set_char:opencv_onnx.TensorProto.raw_data)
5182 }
set_raw_data(const void * value,size_t size)5183 inline void TensorProto::set_raw_data(const void* value, size_t size) {
5184   set_has_raw_data();
5185   raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5186       ::std::string(reinterpret_cast<const char*>(value), size));
5187   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorProto.raw_data)
5188 }
mutable_raw_data()5189 inline ::std::string* TensorProto::mutable_raw_data() {
5190   set_has_raw_data();
5191   // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.raw_data)
5192   return raw_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5193 }
release_raw_data()5194 inline ::std::string* TensorProto::release_raw_data() {
5195   // @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.raw_data)
5196   clear_has_raw_data();
5197   return raw_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5198 }
set_allocated_raw_data(::std::string * raw_data)5199 inline void TensorProto::set_allocated_raw_data(::std::string* raw_data) {
5200   if (raw_data != NULL) {
5201     set_has_raw_data();
5202   } else {
5203     clear_has_raw_data();
5204   }
5205   raw_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), raw_data);
5206   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.raw_data)
5207 }
5208 
5209 // repeated double double_data = 10 [packed = true];
double_data_size()5210 inline int TensorProto::double_data_size() const {
5211   return double_data_.size();
5212 }
clear_double_data()5213 inline void TensorProto::clear_double_data() {
5214   double_data_.Clear();
5215 }
double_data(int index)5216 inline double TensorProto::double_data(int index) const {
5217   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.double_data)
5218   return double_data_.Get(index);
5219 }
set_double_data(int index,double value)5220 inline void TensorProto::set_double_data(int index, double value) {
5221   double_data_.Set(index, value);
5222   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.double_data)
5223 }
add_double_data(double value)5224 inline void TensorProto::add_double_data(double value) {
5225   double_data_.Add(value);
5226   // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.double_data)
5227 }
5228 inline const ::google::protobuf::RepeatedField< double >&
double_data()5229 TensorProto::double_data() const {
5230   // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.double_data)
5231   return double_data_;
5232 }
5233 inline ::google::protobuf::RepeatedField< double >*
mutable_double_data()5234 TensorProto::mutable_double_data() {
5235   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.double_data)
5236   return &double_data_;
5237 }
5238 
5239 // repeated uint64 uint64_data = 11 [packed = true];
uint64_data_size()5240 inline int TensorProto::uint64_data_size() const {
5241   return uint64_data_.size();
5242 }
clear_uint64_data()5243 inline void TensorProto::clear_uint64_data() {
5244   uint64_data_.Clear();
5245 }
uint64_data(int index)5246 inline ::google::protobuf::uint64 TensorProto::uint64_data(int index) const {
5247   // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.uint64_data)
5248   return uint64_data_.Get(index);
5249 }
set_uint64_data(int index,::google::protobuf::uint64 value)5250 inline void TensorProto::set_uint64_data(int index, ::google::protobuf::uint64 value) {
5251   uint64_data_.Set(index, value);
5252   // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.uint64_data)
5253 }
add_uint64_data(::google::protobuf::uint64 value)5254 inline void TensorProto::add_uint64_data(::google::protobuf::uint64 value) {
5255   uint64_data_.Add(value);
5256   // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.uint64_data)
5257 }
5258 inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
uint64_data()5259 TensorProto::uint64_data() const {
5260   // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.uint64_data)
5261   return uint64_data_;
5262 }
5263 inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
mutable_uint64_data()5264 TensorProto::mutable_uint64_data() {
5265   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.uint64_data)
5266   return &uint64_data_;
5267 }
5268 
5269 // -------------------------------------------------------------------
5270 
5271 // TensorShapeProto_Dimension
5272 
5273 // optional int64 dim_value = 1;
has_dim_value()5274 inline bool TensorShapeProto_Dimension::has_dim_value() const {
5275   return value_case() == kDimValue;
5276 }
set_has_dim_value()5277 inline void TensorShapeProto_Dimension::set_has_dim_value() {
5278   _oneof_case_[0] = kDimValue;
5279 }
clear_dim_value()5280 inline void TensorShapeProto_Dimension::clear_dim_value() {
5281   if (has_dim_value()) {
5282     value_.dim_value_ = GOOGLE_LONGLONG(0);
5283     clear_has_value();
5284   }
5285 }
dim_value()5286 inline ::google::protobuf::int64 TensorShapeProto_Dimension::dim_value() const {
5287   // @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.dim_value)
5288   if (has_dim_value()) {
5289     return value_.dim_value_;
5290   }
5291   return GOOGLE_LONGLONG(0);
5292 }
set_dim_value(::google::protobuf::int64 value)5293 inline void TensorShapeProto_Dimension::set_dim_value(::google::protobuf::int64 value) {
5294   if (!has_dim_value()) {
5295     clear_value();
5296     set_has_dim_value();
5297   }
5298   value_.dim_value_ = value;
5299   // @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_value)
5300 }
5301 
5302 // optional string dim_param = 2;
has_dim_param()5303 inline bool TensorShapeProto_Dimension::has_dim_param() const {
5304   return value_case() == kDimParam;
5305 }
set_has_dim_param()5306 inline void TensorShapeProto_Dimension::set_has_dim_param() {
5307   _oneof_case_[0] = kDimParam;
5308 }
clear_dim_param()5309 inline void TensorShapeProto_Dimension::clear_dim_param() {
5310   if (has_dim_param()) {
5311     value_.dim_param_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5312     clear_has_value();
5313   }
5314 }
dim_param()5315 inline const ::std::string& TensorShapeProto_Dimension::dim_param() const {
5316   // @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5317   if (has_dim_param()) {
5318     return value_.dim_param_.GetNoArena();
5319   }
5320   return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
5321 }
set_dim_param(const::std::string & value)5322 inline void TensorShapeProto_Dimension::set_dim_param(const ::std::string& value) {
5323   // @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5324   if (!has_dim_param()) {
5325     clear_value();
5326     set_has_dim_param();
5327     value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5328   }
5329   value_.dim_param_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5330   // @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5331 }
5332 #if LANG_CXX11
set_dim_param(::std::string && value)5333 inline void TensorShapeProto_Dimension::set_dim_param(::std::string&& value) {
5334   // @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5335   if (!has_dim_param()) {
5336     clear_value();
5337     set_has_dim_param();
5338     value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5339   }
5340   value_.dim_param_.SetNoArena(
5341     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5342   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5343 }
5344 #endif
set_dim_param(const char * value)5345 inline void TensorShapeProto_Dimension::set_dim_param(const char* value) {
5346   GOOGLE_DCHECK(value != NULL);
5347   if (!has_dim_param()) {
5348     clear_value();
5349     set_has_dim_param();
5350     value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5351   }
5352   value_.dim_param_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5353       ::std::string(value));
5354   // @@protoc_insertion_point(field_set_char:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5355 }
set_dim_param(const char * value,size_t size)5356 inline void TensorShapeProto_Dimension::set_dim_param(const char* value, size_t size) {
5357   if (!has_dim_param()) {
5358     clear_value();
5359     set_has_dim_param();
5360     value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5361   }
5362   value_.dim_param_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
5363       reinterpret_cast<const char*>(value), size));
5364   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5365 }
mutable_dim_param()5366 inline ::std::string* TensorShapeProto_Dimension::mutable_dim_param() {
5367   if (!has_dim_param()) {
5368     clear_value();
5369     set_has_dim_param();
5370     value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5371   }
5372   // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5373   return value_.dim_param_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5374 }
release_dim_param()5375 inline ::std::string* TensorShapeProto_Dimension::release_dim_param() {
5376   // @@protoc_insertion_point(field_release:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5377   if (has_dim_param()) {
5378     clear_has_value();
5379     return value_.dim_param_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5380   } else {
5381     return NULL;
5382   }
5383 }
set_allocated_dim_param(::std::string * dim_param)5384 inline void TensorShapeProto_Dimension::set_allocated_dim_param(::std::string* dim_param) {
5385   if (!has_dim_param()) {
5386     value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5387   }
5388   clear_value();
5389   if (dim_param != NULL) {
5390     set_has_dim_param();
5391     value_.dim_param_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5392         dim_param);
5393   }
5394   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5395 }
5396 
5397 // optional string denotation = 3;
has_denotation()5398 inline bool TensorShapeProto_Dimension::has_denotation() const {
5399   return (_has_bits_[0] & 0x00000001u) != 0;
5400 }
set_has_denotation()5401 inline void TensorShapeProto_Dimension::set_has_denotation() {
5402   _has_bits_[0] |= 0x00000001u;
5403 }
clear_has_denotation()5404 inline void TensorShapeProto_Dimension::clear_has_denotation() {
5405   _has_bits_[0] &= ~0x00000001u;
5406 }
clear_denotation()5407 inline void TensorShapeProto_Dimension::clear_denotation() {
5408   denotation_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5409   clear_has_denotation();
5410 }
denotation()5411 inline const ::std::string& TensorShapeProto_Dimension::denotation() const {
5412   // @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.denotation)
5413   return denotation_.GetNoArena();
5414 }
set_denotation(const::std::string & value)5415 inline void TensorShapeProto_Dimension::set_denotation(const ::std::string& value) {
5416   set_has_denotation();
5417   denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5418   // @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.denotation)
5419 }
5420 #if LANG_CXX11
set_denotation(::std::string && value)5421 inline void TensorShapeProto_Dimension::set_denotation(::std::string&& value) {
5422   set_has_denotation();
5423   denotation_.SetNoArena(
5424     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5425   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorShapeProto.Dimension.denotation)
5426 }
5427 #endif
set_denotation(const char * value)5428 inline void TensorShapeProto_Dimension::set_denotation(const char* value) {
5429   GOOGLE_DCHECK(value != NULL);
5430   set_has_denotation();
5431   denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5432   // @@protoc_insertion_point(field_set_char:opencv_onnx.TensorShapeProto.Dimension.denotation)
5433 }
set_denotation(const char * value,size_t size)5434 inline void TensorShapeProto_Dimension::set_denotation(const char* value, size_t size) {
5435   set_has_denotation();
5436   denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5437       ::std::string(reinterpret_cast<const char*>(value), size));
5438   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorShapeProto.Dimension.denotation)
5439 }
mutable_denotation()5440 inline ::std::string* TensorShapeProto_Dimension::mutable_denotation() {
5441   set_has_denotation();
5442   // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.Dimension.denotation)
5443   return denotation_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5444 }
release_denotation()5445 inline ::std::string* TensorShapeProto_Dimension::release_denotation() {
5446   // @@protoc_insertion_point(field_release:opencv_onnx.TensorShapeProto.Dimension.denotation)
5447   clear_has_denotation();
5448   return denotation_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5449 }
set_allocated_denotation(::std::string * denotation)5450 inline void TensorShapeProto_Dimension::set_allocated_denotation(::std::string* denotation) {
5451   if (denotation != NULL) {
5452     set_has_denotation();
5453   } else {
5454     clear_has_denotation();
5455   }
5456   denotation_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), denotation);
5457   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorShapeProto.Dimension.denotation)
5458 }
5459 
has_value()5460 inline bool TensorShapeProto_Dimension::has_value() const {
5461   return value_case() != VALUE_NOT_SET;
5462 }
clear_has_value()5463 inline void TensorShapeProto_Dimension::clear_has_value() {
5464   _oneof_case_[0] = VALUE_NOT_SET;
5465 }
value_case()5466 inline TensorShapeProto_Dimension::ValueCase TensorShapeProto_Dimension::value_case() const {
5467   return TensorShapeProto_Dimension::ValueCase(_oneof_case_[0]);
5468 }
5469 // -------------------------------------------------------------------
5470 
5471 // TensorShapeProto
5472 
5473 // repeated .opencv_onnx.TensorShapeProto.Dimension dim = 1;
dim_size()5474 inline int TensorShapeProto::dim_size() const {
5475   return dim_.size();
5476 }
clear_dim()5477 inline void TensorShapeProto::clear_dim() {
5478   dim_.Clear();
5479 }
dim(int index)5480 inline const ::opencv_onnx::TensorShapeProto_Dimension& TensorShapeProto::dim(int index) const {
5481   // @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.dim)
5482   return dim_.Get(index);
5483 }
mutable_dim(int index)5484 inline ::opencv_onnx::TensorShapeProto_Dimension* TensorShapeProto::mutable_dim(int index) {
5485   // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.dim)
5486   return dim_.Mutable(index);
5487 }
add_dim()5488 inline ::opencv_onnx::TensorShapeProto_Dimension* TensorShapeProto::add_dim() {
5489   // @@protoc_insertion_point(field_add:opencv_onnx.TensorShapeProto.dim)
5490   return dim_.Add();
5491 }
5492 inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >*
mutable_dim()5493 TensorShapeProto::mutable_dim() {
5494   // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorShapeProto.dim)
5495   return &dim_;
5496 }
5497 inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >&
dim()5498 TensorShapeProto::dim() const {
5499   // @@protoc_insertion_point(field_list:opencv_onnx.TensorShapeProto.dim)
5500   return dim_;
5501 }
5502 
5503 // -------------------------------------------------------------------
5504 
5505 // TypeProto_Tensor
5506 
5507 // optional .opencv_onnx.TensorProto.DataType elem_type = 1;
has_elem_type()5508 inline bool TypeProto_Tensor::has_elem_type() const {
5509   return (_has_bits_[0] & 0x00000002u) != 0;
5510 }
set_has_elem_type()5511 inline void TypeProto_Tensor::set_has_elem_type() {
5512   _has_bits_[0] |= 0x00000002u;
5513 }
clear_has_elem_type()5514 inline void TypeProto_Tensor::clear_has_elem_type() {
5515   _has_bits_[0] &= ~0x00000002u;
5516 }
clear_elem_type()5517 inline void TypeProto_Tensor::clear_elem_type() {
5518   elem_type_ = 0;
5519   clear_has_elem_type();
5520 }
elem_type()5521 inline ::opencv_onnx::TensorProto_DataType TypeProto_Tensor::elem_type() const {
5522   // @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Tensor.elem_type)
5523   return static_cast< ::opencv_onnx::TensorProto_DataType >(elem_type_);
5524 }
set_elem_type(::opencv_onnx::TensorProto_DataType value)5525 inline void TypeProto_Tensor::set_elem_type(::opencv_onnx::TensorProto_DataType value) {
5526   assert(::opencv_onnx::TensorProto_DataType_IsValid(value));
5527   set_has_elem_type();
5528   elem_type_ = value;
5529   // @@protoc_insertion_point(field_set:opencv_onnx.TypeProto.Tensor.elem_type)
5530 }
5531 
5532 // optional .opencv_onnx.TensorShapeProto shape = 2;
has_shape()5533 inline bool TypeProto_Tensor::has_shape() const {
5534   return (_has_bits_[0] & 0x00000001u) != 0;
5535 }
set_has_shape()5536 inline void TypeProto_Tensor::set_has_shape() {
5537   _has_bits_[0] |= 0x00000001u;
5538 }
clear_has_shape()5539 inline void TypeProto_Tensor::clear_has_shape() {
5540   _has_bits_[0] &= ~0x00000001u;
5541 }
clear_shape()5542 inline void TypeProto_Tensor::clear_shape() {
5543   if (shape_ != NULL) shape_->Clear();
5544   clear_has_shape();
5545 }
shape()5546 inline const ::opencv_onnx::TensorShapeProto& TypeProto_Tensor::shape() const {
5547   const ::opencv_onnx::TensorShapeProto* p = shape_;
5548   // @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Tensor.shape)
5549   return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::TensorShapeProto*>(
5550       &::opencv_onnx::_TensorShapeProto_default_instance_);
5551 }
release_shape()5552 inline ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::release_shape() {
5553   // @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.Tensor.shape)
5554   clear_has_shape();
5555   ::opencv_onnx::TensorShapeProto* temp = shape_;
5556   shape_ = NULL;
5557   return temp;
5558 }
mutable_shape()5559 inline ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::mutable_shape() {
5560   set_has_shape();
5561   if (shape_ == NULL) {
5562     shape_ = new ::opencv_onnx::TensorShapeProto;
5563   }
5564   // @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.Tensor.shape)
5565   return shape_;
5566 }
set_allocated_shape(::opencv_onnx::TensorShapeProto * shape)5567 inline void TypeProto_Tensor::set_allocated_shape(::opencv_onnx::TensorShapeProto* shape) {
5568   ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
5569   if (message_arena == NULL) {
5570     delete shape_;
5571   }
5572   if (shape) {
5573     ::google::protobuf::Arena* submessage_arena = NULL;
5574     if (message_arena != submessage_arena) {
5575       shape = ::google::protobuf::internal::GetOwnedMessage(
5576           message_arena, shape, submessage_arena);
5577     }
5578     set_has_shape();
5579   } else {
5580     clear_has_shape();
5581   }
5582   shape_ = shape;
5583   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.Tensor.shape)
5584 }
5585 
5586 // -------------------------------------------------------------------
5587 
5588 // TypeProto
5589 
5590 // optional .opencv_onnx.TypeProto.Tensor tensor_type = 1;
has_tensor_type()5591 inline bool TypeProto::has_tensor_type() const {
5592   return value_case() == kTensorType;
5593 }
set_has_tensor_type()5594 inline void TypeProto::set_has_tensor_type() {
5595   _oneof_case_[0] = kTensorType;
5596 }
clear_tensor_type()5597 inline void TypeProto::clear_tensor_type() {
5598   if (has_tensor_type()) {
5599     delete value_.tensor_type_;
5600     clear_has_value();
5601   }
5602 }
release_tensor_type()5603 inline ::opencv_onnx::TypeProto_Tensor* TypeProto::release_tensor_type() {
5604   // @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.tensor_type)
5605   if (has_tensor_type()) {
5606     clear_has_value();
5607       ::opencv_onnx::TypeProto_Tensor* temp = value_.tensor_type_;
5608     value_.tensor_type_ = NULL;
5609     return temp;
5610   } else {
5611     return NULL;
5612   }
5613 }
tensor_type()5614 inline const ::opencv_onnx::TypeProto_Tensor& TypeProto::tensor_type() const {
5615   // @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.tensor_type)
5616   return has_tensor_type()
5617       ? *value_.tensor_type_
5618       : *reinterpret_cast< ::opencv_onnx::TypeProto_Tensor*>(&::opencv_onnx::_TypeProto_Tensor_default_instance_);
5619 }
mutable_tensor_type()5620 inline ::opencv_onnx::TypeProto_Tensor* TypeProto::mutable_tensor_type() {
5621   if (!has_tensor_type()) {
5622     clear_value();
5623     set_has_tensor_type();
5624     value_.tensor_type_ = new ::opencv_onnx::TypeProto_Tensor;
5625   }
5626   // @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.tensor_type)
5627   return value_.tensor_type_;
5628 }
5629 
5630 // optional string denotation = 6;
has_denotation()5631 inline bool TypeProto::has_denotation() const {
5632   return (_has_bits_[0] & 0x00000001u) != 0;
5633 }
set_has_denotation()5634 inline void TypeProto::set_has_denotation() {
5635   _has_bits_[0] |= 0x00000001u;
5636 }
clear_has_denotation()5637 inline void TypeProto::clear_has_denotation() {
5638   _has_bits_[0] &= ~0x00000001u;
5639 }
clear_denotation()5640 inline void TypeProto::clear_denotation() {
5641   denotation_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5642   clear_has_denotation();
5643 }
denotation()5644 inline const ::std::string& TypeProto::denotation() const {
5645   // @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.denotation)
5646   return denotation_.GetNoArena();
5647 }
set_denotation(const::std::string & value)5648 inline void TypeProto::set_denotation(const ::std::string& value) {
5649   set_has_denotation();
5650   denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5651   // @@protoc_insertion_point(field_set:opencv_onnx.TypeProto.denotation)
5652 }
5653 #if LANG_CXX11
set_denotation(::std::string && value)5654 inline void TypeProto::set_denotation(::std::string&& value) {
5655   set_has_denotation();
5656   denotation_.SetNoArena(
5657     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5658   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TypeProto.denotation)
5659 }
5660 #endif
set_denotation(const char * value)5661 inline void TypeProto::set_denotation(const char* value) {
5662   GOOGLE_DCHECK(value != NULL);
5663   set_has_denotation();
5664   denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5665   // @@protoc_insertion_point(field_set_char:opencv_onnx.TypeProto.denotation)
5666 }
set_denotation(const char * value,size_t size)5667 inline void TypeProto::set_denotation(const char* value, size_t size) {
5668   set_has_denotation();
5669   denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5670       ::std::string(reinterpret_cast<const char*>(value), size));
5671   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TypeProto.denotation)
5672 }
mutable_denotation()5673 inline ::std::string* TypeProto::mutable_denotation() {
5674   set_has_denotation();
5675   // @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.denotation)
5676   return denotation_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5677 }
release_denotation()5678 inline ::std::string* TypeProto::release_denotation() {
5679   // @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.denotation)
5680   clear_has_denotation();
5681   return denotation_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5682 }
set_allocated_denotation(::std::string * denotation)5683 inline void TypeProto::set_allocated_denotation(::std::string* denotation) {
5684   if (denotation != NULL) {
5685     set_has_denotation();
5686   } else {
5687     clear_has_denotation();
5688   }
5689   denotation_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), denotation);
5690   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.denotation)
5691 }
5692 
has_value()5693 inline bool TypeProto::has_value() const {
5694   return value_case() != VALUE_NOT_SET;
5695 }
clear_has_value()5696 inline void TypeProto::clear_has_value() {
5697   _oneof_case_[0] = VALUE_NOT_SET;
5698 }
value_case()5699 inline TypeProto::ValueCase TypeProto::value_case() const {
5700   return TypeProto::ValueCase(_oneof_case_[0]);
5701 }
5702 // -------------------------------------------------------------------
5703 
5704 // OperatorSetIdProto
5705 
5706 // optional string domain = 1;
has_domain()5707 inline bool OperatorSetIdProto::has_domain() const {
5708   return (_has_bits_[0] & 0x00000001u) != 0;
5709 }
set_has_domain()5710 inline void OperatorSetIdProto::set_has_domain() {
5711   _has_bits_[0] |= 0x00000001u;
5712 }
clear_has_domain()5713 inline void OperatorSetIdProto::clear_has_domain() {
5714   _has_bits_[0] &= ~0x00000001u;
5715 }
clear_domain()5716 inline void OperatorSetIdProto::clear_domain() {
5717   domain_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5718   clear_has_domain();
5719 }
domain()5720 inline const ::std::string& OperatorSetIdProto::domain() const {
5721   // @@protoc_insertion_point(field_get:opencv_onnx.OperatorSetIdProto.domain)
5722   return domain_.GetNoArena();
5723 }
set_domain(const::std::string & value)5724 inline void OperatorSetIdProto::set_domain(const ::std::string& value) {
5725   set_has_domain();
5726   domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5727   // @@protoc_insertion_point(field_set:opencv_onnx.OperatorSetIdProto.domain)
5728 }
5729 #if LANG_CXX11
set_domain(::std::string && value)5730 inline void OperatorSetIdProto::set_domain(::std::string&& value) {
5731   set_has_domain();
5732   domain_.SetNoArena(
5733     &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5734   // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.OperatorSetIdProto.domain)
5735 }
5736 #endif
set_domain(const char * value)5737 inline void OperatorSetIdProto::set_domain(const char* value) {
5738   GOOGLE_DCHECK(value != NULL);
5739   set_has_domain();
5740   domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5741   // @@protoc_insertion_point(field_set_char:opencv_onnx.OperatorSetIdProto.domain)
5742 }
set_domain(const char * value,size_t size)5743 inline void OperatorSetIdProto::set_domain(const char* value, size_t size) {
5744   set_has_domain();
5745   domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5746       ::std::string(reinterpret_cast<const char*>(value), size));
5747   // @@protoc_insertion_point(field_set_pointer:opencv_onnx.OperatorSetIdProto.domain)
5748 }
mutable_domain()5749 inline ::std::string* OperatorSetIdProto::mutable_domain() {
5750   set_has_domain();
5751   // @@protoc_insertion_point(field_mutable:opencv_onnx.OperatorSetIdProto.domain)
5752   return domain_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5753 }
release_domain()5754 inline ::std::string* OperatorSetIdProto::release_domain() {
5755   // @@protoc_insertion_point(field_release:opencv_onnx.OperatorSetIdProto.domain)
5756   clear_has_domain();
5757   return domain_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5758 }
set_allocated_domain(::std::string * domain)5759 inline void OperatorSetIdProto::set_allocated_domain(::std::string* domain) {
5760   if (domain != NULL) {
5761     set_has_domain();
5762   } else {
5763     clear_has_domain();
5764   }
5765   domain_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), domain);
5766   // @@protoc_insertion_point(field_set_allocated:opencv_onnx.OperatorSetIdProto.domain)
5767 }
5768 
5769 // optional int64 version = 2;
has_version()5770 inline bool OperatorSetIdProto::has_version() const {
5771   return (_has_bits_[0] & 0x00000002u) != 0;
5772 }
set_has_version()5773 inline void OperatorSetIdProto::set_has_version() {
5774   _has_bits_[0] |= 0x00000002u;
5775 }
clear_has_version()5776 inline void OperatorSetIdProto::clear_has_version() {
5777   _has_bits_[0] &= ~0x00000002u;
5778 }
clear_version()5779 inline void OperatorSetIdProto::clear_version() {
5780   version_ = GOOGLE_LONGLONG(0);
5781   clear_has_version();
5782 }
version()5783 inline ::google::protobuf::int64 OperatorSetIdProto::version() const {
5784   // @@protoc_insertion_point(field_get:opencv_onnx.OperatorSetIdProto.version)
5785   return version_;
5786 }
set_version(::google::protobuf::int64 value)5787 inline void OperatorSetIdProto::set_version(::google::protobuf::int64 value) {
5788   set_has_version();
5789   version_ = value;
5790   // @@protoc_insertion_point(field_set:opencv_onnx.OperatorSetIdProto.version)
5791 }
5792 
5793 #ifdef __GNUC__
5794   #pragma GCC diagnostic pop
5795 #endif  // __GNUC__
5796 // -------------------------------------------------------------------
5797 
5798 // -------------------------------------------------------------------
5799 
5800 // -------------------------------------------------------------------
5801 
5802 // -------------------------------------------------------------------
5803 
5804 // -------------------------------------------------------------------
5805 
5806 // -------------------------------------------------------------------
5807 
5808 // -------------------------------------------------------------------
5809 
5810 // -------------------------------------------------------------------
5811 
5812 // -------------------------------------------------------------------
5813 
5814 // -------------------------------------------------------------------
5815 
5816 // -------------------------------------------------------------------
5817 
5818 // -------------------------------------------------------------------
5819 
5820 
5821 // @@protoc_insertion_point(namespace_scope)
5822 
5823 }  // namespace opencv_onnx
5824 
5825 namespace google {
5826 namespace protobuf {
5827 
5828 template <> struct is_proto_enum< ::opencv_onnx::AttributeProto_AttributeType> : ::google::protobuf::internal::true_type {};
5829 template <>
5830 inline const EnumDescriptor* GetEnumDescriptor< ::opencv_onnx::AttributeProto_AttributeType>() {
5831   return ::opencv_onnx::AttributeProto_AttributeType_descriptor();
5832 }
5833 template <> struct is_proto_enum< ::opencv_onnx::TensorProto_DataType> : ::google::protobuf::internal::true_type {};
5834 template <>
5835 inline const EnumDescriptor* GetEnumDescriptor< ::opencv_onnx::TensorProto_DataType>() {
5836   return ::opencv_onnx::TensorProto_DataType_descriptor();
5837 }
5838 template <> struct is_proto_enum< ::opencv_onnx::Version> : ::google::protobuf::internal::true_type {};
5839 template <>
5840 inline const EnumDescriptor* GetEnumDescriptor< ::opencv_onnx::Version>() {
5841   return ::opencv_onnx::Version_descriptor();
5842 }
5843 
5844 }  // namespace protobuf
5845 }  // namespace google
5846 
5847 // @@protoc_insertion_point(global_scope)
5848 
5849 #endif  // PROTOBUF_opencv_2donnx_2eproto__INCLUDED
5850