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