CoCalc -- opencv-onnx.pb.h

GitHub Repository: Tetragramm/opencv
Path: blob/master/modules/dnn/misc/onnx/opencv-onnx.pb.h
¹⁶³⁴⁴ views
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();
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();
144
inline const ::std::string& AttributeProto_AttributeType_Name(AttributeProto_AttributeType value) {
145
  return ::google::protobuf::internal::NameOfEnum(
146
    AttributeProto_AttributeType_descriptor(), value);
147
}
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();
177
inline const ::std::string& TensorProto_DataType_Name(TensorProto_DataType value) {
178
  return ::google::protobuf::internal::NameOfEnum(
179
    TensorProto_DataType_descriptor(), value);
180
}
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();
198
inline const ::std::string& Version_Name(Version value) {
199
  return ::google::protobuf::internal::NameOfEnum(
200
    Version_descriptor(), value);
201
}
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
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
235
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
236
    return _internal_metadata_.unknown_fields();
237
  }
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
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);
254
  friend void swap(AttributeProto& a, AttributeProto& b) {
255
    a.Swap(&b);
256
  }
257

258
  // implements Message ----------------------------------------------
259

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;
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:
284
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
285
    return NULL;
286
  }
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;
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*
329
  AttributeType_descriptor() {
330
    return AttributeProto_AttributeType_descriptor();
331
  }
332
  static inline const ::std::string& AttributeType_Name(AttributeType value) {
333
    return AttributeProto_AttributeType_Name(value);
334
  }
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
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
580
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
581
    return _internal_metadata_.unknown_fields();
582
  }
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
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);
599
  friend void swap(ValueInfoProto& a, ValueInfoProto& b) {
600
    a.Swap(&b);
601
  }
602

603
  // implements Message ----------------------------------------------
604

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;
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:
629
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
630
    return NULL;
631
  }
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
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
728
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
729
    return _internal_metadata_.unknown_fields();
730
  }
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
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);
747
  friend void swap(NodeProto& a, NodeProto& b) {
748
    a.Swap(&b);
749
  }
750

751
  // implements Message ----------------------------------------------
752

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;
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:
777
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
778
    return NULL;
779
  }
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
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
959
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
960
    return _internal_metadata_.unknown_fields();
961
  }
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
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);
978
  friend void swap(ModelProto& a, ModelProto& b) {
979
    a.Swap(&b);
980
  }
981

982
  // implements Message ----------------------------------------------
983

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;
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:
1008
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1009
    return NULL;
1010
  }
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
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
1189
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1190
    return _internal_metadata_.unknown_fields();
1191
  }
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
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);
1208
  friend void swap(StringStringEntryProto& a, StringStringEntryProto& b) {
1209
    a.Swap(&b);
1210
  }
1211

1212
  // implements Message ----------------------------------------------
1213

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;
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:
1238
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1239
    return NULL;
1240
  }
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
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
1325
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1326
    return _internal_metadata_.unknown_fields();
1327
  }
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
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);
1344
  friend void swap(GraphProto& a, GraphProto& b) {
1345
    a.Swap(&b);
1346
  }
1347

1348
  // implements Message ----------------------------------------------
1349

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;
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:
1374
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1375
    return NULL;
1376
  }
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
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
1526
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1527
    return _internal_metadata_.unknown_fields();
1528
  }
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
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);
1545
  friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) {
1546
    a.Swap(&b);
1547
  }
1548

1549
  // implements Message ----------------------------------------------
1550

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;
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:
1575
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1576
    return NULL;
1577
  }
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
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
1646
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1647
    return _internal_metadata_.unknown_fields();
1648
  }
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
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);
1665
  friend void swap(TensorProto& a, TensorProto& b) {
1666
    a.Swap(&b);
1667
  }
1668

1669
  // implements Message ----------------------------------------------
1670

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;
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:
1695
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
1696
    return NULL;
1697
  }
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;
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*
1752
  DataType_descriptor() {
1753
    return TensorProto_DataType_descriptor();
1754
  }
1755
  static inline const ::std::string& DataType_Name(DataType value) {
1756
    return TensorProto_DataType_Name(value);
1757
  }
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
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
1984
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1985
    return _internal_metadata_.unknown_fields();
1986
  }
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
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);
2009
  friend void swap(TensorShapeProto_Dimension& a, TensorShapeProto_Dimension& b) {
2010
    a.Swap(&b);
2011
  }
2012

2013
  // implements Message ----------------------------------------------
2014

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;
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:
2039
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2040
    return NULL;
2041
  }
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 {
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
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
2144
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2145
    return _internal_metadata_.unknown_fields();
2146
  }
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
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);
2163
  friend void swap(TensorShapeProto& a, TensorShapeProto& b) {
2164
    a.Swap(&b);
2165
  }
2166

2167
  // implements Message ----------------------------------------------
2168

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;
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:
2193
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2194
    return NULL;
2195
  }
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
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
2259
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2260
    return _internal_metadata_.unknown_fields();
2261
  }
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
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);
2278
  friend void swap(TypeProto_Tensor& a, TypeProto_Tensor& b) {
2279
    a.Swap(&b);
2280
  }
2281

2282
  // implements Message ----------------------------------------------
2283

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;
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:
2308
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2309
    return NULL;
2310
  }
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
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
2381
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2382
    return _internal_metadata_.unknown_fields();
2383
  }
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
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);
2405
  friend void swap(TypeProto& a, TypeProto& b) {
2406
    a.Swap(&b);
2407
  }
2408

2409
  // implements Message ----------------------------------------------
2410

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;
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:
2435
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2436
    return NULL;
2437
  }
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 {
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
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
2527
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2528
    return _internal_metadata_.unknown_fields();
2529
  }
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
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);
2546
  friend void swap(OperatorSetIdProto& a, OperatorSetIdProto& b) {
2547
    a.Swap(&b);
2548
  }
2549

2550
  // implements Message ----------------------------------------------
2551

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;
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:
2576
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
2577
    return NULL;
2578
  }
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;
2639
inline bool AttributeProto::has_name() const {
2640
  return (_has_bits_[0] & 0x00000001u) != 0;
2641
}
2642
inline void AttributeProto::set_has_name() {
2643
  _has_bits_[0] |= 0x00000001u;
2644
}
2645
inline void AttributeProto::clear_has_name() {
2646
  _has_bits_[0] &= ~0x00000001u;
2647
}
2648
inline void AttributeProto::clear_name() {
2649
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2650
  clear_has_name();
2651
}
2652
inline const ::std::string& AttributeProto::name() const {
2653
  // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.name)
2654
  return name_.GetNoArena();
2655
}
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
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
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
}
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
}
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
}
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
}
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;
2702
inline bool AttributeProto::has_ref_attr_name() const {
2703
  return (_has_bits_[0] & 0x00000008u) != 0;
2704
}
2705
inline void AttributeProto::set_has_ref_attr_name() {
2706
  _has_bits_[0] |= 0x00000008u;
2707
}
2708
inline void AttributeProto::clear_has_ref_attr_name() {
2709
  _has_bits_[0] &= ~0x00000008u;
2710
}
2711
inline void AttributeProto::clear_ref_attr_name() {
2712
  ref_attr_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2713
  clear_has_ref_attr_name();
2714
}
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
}
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
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
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
}
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
}
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
}
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
}
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;
2765
inline bool AttributeProto::has_doc_string() const {
2766
  return (_has_bits_[0] & 0x00000004u) != 0;
2767
}
2768
inline void AttributeProto::set_has_doc_string() {
2769
  _has_bits_[0] |= 0x00000004u;
2770
}
2771
inline void AttributeProto::clear_has_doc_string() {
2772
  _has_bits_[0] &= ~0x00000004u;
2773
}
2774
inline void AttributeProto::clear_doc_string() {
2775
  doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2776
  clear_has_doc_string();
2777
}
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
}
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
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
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
}
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
}
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
}
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
}
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;
2828
inline bool AttributeProto::has_type() const {
2829
  return (_has_bits_[0] & 0x00000100u) != 0;
2830
}
2831
inline void AttributeProto::set_has_type() {
2832
  _has_bits_[0] |= 0x00000100u;
2833
}
2834
inline void AttributeProto::clear_has_type() {
2835
  _has_bits_[0] &= ~0x00000100u;
2836
}
2837
inline void AttributeProto::clear_type() {
2838
  type_ = 0;
2839
  clear_has_type();
2840
}
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
}
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;
2853
inline bool AttributeProto::has_f() const {
2854
  return (_has_bits_[0] & 0x00000080u) != 0;
2855
}
2856
inline void AttributeProto::set_has_f() {
2857
  _has_bits_[0] |= 0x00000080u;
2858
}
2859
inline void AttributeProto::clear_has_f() {
2860
  _has_bits_[0] &= ~0x00000080u;
2861
}
2862
inline void AttributeProto::clear_f() {
2863
  f_ = 0;
2864
  clear_has_f();
2865
}
2866
inline float AttributeProto::f() const {
2867
  // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.f)
2868
  return f_;
2869
}
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;
2877
inline bool AttributeProto::has_i() const {
2878
  return (_has_bits_[0] & 0x00000040u) != 0;
2879
}
2880
inline void AttributeProto::set_has_i() {
2881
  _has_bits_[0] |= 0x00000040u;
2882
}
2883
inline void AttributeProto::clear_has_i() {
2884
  _has_bits_[0] &= ~0x00000040u;
2885
}
2886
inline void AttributeProto::clear_i() {
2887
  i_ = GOOGLE_LONGLONG(0);
2888
  clear_has_i();
2889
}
2890
inline ::google::protobuf::int64 AttributeProto::i() const {
2891
  // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.i)
2892
  return i_;
2893
}
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;
2901
inline bool AttributeProto::has_s() const {
2902
  return (_has_bits_[0] & 0x00000002u) != 0;
2903
}
2904
inline void AttributeProto::set_has_s() {
2905
  _has_bits_[0] |= 0x00000002u;
2906
}
2907
inline void AttributeProto::clear_has_s() {
2908
  _has_bits_[0] &= ~0x00000002u;
2909
}
2910
inline void AttributeProto::clear_s() {
2911
  s_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
2912
  clear_has_s();
2913
}
2914
inline const ::std::string& AttributeProto::s() const {
2915
  // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.s)
2916
  return s_.GetNoArena();
2917
}
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
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
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
}
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
}
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
}
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
}
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;
2964
inline bool AttributeProto::has_t() const {
2965
  return (_has_bits_[0] & 0x00000010u) != 0;
2966
}
2967
inline void AttributeProto::set_has_t() {
2968
  _has_bits_[0] |= 0x00000010u;
2969
}
2970
inline void AttributeProto::clear_has_t() {
2971
  _has_bits_[0] &= ~0x00000010u;
2972
}
2973
inline void AttributeProto::clear_t() {
2974
  if (t_ != NULL) t_->Clear();
2975
  clear_has_t();
2976
}
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
}
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
}
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
}
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;
3018
inline bool AttributeProto::has_g() const {
3019
  return (_has_bits_[0] & 0x00000020u) != 0;
3020
}
3021
inline void AttributeProto::set_has_g() {
3022
  _has_bits_[0] |= 0x00000020u;
3023
}
3024
inline void AttributeProto::clear_has_g() {
3025
  _has_bits_[0] &= ~0x00000020u;
3026
}
3027
inline void AttributeProto::clear_g() {
3028
  if (g_ != NULL) g_->Clear();
3029
  clear_has_g();
3030
}
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
}
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
}
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
}
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;
3072
inline int AttributeProto::floats_size() const {
3073
  return floats_.size();
3074
}
3075
inline void AttributeProto::clear_floats() {
3076
  floats_.Clear();
3077
}
3078
inline float AttributeProto::floats(int index) const {
3079
  // @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.floats)
3080
  return floats_.Get(index);
3081
}
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
}
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 >&
3091
AttributeProto::floats() const {
3092
  // @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.floats)
3093
  return floats_;
3094
}
3095
inline ::google::protobuf::RepeatedField< float >*
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;
3102
inline int AttributeProto::ints_size() const {
3103
  return ints_.size();
3104
}
3105
inline void AttributeProto::clear_ints() {
3106
  ints_.Clear();
3107
}
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
}
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
}
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 >&
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 >*
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;
3132
inline int AttributeProto::strings_size() const {
3133
  return strings_.size();
3134
}
3135
inline void AttributeProto::clear_strings() {
3136
  strings_.Clear();
3137
}
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
}
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
}
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
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
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
}
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
}
3166
inline ::std::string* AttributeProto::add_strings() {
3167
  // @@protoc_insertion_point(field_add_mutable:opencv_onnx.AttributeProto.strings)
3168
  return strings_.Add();
3169
}
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
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
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
}
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>&
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>*
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;
3201
inline int AttributeProto::tensors_size() const {
3202
  return tensors_.size();
3203
}
3204
inline void AttributeProto::clear_tensors() {
3205
  tensors_.Clear();
3206
}
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
}
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
}
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 >*
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 >&
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;
3231
inline int AttributeProto::graphs_size() const {
3232
  return graphs_.size();
3233
}
3234
inline void AttributeProto::clear_graphs() {
3235
  graphs_.Clear();
3236
}
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
}
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
}
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 >*
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 >&
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;
3265
inline bool ValueInfoProto::has_name() const {
3266
  return (_has_bits_[0] & 0x00000001u) != 0;
3267
}
3268
inline void ValueInfoProto::set_has_name() {
3269
  _has_bits_[0] |= 0x00000001u;
3270
}
3271
inline void ValueInfoProto::clear_has_name() {
3272
  _has_bits_[0] &= ~0x00000001u;
3273
}
3274
inline void ValueInfoProto::clear_name() {
3275
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3276
  clear_has_name();
3277
}
3278
inline const ::std::string& ValueInfoProto::name() const {
3279
  // @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.name)
3280
  return name_.GetNoArena();
3281
}
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
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
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
}
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
}
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
}
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
}
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;
3328
inline bool ValueInfoProto::has_type() const {
3329
  return (_has_bits_[0] & 0x00000004u) != 0;
3330
}
3331
inline void ValueInfoProto::set_has_type() {
3332
  _has_bits_[0] |= 0x00000004u;
3333
}
3334
inline void ValueInfoProto::clear_has_type() {
3335
  _has_bits_[0] &= ~0x00000004u;
3336
}
3337
inline void ValueInfoProto::clear_type() {
3338
  if (type_ != NULL) type_->Clear();
3339
  clear_has_type();
3340
}
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
}
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
}
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
}
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;
3382
inline bool ValueInfoProto::has_doc_string() const {
3383
  return (_has_bits_[0] & 0x00000002u) != 0;
3384
}
3385
inline void ValueInfoProto::set_has_doc_string() {
3386
  _has_bits_[0] |= 0x00000002u;
3387
}
3388
inline void ValueInfoProto::clear_has_doc_string() {
3389
  _has_bits_[0] &= ~0x00000002u;
3390
}
3391
inline void ValueInfoProto::clear_doc_string() {
3392
  doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3393
  clear_has_doc_string();
3394
}
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
}
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
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
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
}
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
}
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
}
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
}
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;
3449
inline int NodeProto::input_size() const {
3450
  return input_.size();
3451
}
3452
inline void NodeProto::clear_input() {
3453
  input_.Clear();
3454
}
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
}
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
}
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
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
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
}
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
}
3483
inline ::std::string* NodeProto::add_input() {
3484
  // @@protoc_insertion_point(field_add_mutable:opencv_onnx.NodeProto.input)
3485
  return input_.Add();
3486
}
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
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
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
}
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>&
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>*
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;
3518
inline int NodeProto::output_size() const {
3519
  return output_.size();
3520
}
3521
inline void NodeProto::clear_output() {
3522
  output_.Clear();
3523
}
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
}
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
}
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
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
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
}
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
}
3552
inline ::std::string* NodeProto::add_output() {
3553
  // @@protoc_insertion_point(field_add_mutable:opencv_onnx.NodeProto.output)
3554
  return output_.Add();
3555
}
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
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
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
}
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>&
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>*
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;
3587
inline bool NodeProto::has_name() const {
3588
  return (_has_bits_[0] & 0x00000001u) != 0;
3589
}
3590
inline void NodeProto::set_has_name() {
3591
  _has_bits_[0] |= 0x00000001u;
3592
}
3593
inline void NodeProto::clear_has_name() {
3594
  _has_bits_[0] &= ~0x00000001u;
3595
}
3596
inline void NodeProto::clear_name() {
3597
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3598
  clear_has_name();
3599
}
3600
inline const ::std::string& NodeProto::name() const {
3601
  // @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.name)
3602
  return name_.GetNoArena();
3603
}
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
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
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
}
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
}
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
}
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
}
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;
3650
inline bool NodeProto::has_op_type() const {
3651
  return (_has_bits_[0] & 0x00000002u) != 0;
3652
}
3653
inline void NodeProto::set_has_op_type() {
3654
  _has_bits_[0] |= 0x00000002u;
3655
}
3656
inline void NodeProto::clear_has_op_type() {
3657
  _has_bits_[0] &= ~0x00000002u;
3658
}
3659
inline void NodeProto::clear_op_type() {
3660
  op_type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3661
  clear_has_op_type();
3662
}
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
}
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
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
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
}
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
}
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
}
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
}
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;
3713
inline bool NodeProto::has_domain() const {
3714
  return (_has_bits_[0] & 0x00000008u) != 0;
3715
}
3716
inline void NodeProto::set_has_domain() {
3717
  _has_bits_[0] |= 0x00000008u;
3718
}
3719
inline void NodeProto::clear_has_domain() {
3720
  _has_bits_[0] &= ~0x00000008u;
3721
}
3722
inline void NodeProto::clear_domain() {
3723
  domain_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3724
  clear_has_domain();
3725
}
3726
inline const ::std::string& NodeProto::domain() const {
3727
  // @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.domain)
3728
  return domain_.GetNoArena();
3729
}
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
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
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
}
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
}
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
}
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
}
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;
3776
inline int NodeProto::attribute_size() const {
3777
  return attribute_.size();
3778
}
3779
inline void NodeProto::clear_attribute() {
3780
  attribute_.Clear();
3781
}
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
}
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
}
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 >*
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 >&
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;
3806
inline bool NodeProto::has_doc_string() const {
3807
  return (_has_bits_[0] & 0x00000004u) != 0;
3808
}
3809
inline void NodeProto::set_has_doc_string() {
3810
  _has_bits_[0] |= 0x00000004u;
3811
}
3812
inline void NodeProto::clear_has_doc_string() {
3813
  _has_bits_[0] &= ~0x00000004u;
3814
}
3815
inline void NodeProto::clear_doc_string() {
3816
  doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3817
  clear_has_doc_string();
3818
}
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
}
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
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
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
}
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
}
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
}
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
}
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;
3873
inline bool ModelProto::has_ir_version() const {
3874
  return (_has_bits_[0] & 0x00000020u) != 0;
3875
}
3876
inline void ModelProto::set_has_ir_version() {
3877
  _has_bits_[0] |= 0x00000020u;
3878
}
3879
inline void ModelProto::clear_has_ir_version() {
3880
  _has_bits_[0] &= ~0x00000020u;
3881
}
3882
inline void ModelProto::clear_ir_version() {
3883
  ir_version_ = GOOGLE_LONGLONG(0);
3884
  clear_has_ir_version();
3885
}
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
}
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;
3897
inline int ModelProto::opset_import_size() const {
3898
  return opset_import_.size();
3899
}
3900
inline void ModelProto::clear_opset_import() {
3901
  opset_import_.Clear();
3902
}
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
}
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
}
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 >*
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 >&
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;
3927
inline bool ModelProto::has_producer_name() const {
3928
  return (_has_bits_[0] & 0x00000001u) != 0;
3929
}
3930
inline void ModelProto::set_has_producer_name() {
3931
  _has_bits_[0] |= 0x00000001u;
3932
}
3933
inline void ModelProto::clear_has_producer_name() {
3934
  _has_bits_[0] &= ~0x00000001u;
3935
}
3936
inline void ModelProto::clear_producer_name() {
3937
  producer_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3938
  clear_has_producer_name();
3939
}
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
}
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
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
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
}
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
}
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
}
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
}
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;
3990
inline bool ModelProto::has_producer_version() const {
3991
  return (_has_bits_[0] & 0x00000002u) != 0;
3992
}
3993
inline void ModelProto::set_has_producer_version() {
3994
  _has_bits_[0] |= 0x00000002u;
3995
}
3996
inline void ModelProto::clear_has_producer_version() {
3997
  _has_bits_[0] &= ~0x00000002u;
3998
}
3999
inline void ModelProto::clear_producer_version() {
4000
  producer_version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4001
  clear_has_producer_version();
4002
}
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
}
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
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
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
}
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
}
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
}
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
}
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;
4053
inline bool ModelProto::has_domain() const {
4054
  return (_has_bits_[0] & 0x00000004u) != 0;
4055
}
4056
inline void ModelProto::set_has_domain() {
4057
  _has_bits_[0] |= 0x00000004u;
4058
}
4059
inline void ModelProto::clear_has_domain() {
4060
  _has_bits_[0] &= ~0x00000004u;
4061
}
4062
inline void ModelProto::clear_domain() {
4063
  domain_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4064
  clear_has_domain();
4065
}
4066
inline const ::std::string& ModelProto::domain() const {
4067
  // @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.domain)
4068
  return domain_.GetNoArena();
4069
}
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
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
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
}
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
}
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
}
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
}
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;
4116
inline bool ModelProto::has_model_version() const {
4117
  return (_has_bits_[0] & 0x00000040u) != 0;
4118
}
4119
inline void ModelProto::set_has_model_version() {
4120
  _has_bits_[0] |= 0x00000040u;
4121
}
4122
inline void ModelProto::clear_has_model_version() {
4123
  _has_bits_[0] &= ~0x00000040u;
4124
}
4125
inline void ModelProto::clear_model_version() {
4126
  model_version_ = GOOGLE_LONGLONG(0);
4127
  clear_has_model_version();
4128
}
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
}
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;
4140
inline bool ModelProto::has_doc_string() const {
4141
  return (_has_bits_[0] & 0x00000008u) != 0;
4142
}
4143
inline void ModelProto::set_has_doc_string() {
4144
  _has_bits_[0] |= 0x00000008u;
4145
}
4146
inline void ModelProto::clear_has_doc_string() {
4147
  _has_bits_[0] &= ~0x00000008u;
4148
}
4149
inline void ModelProto::clear_doc_string() {
4150
  doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4151
  clear_has_doc_string();
4152
}
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
}
4157
inline void ModelProto::set_doc_string(const ::std::string& value) {
4158
  set_has_doc_string();
4159
  doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4160
  // @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.doc_string)
4161
}
4162
#if LANG_CXX11
4163
inline void ModelProto::set_doc_string(::std::string&& value) {
4164
  set_has_doc_string();
4165
  doc_string_.SetNoArena(
4166
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4167
  // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.ModelProto.doc_string)
4168
}
4169
#endif
4170
inline void ModelProto::set_doc_string(const char* value) {
4171
  GOOGLE_DCHECK(value != NULL);
4172
  set_has_doc_string();
4173
  doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4174
  // @@protoc_insertion_point(field_set_char:opencv_onnx.ModelProto.doc_string)
4175
}
4176
inline void ModelProto::set_doc_string(const char* value, size_t size) {
4177
  set_has_doc_string();
4178
  doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4179
      ::std::string(reinterpret_cast<const char*>(value), size));
4180
  // @@protoc_insertion_point(field_set_pointer:opencv_onnx.ModelProto.doc_string)
4181
}
4182
inline ::std::string* ModelProto::mutable_doc_string() {
4183
  set_has_doc_string();
4184
  // @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.doc_string)
4185
  return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4186
}
4187
inline ::std::string* ModelProto::release_doc_string() {
4188
  // @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.doc_string)
4189
  clear_has_doc_string();
4190
  return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4191
}
4192
inline void ModelProto::set_allocated_doc_string(::std::string* doc_string) {
4193
  if (doc_string != NULL) {
4194
    set_has_doc_string();
4195
  } else {
4196
    clear_has_doc_string();
4197
  }
4198
  doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
4199
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.doc_string)
4200
}
4201

4202
// optional .opencv_onnx.GraphProto graph = 7;
4203
inline bool ModelProto::has_graph() const {
4204
  return (_has_bits_[0] & 0x00000010u) != 0;
4205
}
4206
inline void ModelProto::set_has_graph() {
4207
  _has_bits_[0] |= 0x00000010u;
4208
}
4209
inline void ModelProto::clear_has_graph() {
4210
  _has_bits_[0] &= ~0x00000010u;
4211
}
4212
inline void ModelProto::clear_graph() {
4213
  if (graph_ != NULL) graph_->Clear();
4214
  clear_has_graph();
4215
}
4216
inline const ::opencv_onnx::GraphProto& ModelProto::graph() const {
4217
  const ::opencv_onnx::GraphProto* p = graph_;
4218
  // @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.graph)
4219
  return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::GraphProto*>(
4220
      &::opencv_onnx::_GraphProto_default_instance_);
4221
}
4222
inline ::opencv_onnx::GraphProto* ModelProto::release_graph() {
4223
  // @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.graph)
4224
  clear_has_graph();
4225
  ::opencv_onnx::GraphProto* temp = graph_;
4226
  graph_ = NULL;
4227
  return temp;
4228
}
4229
inline ::opencv_onnx::GraphProto* ModelProto::mutable_graph() {
4230
  set_has_graph();
4231
  if (graph_ == NULL) {
4232
    graph_ = new ::opencv_onnx::GraphProto;
4233
  }
4234
  // @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.graph)
4235
  return graph_;
4236
}
4237
inline void ModelProto::set_allocated_graph(::opencv_onnx::GraphProto* graph) {
4238
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4239
  if (message_arena == NULL) {
4240
    delete graph_;
4241
  }
4242
  if (graph) {
4243
    ::google::protobuf::Arena* submessage_arena = NULL;
4244
    if (message_arena != submessage_arena) {
4245
      graph = ::google::protobuf::internal::GetOwnedMessage(
4246
          message_arena, graph, submessage_arena);
4247
    }
4248
    set_has_graph();
4249
  } else {
4250
    clear_has_graph();
4251
  }
4252
  graph_ = graph;
4253
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.graph)
4254
}
4255

4256
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 14;
4257
inline int ModelProto::metadata_props_size() const {
4258
  return metadata_props_.size();
4259
}
4260
inline void ModelProto::clear_metadata_props() {
4261
  metadata_props_.Clear();
4262
}
4263
inline const ::opencv_onnx::StringStringEntryProto& ModelProto::metadata_props(int index) const {
4264
  // @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.metadata_props)
4265
  return metadata_props_.Get(index);
4266
}
4267
inline ::opencv_onnx::StringStringEntryProto* ModelProto::mutable_metadata_props(int index) {
4268
  // @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.metadata_props)
4269
  return metadata_props_.Mutable(index);
4270
}
4271
inline ::opencv_onnx::StringStringEntryProto* ModelProto::add_metadata_props() {
4272
  // @@protoc_insertion_point(field_add:opencv_onnx.ModelProto.metadata_props)
4273
  return metadata_props_.Add();
4274
}
4275
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
4276
ModelProto::mutable_metadata_props() {
4277
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.ModelProto.metadata_props)
4278
  return &metadata_props_;
4279
}
4280
inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
4281
ModelProto::metadata_props() const {
4282
  // @@protoc_insertion_point(field_list:opencv_onnx.ModelProto.metadata_props)
4283
  return metadata_props_;
4284
}
4285

4286
// -------------------------------------------------------------------
4287

4288
// StringStringEntryProto
4289

4290
// optional string key = 1;
4291
inline bool StringStringEntryProto::has_key() const {
4292
  return (_has_bits_[0] & 0x00000001u) != 0;
4293
}
4294
inline void StringStringEntryProto::set_has_key() {
4295
  _has_bits_[0] |= 0x00000001u;
4296
}
4297
inline void StringStringEntryProto::clear_has_key() {
4298
  _has_bits_[0] &= ~0x00000001u;
4299
}
4300
inline void StringStringEntryProto::clear_key() {
4301
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4302
  clear_has_key();
4303
}
4304
inline const ::std::string& StringStringEntryProto::key() const {
4305
  // @@protoc_insertion_point(field_get:opencv_onnx.StringStringEntryProto.key)
4306
  return key_.GetNoArena();
4307
}
4308
inline void StringStringEntryProto::set_key(const ::std::string& value) {
4309
  set_has_key();
4310
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4311
  // @@protoc_insertion_point(field_set:opencv_onnx.StringStringEntryProto.key)
4312
}
4313
#if LANG_CXX11
4314
inline void StringStringEntryProto::set_key(::std::string&& value) {
4315
  set_has_key();
4316
  key_.SetNoArena(
4317
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4318
  // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.StringStringEntryProto.key)
4319
}
4320
#endif
4321
inline void StringStringEntryProto::set_key(const char* value) {
4322
  GOOGLE_DCHECK(value != NULL);
4323
  set_has_key();
4324
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4325
  // @@protoc_insertion_point(field_set_char:opencv_onnx.StringStringEntryProto.key)
4326
}
4327
inline void StringStringEntryProto::set_key(const char* value, size_t size) {
4328
  set_has_key();
4329
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4330
      ::std::string(reinterpret_cast<const char*>(value), size));
4331
  // @@protoc_insertion_point(field_set_pointer:opencv_onnx.StringStringEntryProto.key)
4332
}
4333
inline ::std::string* StringStringEntryProto::mutable_key() {
4334
  set_has_key();
4335
  // @@protoc_insertion_point(field_mutable:opencv_onnx.StringStringEntryProto.key)
4336
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4337
}
4338
inline ::std::string* StringStringEntryProto::release_key() {
4339
  // @@protoc_insertion_point(field_release:opencv_onnx.StringStringEntryProto.key)
4340
  clear_has_key();
4341
  return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4342
}
4343
inline void StringStringEntryProto::set_allocated_key(::std::string* key) {
4344
  if (key != NULL) {
4345
    set_has_key();
4346
  } else {
4347
    clear_has_key();
4348
  }
4349
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
4350
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.StringStringEntryProto.key)
4351
}
4352

4353
// optional string value = 2;
4354
inline bool StringStringEntryProto::has_value() const {
4355
  return (_has_bits_[0] & 0x00000002u) != 0;
4356
}
4357
inline void StringStringEntryProto::set_has_value() {
4358
  _has_bits_[0] |= 0x00000002u;
4359
}
4360
inline void StringStringEntryProto::clear_has_value() {
4361
  _has_bits_[0] &= ~0x00000002u;
4362
}
4363
inline void StringStringEntryProto::clear_value() {
4364
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4365
  clear_has_value();
4366
}
4367
inline const ::std::string& StringStringEntryProto::value() const {
4368
  // @@protoc_insertion_point(field_get:opencv_onnx.StringStringEntryProto.value)
4369
  return value_.GetNoArena();
4370
}
4371
inline void StringStringEntryProto::set_value(const ::std::string& value) {
4372
  set_has_value();
4373
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4374
  // @@protoc_insertion_point(field_set:opencv_onnx.StringStringEntryProto.value)
4375
}
4376
#if LANG_CXX11
4377
inline void StringStringEntryProto::set_value(::std::string&& value) {
4378
  set_has_value();
4379
  value_.SetNoArena(
4380
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4381
  // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.StringStringEntryProto.value)
4382
}
4383
#endif
4384
inline void StringStringEntryProto::set_value(const char* value) {
4385
  GOOGLE_DCHECK(value != NULL);
4386
  set_has_value();
4387
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4388
  // @@protoc_insertion_point(field_set_char:opencv_onnx.StringStringEntryProto.value)
4389
}
4390
inline void StringStringEntryProto::set_value(const char* value, size_t size) {
4391
  set_has_value();
4392
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4393
      ::std::string(reinterpret_cast<const char*>(value), size));
4394
  // @@protoc_insertion_point(field_set_pointer:opencv_onnx.StringStringEntryProto.value)
4395
}
4396
inline ::std::string* StringStringEntryProto::mutable_value() {
4397
  set_has_value();
4398
  // @@protoc_insertion_point(field_mutable:opencv_onnx.StringStringEntryProto.value)
4399
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4400
}
4401
inline ::std::string* StringStringEntryProto::release_value() {
4402
  // @@protoc_insertion_point(field_release:opencv_onnx.StringStringEntryProto.value)
4403
  clear_has_value();
4404
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4405
}
4406
inline void StringStringEntryProto::set_allocated_value(::std::string* value) {
4407
  if (value != NULL) {
4408
    set_has_value();
4409
  } else {
4410
    clear_has_value();
4411
  }
4412
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4413
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.StringStringEntryProto.value)
4414
}
4415

4416
// -------------------------------------------------------------------
4417

4418
// GraphProto
4419

4420
// repeated .opencv_onnx.NodeProto node = 1;
4421
inline int GraphProto::node_size() const {
4422
  return node_.size();
4423
}
4424
inline void GraphProto::clear_node() {
4425
  node_.Clear();
4426
}
4427
inline const ::opencv_onnx::NodeProto& GraphProto::node(int index) const {
4428
  // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.node)
4429
  return node_.Get(index);
4430
}
4431
inline ::opencv_onnx::NodeProto* GraphProto::mutable_node(int index) {
4432
  // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.node)
4433
  return node_.Mutable(index);
4434
}
4435
inline ::opencv_onnx::NodeProto* GraphProto::add_node() {
4436
  // @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.node)
4437
  return node_.Add();
4438
}
4439
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::NodeProto >*
4440
GraphProto::mutable_node() {
4441
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.node)
4442
  return &node_;
4443
}
4444
inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::NodeProto >&
4445
GraphProto::node() const {
4446
  // @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.node)
4447
  return node_;
4448
}
4449

4450
// optional string name = 2;
4451
inline bool GraphProto::has_name() const {
4452
  return (_has_bits_[0] & 0x00000001u) != 0;
4453
}
4454
inline void GraphProto::set_has_name() {
4455
  _has_bits_[0] |= 0x00000001u;
4456
}
4457
inline void GraphProto::clear_has_name() {
4458
  _has_bits_[0] &= ~0x00000001u;
4459
}
4460
inline void GraphProto::clear_name() {
4461
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4462
  clear_has_name();
4463
}
4464
inline const ::std::string& GraphProto::name() const {
4465
  // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.name)
4466
  return name_.GetNoArena();
4467
}
4468
inline void GraphProto::set_name(const ::std::string& value) {
4469
  set_has_name();
4470
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4471
  // @@protoc_insertion_point(field_set:opencv_onnx.GraphProto.name)
4472
}
4473
#if LANG_CXX11
4474
inline void GraphProto::set_name(::std::string&& value) {
4475
  set_has_name();
4476
  name_.SetNoArena(
4477
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4478
  // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.GraphProto.name)
4479
}
4480
#endif
4481
inline void GraphProto::set_name(const char* value) {
4482
  GOOGLE_DCHECK(value != NULL);
4483
  set_has_name();
4484
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4485
  // @@protoc_insertion_point(field_set_char:opencv_onnx.GraphProto.name)
4486
}
4487
inline void GraphProto::set_name(const char* value, size_t size) {
4488
  set_has_name();
4489
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4490
      ::std::string(reinterpret_cast<const char*>(value), size));
4491
  // @@protoc_insertion_point(field_set_pointer:opencv_onnx.GraphProto.name)
4492
}
4493
inline ::std::string* GraphProto::mutable_name() {
4494
  set_has_name();
4495
  // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.name)
4496
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4497
}
4498
inline ::std::string* GraphProto::release_name() {
4499
  // @@protoc_insertion_point(field_release:opencv_onnx.GraphProto.name)
4500
  clear_has_name();
4501
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4502
}
4503
inline void GraphProto::set_allocated_name(::std::string* name) {
4504
  if (name != NULL) {
4505
    set_has_name();
4506
  } else {
4507
    clear_has_name();
4508
  }
4509
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
4510
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.GraphProto.name)
4511
}
4512

4513
// repeated .opencv_onnx.TensorProto initializer = 5;
4514
inline int GraphProto::initializer_size() const {
4515
  return initializer_.size();
4516
}
4517
inline void GraphProto::clear_initializer() {
4518
  initializer_.Clear();
4519
}
4520
inline const ::opencv_onnx::TensorProto& GraphProto::initializer(int index) const {
4521
  // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.initializer)
4522
  return initializer_.Get(index);
4523
}
4524
inline ::opencv_onnx::TensorProto* GraphProto::mutable_initializer(int index) {
4525
  // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.initializer)
4526
  return initializer_.Mutable(index);
4527
}
4528
inline ::opencv_onnx::TensorProto* GraphProto::add_initializer() {
4529
  // @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.initializer)
4530
  return initializer_.Add();
4531
}
4532
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >*
4533
GraphProto::mutable_initializer() {
4534
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.initializer)
4535
  return &initializer_;
4536
}
4537
inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >&
4538
GraphProto::initializer() const {
4539
  // @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.initializer)
4540
  return initializer_;
4541
}
4542

4543
// optional string doc_string = 10;
4544
inline bool GraphProto::has_doc_string() const {
4545
  return (_has_bits_[0] & 0x00000002u) != 0;
4546
}
4547
inline void GraphProto::set_has_doc_string() {
4548
  _has_bits_[0] |= 0x00000002u;
4549
}
4550
inline void GraphProto::clear_has_doc_string() {
4551
  _has_bits_[0] &= ~0x00000002u;
4552
}
4553
inline void GraphProto::clear_doc_string() {
4554
  doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4555
  clear_has_doc_string();
4556
}
4557
inline const ::std::string& GraphProto::doc_string() const {
4558
  // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.doc_string)
4559
  return doc_string_.GetNoArena();
4560
}
4561
inline void GraphProto::set_doc_string(const ::std::string& value) {
4562
  set_has_doc_string();
4563
  doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
4564
  // @@protoc_insertion_point(field_set:opencv_onnx.GraphProto.doc_string)
4565
}
4566
#if LANG_CXX11
4567
inline void GraphProto::set_doc_string(::std::string&& value) {
4568
  set_has_doc_string();
4569
  doc_string_.SetNoArena(
4570
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4571
  // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.GraphProto.doc_string)
4572
}
4573
#endif
4574
inline void GraphProto::set_doc_string(const char* value) {
4575
  GOOGLE_DCHECK(value != NULL);
4576
  set_has_doc_string();
4577
  doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4578
  // @@protoc_insertion_point(field_set_char:opencv_onnx.GraphProto.doc_string)
4579
}
4580
inline void GraphProto::set_doc_string(const char* value, size_t size) {
4581
  set_has_doc_string();
4582
  doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
4583
      ::std::string(reinterpret_cast<const char*>(value), size));
4584
  // @@protoc_insertion_point(field_set_pointer:opencv_onnx.GraphProto.doc_string)
4585
}
4586
inline ::std::string* GraphProto::mutable_doc_string() {
4587
  set_has_doc_string();
4588
  // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.doc_string)
4589
  return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4590
}
4591
inline ::std::string* GraphProto::release_doc_string() {
4592
  // @@protoc_insertion_point(field_release:opencv_onnx.GraphProto.doc_string)
4593
  clear_has_doc_string();
4594
  return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4595
}
4596
inline void GraphProto::set_allocated_doc_string(::std::string* doc_string) {
4597
  if (doc_string != NULL) {
4598
    set_has_doc_string();
4599
  } else {
4600
    clear_has_doc_string();
4601
  }
4602
  doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
4603
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.GraphProto.doc_string)
4604
}
4605

4606
// repeated .opencv_onnx.ValueInfoProto input = 11;
4607
inline int GraphProto::input_size() const {
4608
  return input_.size();
4609
}
4610
inline void GraphProto::clear_input() {
4611
  input_.Clear();
4612
}
4613
inline const ::opencv_onnx::ValueInfoProto& GraphProto::input(int index) const {
4614
  // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.input)
4615
  return input_.Get(index);
4616
}
4617
inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_input(int index) {
4618
  // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.input)
4619
  return input_.Mutable(index);
4620
}
4621
inline ::opencv_onnx::ValueInfoProto* GraphProto::add_input() {
4622
  // @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.input)
4623
  return input_.Add();
4624
}
4625
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
4626
GraphProto::mutable_input() {
4627
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.input)
4628
  return &input_;
4629
}
4630
inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
4631
GraphProto::input() const {
4632
  // @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.input)
4633
  return input_;
4634
}
4635

4636
// repeated .opencv_onnx.ValueInfoProto output = 12;
4637
inline int GraphProto::output_size() const {
4638
  return output_.size();
4639
}
4640
inline void GraphProto::clear_output() {
4641
  output_.Clear();
4642
}
4643
inline const ::opencv_onnx::ValueInfoProto& GraphProto::output(int index) const {
4644
  // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.output)
4645
  return output_.Get(index);
4646
}
4647
inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_output(int index) {
4648
  // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.output)
4649
  return output_.Mutable(index);
4650
}
4651
inline ::opencv_onnx::ValueInfoProto* GraphProto::add_output() {
4652
  // @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.output)
4653
  return output_.Add();
4654
}
4655
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
4656
GraphProto::mutable_output() {
4657
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.output)
4658
  return &output_;
4659
}
4660
inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
4661
GraphProto::output() const {
4662
  // @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.output)
4663
  return output_;
4664
}
4665

4666
// repeated .opencv_onnx.ValueInfoProto value_info = 13;
4667
inline int GraphProto::value_info_size() const {
4668
  return value_info_.size();
4669
}
4670
inline void GraphProto::clear_value_info() {
4671
  value_info_.Clear();
4672
}
4673
inline const ::opencv_onnx::ValueInfoProto& GraphProto::value_info(int index) const {
4674
  // @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.value_info)
4675
  return value_info_.Get(index);
4676
}
4677
inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_value_info(int index) {
4678
  // @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.value_info)
4679
  return value_info_.Mutable(index);
4680
}
4681
inline ::opencv_onnx::ValueInfoProto* GraphProto::add_value_info() {
4682
  // @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.value_info)
4683
  return value_info_.Add();
4684
}
4685
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
4686
GraphProto::mutable_value_info() {
4687
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.value_info)
4688
  return &value_info_;
4689
}
4690
inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
4691
GraphProto::value_info() const {
4692
  // @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.value_info)
4693
  return value_info_;
4694
}
4695

4696
// -------------------------------------------------------------------
4697

4698
// TensorProto_Segment
4699

4700
// optional int64 begin = 1;
4701
inline bool TensorProto_Segment::has_begin() const {
4702
  return (_has_bits_[0] & 0x00000001u) != 0;
4703
}
4704
inline void TensorProto_Segment::set_has_begin() {
4705
  _has_bits_[0] |= 0x00000001u;
4706
}
4707
inline void TensorProto_Segment::clear_has_begin() {
4708
  _has_bits_[0] &= ~0x00000001u;
4709
}
4710
inline void TensorProto_Segment::clear_begin() {
4711
  begin_ = GOOGLE_LONGLONG(0);
4712
  clear_has_begin();
4713
}
4714
inline ::google::protobuf::int64 TensorProto_Segment::begin() const {
4715
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.Segment.begin)
4716
  return begin_;
4717
}
4718
inline void TensorProto_Segment::set_begin(::google::protobuf::int64 value) {
4719
  set_has_begin();
4720
  begin_ = value;
4721
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.Segment.begin)
4722
}
4723

4724
// optional int64 end = 2;
4725
inline bool TensorProto_Segment::has_end() const {
4726
  return (_has_bits_[0] & 0x00000002u) != 0;
4727
}
4728
inline void TensorProto_Segment::set_has_end() {
4729
  _has_bits_[0] |= 0x00000002u;
4730
}
4731
inline void TensorProto_Segment::clear_has_end() {
4732
  _has_bits_[0] &= ~0x00000002u;
4733
}
4734
inline void TensorProto_Segment::clear_end() {
4735
  end_ = GOOGLE_LONGLONG(0);
4736
  clear_has_end();
4737
}
4738
inline ::google::protobuf::int64 TensorProto_Segment::end() const {
4739
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.Segment.end)
4740
  return end_;
4741
}
4742
inline void TensorProto_Segment::set_end(::google::protobuf::int64 value) {
4743
  set_has_end();
4744
  end_ = value;
4745
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.Segment.end)
4746
}
4747

4748
// -------------------------------------------------------------------
4749

4750
// TensorProto
4751

4752
// repeated int64 dims = 1;
4753
inline int TensorProto::dims_size() const {
4754
  return dims_.size();
4755
}
4756
inline void TensorProto::clear_dims() {
4757
  dims_.Clear();
4758
}
4759
inline ::google::protobuf::int64 TensorProto::dims(int index) const {
4760
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.dims)
4761
  return dims_.Get(index);
4762
}
4763
inline void TensorProto::set_dims(int index, ::google::protobuf::int64 value) {
4764
  dims_.Set(index, value);
4765
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.dims)
4766
}
4767
inline void TensorProto::add_dims(::google::protobuf::int64 value) {
4768
  dims_.Add(value);
4769
  // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.dims)
4770
}
4771
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
4772
TensorProto::dims() const {
4773
  // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.dims)
4774
  return dims_;
4775
}
4776
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
4777
TensorProto::mutable_dims() {
4778
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.dims)
4779
  return &dims_;
4780
}
4781

4782
// optional .opencv_onnx.TensorProto.DataType data_type = 2;
4783
inline bool TensorProto::has_data_type() const {
4784
  return (_has_bits_[0] & 0x00000010u) != 0;
4785
}
4786
inline void TensorProto::set_has_data_type() {
4787
  _has_bits_[0] |= 0x00000010u;
4788
}
4789
inline void TensorProto::clear_has_data_type() {
4790
  _has_bits_[0] &= ~0x00000010u;
4791
}
4792
inline void TensorProto::clear_data_type() {
4793
  data_type_ = 0;
4794
  clear_has_data_type();
4795
}
4796
inline ::opencv_onnx::TensorProto_DataType TensorProto::data_type() const {
4797
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.data_type)
4798
  return static_cast< ::opencv_onnx::TensorProto_DataType >(data_type_);
4799
}
4800
inline void TensorProto::set_data_type(::opencv_onnx::TensorProto_DataType value) {
4801
  assert(::opencv_onnx::TensorProto_DataType_IsValid(value));
4802
  set_has_data_type();
4803
  data_type_ = value;
4804
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.data_type)
4805
}
4806

4807
// optional .opencv_onnx.TensorProto.Segment segment = 3;
4808
inline bool TensorProto::has_segment() const {
4809
  return (_has_bits_[0] & 0x00000008u) != 0;
4810
}
4811
inline void TensorProto::set_has_segment() {
4812
  _has_bits_[0] |= 0x00000008u;
4813
}
4814
inline void TensorProto::clear_has_segment() {
4815
  _has_bits_[0] &= ~0x00000008u;
4816
}
4817
inline void TensorProto::clear_segment() {
4818
  if (segment_ != NULL) segment_->Clear();
4819
  clear_has_segment();
4820
}
4821
inline const ::opencv_onnx::TensorProto_Segment& TensorProto::segment() const {
4822
  const ::opencv_onnx::TensorProto_Segment* p = segment_;
4823
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.segment)
4824
  return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::TensorProto_Segment*>(
4825
      &::opencv_onnx::_TensorProto_Segment_default_instance_);
4826
}
4827
inline ::opencv_onnx::TensorProto_Segment* TensorProto::release_segment() {
4828
  // @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.segment)
4829
  clear_has_segment();
4830
  ::opencv_onnx::TensorProto_Segment* temp = segment_;
4831
  segment_ = NULL;
4832
  return temp;
4833
}
4834
inline ::opencv_onnx::TensorProto_Segment* TensorProto::mutable_segment() {
4835
  set_has_segment();
4836
  if (segment_ == NULL) {
4837
    segment_ = new ::opencv_onnx::TensorProto_Segment;
4838
  }
4839
  // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.segment)
4840
  return segment_;
4841
}
4842
inline void TensorProto::set_allocated_segment(::opencv_onnx::TensorProto_Segment* segment) {
4843
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
4844
  if (message_arena == NULL) {
4845
    delete segment_;
4846
  }
4847
  if (segment) {
4848
    ::google::protobuf::Arena* submessage_arena = NULL;
4849
    if (message_arena != submessage_arena) {
4850
      segment = ::google::protobuf::internal::GetOwnedMessage(
4851
          message_arena, segment, submessage_arena);
4852
    }
4853
    set_has_segment();
4854
  } else {
4855
    clear_has_segment();
4856
  }
4857
  segment_ = segment;
4858
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.segment)
4859
}
4860

4861
// repeated float float_data = 4 [packed = true];
4862
inline int TensorProto::float_data_size() const {
4863
  return float_data_.size();
4864
}
4865
inline void TensorProto::clear_float_data() {
4866
  float_data_.Clear();
4867
}
4868
inline float TensorProto::float_data(int index) const {
4869
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.float_data)
4870
  return float_data_.Get(index);
4871
}
4872
inline void TensorProto::set_float_data(int index, float value) {
4873
  float_data_.Set(index, value);
4874
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.float_data)
4875
}
4876
inline void TensorProto::add_float_data(float value) {
4877
  float_data_.Add(value);
4878
  // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.float_data)
4879
}
4880
inline const ::google::protobuf::RepeatedField< float >&
4881
TensorProto::float_data() const {
4882
  // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.float_data)
4883
  return float_data_;
4884
}
4885
inline ::google::protobuf::RepeatedField< float >*
4886
TensorProto::mutable_float_data() {
4887
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.float_data)
4888
  return &float_data_;
4889
}
4890

4891
// repeated int32 int32_data = 5 [packed = true];
4892
inline int TensorProto::int32_data_size() const {
4893
  return int32_data_.size();
4894
}
4895
inline void TensorProto::clear_int32_data() {
4896
  int32_data_.Clear();
4897
}
4898
inline ::google::protobuf::int32 TensorProto::int32_data(int index) const {
4899
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.int32_data)
4900
  return int32_data_.Get(index);
4901
}
4902
inline void TensorProto::set_int32_data(int index, ::google::protobuf::int32 value) {
4903
  int32_data_.Set(index, value);
4904
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.int32_data)
4905
}
4906
inline void TensorProto::add_int32_data(::google::protobuf::int32 value) {
4907
  int32_data_.Add(value);
4908
  // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.int32_data)
4909
}
4910
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
4911
TensorProto::int32_data() const {
4912
  // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.int32_data)
4913
  return int32_data_;
4914
}
4915
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
4916
TensorProto::mutable_int32_data() {
4917
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.int32_data)
4918
  return &int32_data_;
4919
}
4920

4921
// repeated bytes string_data = 6;
4922
inline int TensorProto::string_data_size() const {
4923
  return string_data_.size();
4924
}
4925
inline void TensorProto::clear_string_data() {
4926
  string_data_.Clear();
4927
}
4928
inline const ::std::string& TensorProto::string_data(int index) const {
4929
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.string_data)
4930
  return string_data_.Get(index);
4931
}
4932
inline ::std::string* TensorProto::mutable_string_data(int index) {
4933
  // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.string_data)
4934
  return string_data_.Mutable(index);
4935
}
4936
inline void TensorProto::set_string_data(int index, const ::std::string& value) {
4937
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.string_data)
4938
  string_data_.Mutable(index)->assign(value);
4939
}
4940
#if LANG_CXX11
4941
inline void TensorProto::set_string_data(int index, ::std::string&& value) {
4942
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.string_data)
4943
  string_data_.Mutable(index)->assign(std::move(value));
4944
}
4945
#endif
4946
inline void TensorProto::set_string_data(int index, const char* value) {
4947
  GOOGLE_DCHECK(value != NULL);
4948
  string_data_.Mutable(index)->assign(value);
4949
  // @@protoc_insertion_point(field_set_char:opencv_onnx.TensorProto.string_data)
4950
}
4951
inline void TensorProto::set_string_data(int index, const void* value, size_t size) {
4952
  string_data_.Mutable(index)->assign(
4953
    reinterpret_cast<const char*>(value), size);
4954
  // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorProto.string_data)
4955
}
4956
inline ::std::string* TensorProto::add_string_data() {
4957
  // @@protoc_insertion_point(field_add_mutable:opencv_onnx.TensorProto.string_data)
4958
  return string_data_.Add();
4959
}
4960
inline void TensorProto::add_string_data(const ::std::string& value) {
4961
  string_data_.Add()->assign(value);
4962
  // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.string_data)
4963
}
4964
#if LANG_CXX11
4965
inline void TensorProto::add_string_data(::std::string&& value) {
4966
  string_data_.Add(std::move(value));
4967
  // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.string_data)
4968
}
4969
#endif
4970
inline void TensorProto::add_string_data(const char* value) {
4971
  GOOGLE_DCHECK(value != NULL);
4972
  string_data_.Add()->assign(value);
4973
  // @@protoc_insertion_point(field_add_char:opencv_onnx.TensorProto.string_data)
4974
}
4975
inline void TensorProto::add_string_data(const void* value, size_t size) {
4976
  string_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
4977
  // @@protoc_insertion_point(field_add_pointer:opencv_onnx.TensorProto.string_data)
4978
}
4979
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
4980
TensorProto::string_data() const {
4981
  // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.string_data)
4982
  return string_data_;
4983
}
4984
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
4985
TensorProto::mutable_string_data() {
4986
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.string_data)
4987
  return &string_data_;
4988
}
4989

4990
// repeated int64 int64_data = 7 [packed = true];
4991
inline int TensorProto::int64_data_size() const {
4992
  return int64_data_.size();
4993
}
4994
inline void TensorProto::clear_int64_data() {
4995
  int64_data_.Clear();
4996
}
4997
inline ::google::protobuf::int64 TensorProto::int64_data(int index) const {
4998
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.int64_data)
4999
  return int64_data_.Get(index);
5000
}
5001
inline void TensorProto::set_int64_data(int index, ::google::protobuf::int64 value) {
5002
  int64_data_.Set(index, value);
5003
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.int64_data)
5004
}
5005
inline void TensorProto::add_int64_data(::google::protobuf::int64 value) {
5006
  int64_data_.Add(value);
5007
  // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.int64_data)
5008
}
5009
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
5010
TensorProto::int64_data() const {
5011
  // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.int64_data)
5012
  return int64_data_;
5013
}
5014
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
5015
TensorProto::mutable_int64_data() {
5016
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.int64_data)
5017
  return &int64_data_;
5018
}
5019

5020
// optional string name = 8;
5021
inline bool TensorProto::has_name() const {
5022
  return (_has_bits_[0] & 0x00000001u) != 0;
5023
}
5024
inline void TensorProto::set_has_name() {
5025
  _has_bits_[0] |= 0x00000001u;
5026
}
5027
inline void TensorProto::clear_has_name() {
5028
  _has_bits_[0] &= ~0x00000001u;
5029
}
5030
inline void TensorProto::clear_name() {
5031
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5032
  clear_has_name();
5033
}
5034
inline const ::std::string& TensorProto::name() const {
5035
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.name)
5036
  return name_.GetNoArena();
5037
}
5038
inline void TensorProto::set_name(const ::std::string& value) {
5039
  set_has_name();
5040
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5041
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.name)
5042
}
5043
#if LANG_CXX11
5044
inline void TensorProto::set_name(::std::string&& value) {
5045
  set_has_name();
5046
  name_.SetNoArena(
5047
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5048
  // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorProto.name)
5049
}
5050
#endif
5051
inline void TensorProto::set_name(const char* value) {
5052
  GOOGLE_DCHECK(value != NULL);
5053
  set_has_name();
5054
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5055
  // @@protoc_insertion_point(field_set_char:opencv_onnx.TensorProto.name)
5056
}
5057
inline void TensorProto::set_name(const char* value, size_t size) {
5058
  set_has_name();
5059
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5060
      ::std::string(reinterpret_cast<const char*>(value), size));
5061
  // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorProto.name)
5062
}
5063
inline ::std::string* TensorProto::mutable_name() {
5064
  set_has_name();
5065
  // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.name)
5066
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5067
}
5068
inline ::std::string* TensorProto::release_name() {
5069
  // @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.name)
5070
  clear_has_name();
5071
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5072
}
5073
inline void TensorProto::set_allocated_name(::std::string* name) {
5074
  if (name != NULL) {
5075
    set_has_name();
5076
  } else {
5077
    clear_has_name();
5078
  }
5079
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
5080
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.name)
5081
}
5082

5083
// optional string doc_string = 12;
5084
inline bool TensorProto::has_doc_string() const {
5085
  return (_has_bits_[0] & 0x00000004u) != 0;
5086
}
5087
inline void TensorProto::set_has_doc_string() {
5088
  _has_bits_[0] |= 0x00000004u;
5089
}
5090
inline void TensorProto::clear_has_doc_string() {
5091
  _has_bits_[0] &= ~0x00000004u;
5092
}
5093
inline void TensorProto::clear_doc_string() {
5094
  doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5095
  clear_has_doc_string();
5096
}
5097
inline const ::std::string& TensorProto::doc_string() const {
5098
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.doc_string)
5099
  return doc_string_.GetNoArena();
5100
}
5101
inline void TensorProto::set_doc_string(const ::std::string& value) {
5102
  set_has_doc_string();
5103
  doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5104
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.doc_string)
5105
}
5106
#if LANG_CXX11
5107
inline void TensorProto::set_doc_string(::std::string&& value) {
5108
  set_has_doc_string();
5109
  doc_string_.SetNoArena(
5110
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5111
  // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorProto.doc_string)
5112
}
5113
#endif
5114
inline void TensorProto::set_doc_string(const char* value) {
5115
  GOOGLE_DCHECK(value != NULL);
5116
  set_has_doc_string();
5117
  doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5118
  // @@protoc_insertion_point(field_set_char:opencv_onnx.TensorProto.doc_string)
5119
}
5120
inline void TensorProto::set_doc_string(const char* value, size_t size) {
5121
  set_has_doc_string();
5122
  doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5123
      ::std::string(reinterpret_cast<const char*>(value), size));
5124
  // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorProto.doc_string)
5125
}
5126
inline ::std::string* TensorProto::mutable_doc_string() {
5127
  set_has_doc_string();
5128
  // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.doc_string)
5129
  return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5130
}
5131
inline ::std::string* TensorProto::release_doc_string() {
5132
  // @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.doc_string)
5133
  clear_has_doc_string();
5134
  return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5135
}
5136
inline void TensorProto::set_allocated_doc_string(::std::string* doc_string) {
5137
  if (doc_string != NULL) {
5138
    set_has_doc_string();
5139
  } else {
5140
    clear_has_doc_string();
5141
  }
5142
  doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
5143
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.doc_string)
5144
}
5145

5146
// optional bytes raw_data = 9;
5147
inline bool TensorProto::has_raw_data() const {
5148
  return (_has_bits_[0] & 0x00000002u) != 0;
5149
}
5150
inline void TensorProto::set_has_raw_data() {
5151
  _has_bits_[0] |= 0x00000002u;
5152
}
5153
inline void TensorProto::clear_has_raw_data() {
5154
  _has_bits_[0] &= ~0x00000002u;
5155
}
5156
inline void TensorProto::clear_raw_data() {
5157
  raw_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5158
  clear_has_raw_data();
5159
}
5160
inline const ::std::string& TensorProto::raw_data() const {
5161
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.raw_data)
5162
  return raw_data_.GetNoArena();
5163
}
5164
inline void TensorProto::set_raw_data(const ::std::string& value) {
5165
  set_has_raw_data();
5166
  raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5167
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.raw_data)
5168
}
5169
#if LANG_CXX11
5170
inline void TensorProto::set_raw_data(::std::string&& value) {
5171
  set_has_raw_data();
5172
  raw_data_.SetNoArena(
5173
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5174
  // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorProto.raw_data)
5175
}
5176
#endif
5177
inline void TensorProto::set_raw_data(const char* value) {
5178
  GOOGLE_DCHECK(value != NULL);
5179
  set_has_raw_data();
5180
  raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5181
  // @@protoc_insertion_point(field_set_char:opencv_onnx.TensorProto.raw_data)
5182
}
5183
inline void TensorProto::set_raw_data(const void* value, size_t size) {
5184
  set_has_raw_data();
5185
  raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5186
      ::std::string(reinterpret_cast<const char*>(value), size));
5187
  // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorProto.raw_data)
5188
}
5189
inline ::std::string* TensorProto::mutable_raw_data() {
5190
  set_has_raw_data();
5191
  // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.raw_data)
5192
  return raw_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5193
}
5194
inline ::std::string* TensorProto::release_raw_data() {
5195
  // @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.raw_data)
5196
  clear_has_raw_data();
5197
  return raw_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5198
}
5199
inline void TensorProto::set_allocated_raw_data(::std::string* raw_data) {
5200
  if (raw_data != NULL) {
5201
    set_has_raw_data();
5202
  } else {
5203
    clear_has_raw_data();
5204
  }
5205
  raw_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), raw_data);
5206
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.raw_data)
5207
}
5208

5209
// repeated double double_data = 10 [packed = true];
5210
inline int TensorProto::double_data_size() const {
5211
  return double_data_.size();
5212
}
5213
inline void TensorProto::clear_double_data() {
5214
  double_data_.Clear();
5215
}
5216
inline double TensorProto::double_data(int index) const {
5217
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.double_data)
5218
  return double_data_.Get(index);
5219
}
5220
inline void TensorProto::set_double_data(int index, double value) {
5221
  double_data_.Set(index, value);
5222
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.double_data)
5223
}
5224
inline void TensorProto::add_double_data(double value) {
5225
  double_data_.Add(value);
5226
  // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.double_data)
5227
}
5228
inline const ::google::protobuf::RepeatedField< double >&
5229
TensorProto::double_data() const {
5230
  // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.double_data)
5231
  return double_data_;
5232
}
5233
inline ::google::protobuf::RepeatedField< double >*
5234
TensorProto::mutable_double_data() {
5235
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.double_data)
5236
  return &double_data_;
5237
}
5238

5239
// repeated uint64 uint64_data = 11 [packed = true];
5240
inline int TensorProto::uint64_data_size() const {
5241
  return uint64_data_.size();
5242
}
5243
inline void TensorProto::clear_uint64_data() {
5244
  uint64_data_.Clear();
5245
}
5246
inline ::google::protobuf::uint64 TensorProto::uint64_data(int index) const {
5247
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.uint64_data)
5248
  return uint64_data_.Get(index);
5249
}
5250
inline void TensorProto::set_uint64_data(int index, ::google::protobuf::uint64 value) {
5251
  uint64_data_.Set(index, value);
5252
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.uint64_data)
5253
}
5254
inline void TensorProto::add_uint64_data(::google::protobuf::uint64 value) {
5255
  uint64_data_.Add(value);
5256
  // @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.uint64_data)
5257
}
5258
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
5259
TensorProto::uint64_data() const {
5260
  // @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.uint64_data)
5261
  return uint64_data_;
5262
}
5263
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
5264
TensorProto::mutable_uint64_data() {
5265
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.uint64_data)
5266
  return &uint64_data_;
5267
}
5268

5269
// -------------------------------------------------------------------
5270

5271
// TensorShapeProto_Dimension
5272

5273
// optional int64 dim_value = 1;
5274
inline bool TensorShapeProto_Dimension::has_dim_value() const {
5275
  return value_case() == kDimValue;
5276
}
5277
inline void TensorShapeProto_Dimension::set_has_dim_value() {
5278
  _oneof_case_[0] = kDimValue;
5279
}
5280
inline void TensorShapeProto_Dimension::clear_dim_value() {
5281
  if (has_dim_value()) {
5282
    value_.dim_value_ = GOOGLE_LONGLONG(0);
5283
    clear_has_value();
5284
  }
5285
}
5286
inline ::google::protobuf::int64 TensorShapeProto_Dimension::dim_value() const {
5287
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.dim_value)
5288
  if (has_dim_value()) {
5289
    return value_.dim_value_;
5290
  }
5291
  return GOOGLE_LONGLONG(0);
5292
}
5293
inline void TensorShapeProto_Dimension::set_dim_value(::google::protobuf::int64 value) {
5294
  if (!has_dim_value()) {
5295
    clear_value();
5296
    set_has_dim_value();
5297
  }
5298
  value_.dim_value_ = value;
5299
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_value)
5300
}
5301

5302
// optional string dim_param = 2;
5303
inline bool TensorShapeProto_Dimension::has_dim_param() const {
5304
  return value_case() == kDimParam;
5305
}
5306
inline void TensorShapeProto_Dimension::set_has_dim_param() {
5307
  _oneof_case_[0] = kDimParam;
5308
}
5309
inline void TensorShapeProto_Dimension::clear_dim_param() {
5310
  if (has_dim_param()) {
5311
    value_.dim_param_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5312
    clear_has_value();
5313
  }
5314
}
5315
inline const ::std::string& TensorShapeProto_Dimension::dim_param() const {
5316
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5317
  if (has_dim_param()) {
5318
    return value_.dim_param_.GetNoArena();
5319
  }
5320
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
5321
}
5322
inline void TensorShapeProto_Dimension::set_dim_param(const ::std::string& value) {
5323
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5324
  if (!has_dim_param()) {
5325
    clear_value();
5326
    set_has_dim_param();
5327
    value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5328
  }
5329
  value_.dim_param_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5330
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5331
}
5332
#if LANG_CXX11
5333
inline void TensorShapeProto_Dimension::set_dim_param(::std::string&& value) {
5334
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5335
  if (!has_dim_param()) {
5336
    clear_value();
5337
    set_has_dim_param();
5338
    value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5339
  }
5340
  value_.dim_param_.SetNoArena(
5341
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5342
  // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5343
}
5344
#endif
5345
inline void TensorShapeProto_Dimension::set_dim_param(const char* value) {
5346
  GOOGLE_DCHECK(value != NULL);
5347
  if (!has_dim_param()) {
5348
    clear_value();
5349
    set_has_dim_param();
5350
    value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5351
  }
5352
  value_.dim_param_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5353
      ::std::string(value));
5354
  // @@protoc_insertion_point(field_set_char:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5355
}
5356
inline void TensorShapeProto_Dimension::set_dim_param(const char* value, size_t size) {
5357
  if (!has_dim_param()) {
5358
    clear_value();
5359
    set_has_dim_param();
5360
    value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5361
  }
5362
  value_.dim_param_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
5363
      reinterpret_cast<const char*>(value), size));
5364
  // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5365
}
5366
inline ::std::string* TensorShapeProto_Dimension::mutable_dim_param() {
5367
  if (!has_dim_param()) {
5368
    clear_value();
5369
    set_has_dim_param();
5370
    value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5371
  }
5372
  // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5373
  return value_.dim_param_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5374
}
5375
inline ::std::string* TensorShapeProto_Dimension::release_dim_param() {
5376
  // @@protoc_insertion_point(field_release:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5377
  if (has_dim_param()) {
5378
    clear_has_value();
5379
    return value_.dim_param_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5380
  } else {
5381
    return NULL;
5382
  }
5383
}
5384
inline void TensorShapeProto_Dimension::set_allocated_dim_param(::std::string* dim_param) {
5385
  if (!has_dim_param()) {
5386
    value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5387
  }
5388
  clear_value();
5389
  if (dim_param != NULL) {
5390
    set_has_dim_param();
5391
    value_.dim_param_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5392
        dim_param);
5393
  }
5394
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorShapeProto.Dimension.dim_param)
5395
}
5396

5397
// optional string denotation = 3;
5398
inline bool TensorShapeProto_Dimension::has_denotation() const {
5399
  return (_has_bits_[0] & 0x00000001u) != 0;
5400
}
5401
inline void TensorShapeProto_Dimension::set_has_denotation() {
5402
  _has_bits_[0] |= 0x00000001u;
5403
}
5404
inline void TensorShapeProto_Dimension::clear_has_denotation() {
5405
  _has_bits_[0] &= ~0x00000001u;
5406
}
5407
inline void TensorShapeProto_Dimension::clear_denotation() {
5408
  denotation_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5409
  clear_has_denotation();
5410
}
5411
inline const ::std::string& TensorShapeProto_Dimension::denotation() const {
5412
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.denotation)
5413
  return denotation_.GetNoArena();
5414
}
5415
inline void TensorShapeProto_Dimension::set_denotation(const ::std::string& value) {
5416
  set_has_denotation();
5417
  denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5418
  // @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.denotation)
5419
}
5420
#if LANG_CXX11
5421
inline void TensorShapeProto_Dimension::set_denotation(::std::string&& value) {
5422
  set_has_denotation();
5423
  denotation_.SetNoArena(
5424
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5425
  // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorShapeProto.Dimension.denotation)
5426
}
5427
#endif
5428
inline void TensorShapeProto_Dimension::set_denotation(const char* value) {
5429
  GOOGLE_DCHECK(value != NULL);
5430
  set_has_denotation();
5431
  denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5432
  // @@protoc_insertion_point(field_set_char:opencv_onnx.TensorShapeProto.Dimension.denotation)
5433
}
5434
inline void TensorShapeProto_Dimension::set_denotation(const char* value, size_t size) {
5435
  set_has_denotation();
5436
  denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5437
      ::std::string(reinterpret_cast<const char*>(value), size));
5438
  // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorShapeProto.Dimension.denotation)
5439
}
5440
inline ::std::string* TensorShapeProto_Dimension::mutable_denotation() {
5441
  set_has_denotation();
5442
  // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.Dimension.denotation)
5443
  return denotation_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5444
}
5445
inline ::std::string* TensorShapeProto_Dimension::release_denotation() {
5446
  // @@protoc_insertion_point(field_release:opencv_onnx.TensorShapeProto.Dimension.denotation)
5447
  clear_has_denotation();
5448
  return denotation_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5449
}
5450
inline void TensorShapeProto_Dimension::set_allocated_denotation(::std::string* denotation) {
5451
  if (denotation != NULL) {
5452
    set_has_denotation();
5453
  } else {
5454
    clear_has_denotation();
5455
  }
5456
  denotation_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), denotation);
5457
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorShapeProto.Dimension.denotation)
5458
}
5459

5460
inline bool TensorShapeProto_Dimension::has_value() const {
5461
  return value_case() != VALUE_NOT_SET;
5462
}
5463
inline void TensorShapeProto_Dimension::clear_has_value() {
5464
  _oneof_case_[0] = VALUE_NOT_SET;
5465
}
5466
inline TensorShapeProto_Dimension::ValueCase TensorShapeProto_Dimension::value_case() const {
5467
  return TensorShapeProto_Dimension::ValueCase(_oneof_case_[0]);
5468
}
5469
// -------------------------------------------------------------------
5470

5471
// TensorShapeProto
5472

5473
// repeated .opencv_onnx.TensorShapeProto.Dimension dim = 1;
5474
inline int TensorShapeProto::dim_size() const {
5475
  return dim_.size();
5476
}
5477
inline void TensorShapeProto::clear_dim() {
5478
  dim_.Clear();
5479
}
5480
inline const ::opencv_onnx::TensorShapeProto_Dimension& TensorShapeProto::dim(int index) const {
5481
  // @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.dim)
5482
  return dim_.Get(index);
5483
}
5484
inline ::opencv_onnx::TensorShapeProto_Dimension* TensorShapeProto::mutable_dim(int index) {
5485
  // @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.dim)
5486
  return dim_.Mutable(index);
5487
}
5488
inline ::opencv_onnx::TensorShapeProto_Dimension* TensorShapeProto::add_dim() {
5489
  // @@protoc_insertion_point(field_add:opencv_onnx.TensorShapeProto.dim)
5490
  return dim_.Add();
5491
}
5492
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >*
5493
TensorShapeProto::mutable_dim() {
5494
  // @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorShapeProto.dim)
5495
  return &dim_;
5496
}
5497
inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >&
5498
TensorShapeProto::dim() const {
5499
  // @@protoc_insertion_point(field_list:opencv_onnx.TensorShapeProto.dim)
5500
  return dim_;
5501
}
5502

5503
// -------------------------------------------------------------------
5504

5505
// TypeProto_Tensor
5506

5507
// optional .opencv_onnx.TensorProto.DataType elem_type = 1;
5508
inline bool TypeProto_Tensor::has_elem_type() const {
5509
  return (_has_bits_[0] & 0x00000002u) != 0;
5510
}
5511
inline void TypeProto_Tensor::set_has_elem_type() {
5512
  _has_bits_[0] |= 0x00000002u;
5513
}
5514
inline void TypeProto_Tensor::clear_has_elem_type() {
5515
  _has_bits_[0] &= ~0x00000002u;
5516
}
5517
inline void TypeProto_Tensor::clear_elem_type() {
5518
  elem_type_ = 0;
5519
  clear_has_elem_type();
5520
}
5521
inline ::opencv_onnx::TensorProto_DataType TypeProto_Tensor::elem_type() const {
5522
  // @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Tensor.elem_type)
5523
  return static_cast< ::opencv_onnx::TensorProto_DataType >(elem_type_);
5524
}
5525
inline void TypeProto_Tensor::set_elem_type(::opencv_onnx::TensorProto_DataType value) {
5526
  assert(::opencv_onnx::TensorProto_DataType_IsValid(value));
5527
  set_has_elem_type();
5528
  elem_type_ = value;
5529
  // @@protoc_insertion_point(field_set:opencv_onnx.TypeProto.Tensor.elem_type)
5530
}
5531

5532
// optional .opencv_onnx.TensorShapeProto shape = 2;
5533
inline bool TypeProto_Tensor::has_shape() const {
5534
  return (_has_bits_[0] & 0x00000001u) != 0;
5535
}
5536
inline void TypeProto_Tensor::set_has_shape() {
5537
  _has_bits_[0] |= 0x00000001u;
5538
}
5539
inline void TypeProto_Tensor::clear_has_shape() {
5540
  _has_bits_[0] &= ~0x00000001u;
5541
}
5542
inline void TypeProto_Tensor::clear_shape() {
5543
  if (shape_ != NULL) shape_->Clear();
5544
  clear_has_shape();
5545
}
5546
inline const ::opencv_onnx::TensorShapeProto& TypeProto_Tensor::shape() const {
5547
  const ::opencv_onnx::TensorShapeProto* p = shape_;
5548
  // @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Tensor.shape)
5549
  return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::TensorShapeProto*>(
5550
      &::opencv_onnx::_TensorShapeProto_default_instance_);
5551
}
5552
inline ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::release_shape() {
5553
  // @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.Tensor.shape)
5554
  clear_has_shape();
5555
  ::opencv_onnx::TensorShapeProto* temp = shape_;
5556
  shape_ = NULL;
5557
  return temp;
5558
}
5559
inline ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::mutable_shape() {
5560
  set_has_shape();
5561
  if (shape_ == NULL) {
5562
    shape_ = new ::opencv_onnx::TensorShapeProto;
5563
  }
5564
  // @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.Tensor.shape)
5565
  return shape_;
5566
}
5567
inline void TypeProto_Tensor::set_allocated_shape(::opencv_onnx::TensorShapeProto* shape) {
5568
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
5569
  if (message_arena == NULL) {
5570
    delete shape_;
5571
  }
5572
  if (shape) {
5573
    ::google::protobuf::Arena* submessage_arena = NULL;
5574
    if (message_arena != submessage_arena) {
5575
      shape = ::google::protobuf::internal::GetOwnedMessage(
5576
          message_arena, shape, submessage_arena);
5577
    }
5578
    set_has_shape();
5579
  } else {
5580
    clear_has_shape();
5581
  }
5582
  shape_ = shape;
5583
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.Tensor.shape)
5584
}
5585

5586
// -------------------------------------------------------------------
5587

5588
// TypeProto
5589

5590
// optional .opencv_onnx.TypeProto.Tensor tensor_type = 1;
5591
inline bool TypeProto::has_tensor_type() const {
5592
  return value_case() == kTensorType;
5593
}
5594
inline void TypeProto::set_has_tensor_type() {
5595
  _oneof_case_[0] = kTensorType;
5596
}
5597
inline void TypeProto::clear_tensor_type() {
5598
  if (has_tensor_type()) {
5599
    delete value_.tensor_type_;
5600
    clear_has_value();
5601
  }
5602
}
5603
inline ::opencv_onnx::TypeProto_Tensor* TypeProto::release_tensor_type() {
5604
  // @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.tensor_type)
5605
  if (has_tensor_type()) {
5606
    clear_has_value();
5607
      ::opencv_onnx::TypeProto_Tensor* temp = value_.tensor_type_;
5608
    value_.tensor_type_ = NULL;
5609
    return temp;
5610
  } else {
5611
    return NULL;
5612
  }
5613
}
5614
inline const ::opencv_onnx::TypeProto_Tensor& TypeProto::tensor_type() const {
5615
  // @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.tensor_type)
5616
  return has_tensor_type()
5617
      ? *value_.tensor_type_
5618
      : *reinterpret_cast< ::opencv_onnx::TypeProto_Tensor*>(&::opencv_onnx::_TypeProto_Tensor_default_instance_);
5619
}
5620
inline ::opencv_onnx::TypeProto_Tensor* TypeProto::mutable_tensor_type() {
5621
  if (!has_tensor_type()) {
5622
    clear_value();
5623
    set_has_tensor_type();
5624
    value_.tensor_type_ = new ::opencv_onnx::TypeProto_Tensor;
5625
  }
5626
  // @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.tensor_type)
5627
  return value_.tensor_type_;
5628
}
5629

5630
// optional string denotation = 6;
5631
inline bool TypeProto::has_denotation() const {
5632
  return (_has_bits_[0] & 0x00000001u) != 0;
5633
}
5634
inline void TypeProto::set_has_denotation() {
5635
  _has_bits_[0] |= 0x00000001u;
5636
}
5637
inline void TypeProto::clear_has_denotation() {
5638
  _has_bits_[0] &= ~0x00000001u;
5639
}
5640
inline void TypeProto::clear_denotation() {
5641
  denotation_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5642
  clear_has_denotation();
5643
}
5644
inline const ::std::string& TypeProto::denotation() const {
5645
  // @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.denotation)
5646
  return denotation_.GetNoArena();
5647
}
5648
inline void TypeProto::set_denotation(const ::std::string& value) {
5649
  set_has_denotation();
5650
  denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5651
  // @@protoc_insertion_point(field_set:opencv_onnx.TypeProto.denotation)
5652
}
5653
#if LANG_CXX11
5654
inline void TypeProto::set_denotation(::std::string&& value) {
5655
  set_has_denotation();
5656
  denotation_.SetNoArena(
5657
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5658
  // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TypeProto.denotation)
5659
}
5660
#endif
5661
inline void TypeProto::set_denotation(const char* value) {
5662
  GOOGLE_DCHECK(value != NULL);
5663
  set_has_denotation();
5664
  denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5665
  // @@protoc_insertion_point(field_set_char:opencv_onnx.TypeProto.denotation)
5666
}
5667
inline void TypeProto::set_denotation(const char* value, size_t size) {
5668
  set_has_denotation();
5669
  denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5670
      ::std::string(reinterpret_cast<const char*>(value), size));
5671
  // @@protoc_insertion_point(field_set_pointer:opencv_onnx.TypeProto.denotation)
5672
}
5673
inline ::std::string* TypeProto::mutable_denotation() {
5674
  set_has_denotation();
5675
  // @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.denotation)
5676
  return denotation_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5677
}
5678
inline ::std::string* TypeProto::release_denotation() {
5679
  // @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.denotation)
5680
  clear_has_denotation();
5681
  return denotation_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5682
}
5683
inline void TypeProto::set_allocated_denotation(::std::string* denotation) {
5684
  if (denotation != NULL) {
5685
    set_has_denotation();
5686
  } else {
5687
    clear_has_denotation();
5688
  }
5689
  denotation_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), denotation);
5690
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.denotation)
5691
}
5692

5693
inline bool TypeProto::has_value() const {
5694
  return value_case() != VALUE_NOT_SET;
5695
}
5696
inline void TypeProto::clear_has_value() {
5697
  _oneof_case_[0] = VALUE_NOT_SET;
5698
}
5699
inline TypeProto::ValueCase TypeProto::value_case() const {
5700
  return TypeProto::ValueCase(_oneof_case_[0]);
5701
}
5702
// -------------------------------------------------------------------
5703

5704
// OperatorSetIdProto
5705

5706
// optional string domain = 1;
5707
inline bool OperatorSetIdProto::has_domain() const {
5708
  return (_has_bits_[0] & 0x00000001u) != 0;
5709
}
5710
inline void OperatorSetIdProto::set_has_domain() {
5711
  _has_bits_[0] |= 0x00000001u;
5712
}
5713
inline void OperatorSetIdProto::clear_has_domain() {
5714
  _has_bits_[0] &= ~0x00000001u;
5715
}
5716
inline void OperatorSetIdProto::clear_domain() {
5717
  domain_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5718
  clear_has_domain();
5719
}
5720
inline const ::std::string& OperatorSetIdProto::domain() const {
5721
  // @@protoc_insertion_point(field_get:opencv_onnx.OperatorSetIdProto.domain)
5722
  return domain_.GetNoArena();
5723
}
5724
inline void OperatorSetIdProto::set_domain(const ::std::string& value) {
5725
  set_has_domain();
5726
  domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
5727
  // @@protoc_insertion_point(field_set:opencv_onnx.OperatorSetIdProto.domain)
5728
}
5729
#if LANG_CXX11
5730
inline void OperatorSetIdProto::set_domain(::std::string&& value) {
5731
  set_has_domain();
5732
  domain_.SetNoArena(
5733
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5734
  // @@protoc_insertion_point(field_set_rvalue:opencv_onnx.OperatorSetIdProto.domain)
5735
}
5736
#endif
5737
inline void OperatorSetIdProto::set_domain(const char* value) {
5738
  GOOGLE_DCHECK(value != NULL);
5739
  set_has_domain();
5740
  domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5741
  // @@protoc_insertion_point(field_set_char:opencv_onnx.OperatorSetIdProto.domain)
5742
}
5743
inline void OperatorSetIdProto::set_domain(const char* value, size_t size) {
5744
  set_has_domain();
5745
  domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
5746
      ::std::string(reinterpret_cast<const char*>(value), size));
5747
  // @@protoc_insertion_point(field_set_pointer:opencv_onnx.OperatorSetIdProto.domain)
5748
}
5749
inline ::std::string* OperatorSetIdProto::mutable_domain() {
5750
  set_has_domain();
5751
  // @@protoc_insertion_point(field_mutable:opencv_onnx.OperatorSetIdProto.domain)
5752
  return domain_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5753
}
5754
inline ::std::string* OperatorSetIdProto::release_domain() {
5755
  // @@protoc_insertion_point(field_release:opencv_onnx.OperatorSetIdProto.domain)
5756
  clear_has_domain();
5757
  return domain_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5758
}
5759
inline void OperatorSetIdProto::set_allocated_domain(::std::string* domain) {
5760
  if (domain != NULL) {
5761
    set_has_domain();
5762
  } else {
5763
    clear_has_domain();
5764
  }
5765
  domain_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), domain);
5766
  // @@protoc_insertion_point(field_set_allocated:opencv_onnx.OperatorSetIdProto.domain)
5767
}
5768

5769
// optional int64 version = 2;
5770
inline bool OperatorSetIdProto::has_version() const {
5771
  return (_has_bits_[0] & 0x00000002u) != 0;
5772
}
5773
inline void OperatorSetIdProto::set_has_version() {
5774
  _has_bits_[0] |= 0x00000002u;
5775
}
5776
inline void OperatorSetIdProto::clear_has_version() {
5777
  _has_bits_[0] &= ~0x00000002u;
5778
}
5779
inline void OperatorSetIdProto::clear_version() {
5780
  version_ = GOOGLE_LONGLONG(0);
5781
  clear_has_version();
5782
}
5783
inline ::google::protobuf::int64 OperatorSetIdProto::version() const {
5784
  // @@protoc_insertion_point(field_get:opencv_onnx.OperatorSetIdProto.version)
5785
  return version_;
5786
}
5787
inline void OperatorSetIdProto::set_version(::google::protobuf::int64 value) {
5788
  set_has_version();
5789
  version_ = value;
5790
  // @@protoc_insertion_point(field_set:opencv_onnx.OperatorSetIdProto.version)
5791
}
5792

5793
#ifdef __GNUC__
5794
  #pragma GCC diagnostic pop
5795
#endif  // __GNUC__
5796
// -------------------------------------------------------------------
5797

5798
// -------------------------------------------------------------------
5799

5800
// -------------------------------------------------------------------
5801

5802
// -------------------------------------------------------------------
5803

5804
// -------------------------------------------------------------------
5805

5806
// -------------------------------------------------------------------
5807

5808
// -------------------------------------------------------------------
5809

5810
// -------------------------------------------------------------------
5811

5812
// -------------------------------------------------------------------
5813

5814
// -------------------------------------------------------------------
5815

5816
// -------------------------------------------------------------------
5817

5818
// -------------------------------------------------------------------
5819

5820

5821
// @@protoc_insertion_point(namespace_scope)
5822

5823
}  // namespace opencv_onnx
5824

5825
namespace google {
5826
namespace protobuf {
5827

5828
template <> struct is_proto_enum< ::opencv_onnx::AttributeProto_AttributeType> : ::google::protobuf::internal::true_type {};
5829
template <>
5830
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_onnx::AttributeProto_AttributeType>() {
5831
  return ::opencv_onnx::AttributeProto_AttributeType_descriptor();
5832
}
5833
template <> struct is_proto_enum< ::opencv_onnx::TensorProto_DataType> : ::google::protobuf::internal::true_type {};
5834
template <>
5835
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_onnx::TensorProto_DataType>() {
5836
  return ::opencv_onnx::TensorProto_DataType_descriptor();
5837
}
5838
template <> struct is_proto_enum< ::opencv_onnx::Version> : ::google::protobuf::internal::true_type {};
5839
template <>
5840
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_onnx::Version>() {
5841
  return ::opencv_onnx::Version_descriptor();
5842
}
5843

5844
}  // namespace protobuf
5845
}  // namespace google
5846

5847
// @@protoc_insertion_point(global_scope)
5848

5849
#endif  // PROTOBUF_opencv_2donnx_2eproto__INCLUDED
5850

5851
Product

Resources

Company
