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