1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: caffe2.proto
3
4#ifndef PROTOBUF_caffe2_2eproto__INCLUDED
5#define PROTOBUF_caffe2_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 caffe2 {
31
32// Internal implementation detail -- do not call these.
33void protobuf_AddDesc_caffe2_2eproto();
34void protobuf_AssignDesc_caffe2_2eproto();
35void protobuf_ShutdownFile_caffe2_2eproto();
36
37class ExternalDataProto;
38class TensorProto;
39class TensorProto_Segment;
40class QTensorProto;
41class TensorProtos;
42class TensorShape;
43class TensorShapes;
44class TensorBoundShape;
45class TensorBoundShapes;
46class AOTConfig;
47class Argument;
48class DeviceOption;
49class OperatorDef;
50class MapFieldEntry;
51class BackendOptions;
52class PartitionInfo;
53class NetDef;
54class ExecutionStep;
55class PlanDef;
56class BlobProto;
57class DBReaderProto;
58
59enum ExternalDataProto_SourceType {
60 ExternalDataProto_SourceType_INLINE_CONTAINER = 0,
61 ExternalDataProto_SourceType_SIMPLE_FILE = 1
62};
63bool ExternalDataProto_SourceType_IsValid(int value);
64const ExternalDataProto_SourceType ExternalDataProto_SourceType_SourceType_MIN = ExternalDataProto_SourceType_INLINE_CONTAINER;
65const ExternalDataProto_SourceType ExternalDataProto_SourceType_SourceType_MAX = ExternalDataProto_SourceType_SIMPLE_FILE;
66const int ExternalDataProto_SourceType_SourceType_ARRAYSIZE = ExternalDataProto_SourceType_SourceType_MAX + 1;
67
68const ::google::protobuf::EnumDescriptor* ExternalDataProto_SourceType_descriptor();
69inline const ::std::string& ExternalDataProto_SourceType_Name(ExternalDataProto_SourceType value) {
70 return ::google::protobuf::internal::NameOfEnum(
71 ExternalDataProto_SourceType_descriptor(), value);
72}
73inline bool ExternalDataProto_SourceType_Parse(
74 const ::std::string& name, ExternalDataProto_SourceType* value) {
75 return ::google::protobuf::internal::ParseNamedEnum<ExternalDataProto_SourceType>(
76 ExternalDataProto_SourceType_descriptor(), name, value);
77}
78enum TensorProto_DataType {
79 TensorProto_DataType_UNDEFINED = 0,
80 TensorProto_DataType_FLOAT = 1,
81 TensorProto_DataType_INT32 = 2,
82 TensorProto_DataType_BYTE = 3,
83 TensorProto_DataType_STRING = 4,
84 TensorProto_DataType_BOOL = 5,
85 TensorProto_DataType_UINT8 = 6,
86 TensorProto_DataType_INT8 = 7,
87 TensorProto_DataType_UINT16 = 8,
88 TensorProto_DataType_INT16 = 9,
89 TensorProto_DataType_INT64 = 10,
90 TensorProto_DataType_FLOAT16 = 12,
91 TensorProto_DataType_DOUBLE = 13,
92 TensorProto_DataType_ZERO_COLLISION_HASH = 14
93};
94bool TensorProto_DataType_IsValid(int value);
95const TensorProto_DataType TensorProto_DataType_DataType_MIN = TensorProto_DataType_UNDEFINED;
96const TensorProto_DataType TensorProto_DataType_DataType_MAX = TensorProto_DataType_ZERO_COLLISION_HASH;
97const int TensorProto_DataType_DataType_ARRAYSIZE = TensorProto_DataType_DataType_MAX + 1;
98
99const ::google::protobuf::EnumDescriptor* TensorProto_DataType_descriptor();
100inline const ::std::string& TensorProto_DataType_Name(TensorProto_DataType value) {
101 return ::google::protobuf::internal::NameOfEnum(
102 TensorProto_DataType_descriptor(), value);
103}
104inline bool TensorProto_DataType_Parse(
105 const ::std::string& name, TensorProto_DataType* value) {
106 return ::google::protobuf::internal::ParseNamedEnum<TensorProto_DataType>(
107 TensorProto_DataType_descriptor(), name, value);
108}
109enum TensorProto_StorageType {
110 TensorProto_StorageType_TYPED = 1,
111 TensorProto_StorageType_RAW = 2,
112 TensorProto_StorageType_EXTERNAL = 3,
113 TensorProto_StorageType_NO_CONTENT = 4
114};
115bool TensorProto_StorageType_IsValid(int value);
116const TensorProto_StorageType TensorProto_StorageType_StorageType_MIN = TensorProto_StorageType_TYPED;
117const TensorProto_StorageType TensorProto_StorageType_StorageType_MAX = TensorProto_StorageType_NO_CONTENT;
118const int TensorProto_StorageType_StorageType_ARRAYSIZE = TensorProto_StorageType_StorageType_MAX + 1;
119
120const ::google::protobuf::EnumDescriptor* TensorProto_StorageType_descriptor();
121inline const ::std::string& TensorProto_StorageType_Name(TensorProto_StorageType value) {
122 return ::google::protobuf::internal::NameOfEnum(
123 TensorProto_StorageType_descriptor(), value);
124}
125inline bool TensorProto_StorageType_Parse(
126 const ::std::string& name, TensorProto_StorageType* value) {
127 return ::google::protobuf::internal::ParseNamedEnum<TensorProto_StorageType>(
128 TensorProto_StorageType_descriptor(), name, value);
129}
130enum TensorBoundShape_DimType {
131 TensorBoundShape_DimType_UNKNOWN = 0,
132 TensorBoundShape_DimType_CONSTANT = 1,
133 TensorBoundShape_DimType_BATCH = 2,
134 TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX = 3,
135 TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX_DEFAULT = 4,
136 TensorBoundShape_DimType_FEATURE_MAX = 5,
137 TensorBoundShape_DimType_FEATURE_MAX_DEFAULT = 6
138};
139bool TensorBoundShape_DimType_IsValid(int value);
140const TensorBoundShape_DimType TensorBoundShape_DimType_DimType_MIN = TensorBoundShape_DimType_UNKNOWN;
141const TensorBoundShape_DimType TensorBoundShape_DimType_DimType_MAX = TensorBoundShape_DimType_FEATURE_MAX_DEFAULT;
142const int TensorBoundShape_DimType_DimType_ARRAYSIZE = TensorBoundShape_DimType_DimType_MAX + 1;
143
144const ::google::protobuf::EnumDescriptor* TensorBoundShape_DimType_descriptor();
145inline const ::std::string& TensorBoundShape_DimType_Name(TensorBoundShape_DimType value) {
146 return ::google::protobuf::internal::NameOfEnum(
147 TensorBoundShape_DimType_descriptor(), value);
148}
149inline bool TensorBoundShape_DimType_Parse(
150 const ::std::string& name, TensorBoundShape_DimType* value) {
151 return ::google::protobuf::internal::ParseNamedEnum<TensorBoundShape_DimType>(
152 TensorBoundShape_DimType_descriptor(), name, value);
153}
154enum DeviceTypeProto {
155 PROTO_CPU = 0,
156 PROTO_CUDA = 1,
157 PROTO_MKLDNN = 2,
158 PROTO_OPENGL = 3,
159 PROTO_OPENCL = 4,
160 PROTO_IDEEP = 5,
161 PROTO_HIP = 6,
162 PROTO_FPGA = 7,
163 PROTO_MSNPU = 8,
164 PROTO_XLA = 9,
165 PROTO_COMPILE_TIME_MAX_DEVICE_TYPES = 10,
166 PROTO_ONLY_FOR_TEST = 20901
167};
168bool DeviceTypeProto_IsValid(int value);
169const DeviceTypeProto DeviceTypeProto_MIN = PROTO_CPU;
170const DeviceTypeProto DeviceTypeProto_MAX = PROTO_ONLY_FOR_TEST;
171const int DeviceTypeProto_ARRAYSIZE = DeviceTypeProto_MAX + 1;
172
173const ::google::protobuf::EnumDescriptor* DeviceTypeProto_descriptor();
174inline const ::std::string& DeviceTypeProto_Name(DeviceTypeProto value) {
175 return ::google::protobuf::internal::NameOfEnum(
176 DeviceTypeProto_descriptor(), value);
177}
178inline bool DeviceTypeProto_Parse(
179 const ::std::string& name, DeviceTypeProto* value) {
180 return ::google::protobuf::internal::ParseNamedEnum<DeviceTypeProto>(
181 DeviceTypeProto_descriptor(), name, value);
182}
183// ===================================================================
184
185class ExternalDataProto : public ::google::protobuf::Message {
186 public:
187 ExternalDataProto();
188 virtual ~ExternalDataProto();
189
190 ExternalDataProto(const ExternalDataProto& from);
191
192 inline ExternalDataProto& operator=(const ExternalDataProto& from) {
193 CopyFrom(from);
194 return *this;
195 }
196
197 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
198 return _unknown_fields_;
199 }
200
201 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
202 return &_unknown_fields_;
203 }
204
205 static const ::google::protobuf::Descriptor* descriptor();
206 static const ExternalDataProto& default_instance();
207
208 void Swap(ExternalDataProto* other);
209
210 // implements Message ----------------------------------------------
211
212 ExternalDataProto* New() const;
213 void CopyFrom(const ::google::protobuf::Message& from);
214 void MergeFrom(const ::google::protobuf::Message& from);
215 void CopyFrom(const ExternalDataProto& from);
216 void MergeFrom(const ExternalDataProto& from);
217 void Clear();
218 bool IsInitialized() const;
219
220 int ByteSize() const;
221 bool MergePartialFromCodedStream(
222 ::google::protobuf::io::CodedInputStream* input);
223 void SerializeWithCachedSizes(
224 ::google::protobuf::io::CodedOutputStream* output) const;
225 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
226 int GetCachedSize() const { return _cached_size_; }
227 private:
228 void SharedCtor();
229 void SharedDtor();
230 void SetCachedSize(int size) const;
231 public:
232 ::google::protobuf::Metadata GetMetadata() const;
233
234 // nested types ----------------------------------------------------
235
236 typedef ExternalDataProto_SourceType SourceType;
237 static const SourceType INLINE_CONTAINER = ExternalDataProto_SourceType_INLINE_CONTAINER;
238 static const SourceType SIMPLE_FILE = ExternalDataProto_SourceType_SIMPLE_FILE;
239 static inline bool SourceType_IsValid(int value) {
240 return ExternalDataProto_SourceType_IsValid(value);
241 }
242 static const SourceType SourceType_MIN =
243 ExternalDataProto_SourceType_SourceType_MIN;
244 static const SourceType SourceType_MAX =
245 ExternalDataProto_SourceType_SourceType_MAX;
246 static const int SourceType_ARRAYSIZE =
247 ExternalDataProto_SourceType_SourceType_ARRAYSIZE;
248 static inline const ::google::protobuf::EnumDescriptor*
249 SourceType_descriptor() {
250 return ExternalDataProto_SourceType_descriptor();
251 }
252 static inline const ::std::string& SourceType_Name(SourceType value) {
253 return ExternalDataProto_SourceType_Name(value);
254 }
255 static inline bool SourceType_Parse(const ::std::string& name,
256 SourceType* value) {
257 return ExternalDataProto_SourceType_Parse(name, value);
258 }
259
260 // accessors -------------------------------------------------------
261
262 // optional .caffe2.ExternalDataProto.SourceType source_type = 1 [default = INLINE_CONTAINER];
263 inline bool has_source_type() const;
264 inline void clear_source_type();
265 static const int kSourceTypeFieldNumber = 1;
266 inline ::caffe2::ExternalDataProto_SourceType source_type() const;
267 inline void set_source_type(::caffe2::ExternalDataProto_SourceType value);
268
269 // optional string record_id = 2;
270 inline bool has_record_id() const;
271 inline void clear_record_id();
272 static const int kRecordIdFieldNumber = 2;
273 inline const ::std::string& record_id() const;
274 inline void set_record_id(const ::std::string& value);
275 inline void set_record_id(const char* value);
276 inline void set_record_id(const char* value, size_t size);
277 inline ::std::string* mutable_record_id();
278 inline ::std::string* release_record_id();
279 inline void set_allocated_record_id(::std::string* record_id);
280
281 // optional uint64 record_size = 5;
282 inline bool has_record_size() const;
283 inline void clear_record_size();
284 static const int kRecordSizeFieldNumber = 5;
285 inline ::google::protobuf::uint64 record_size() const;
286 inline void set_record_size(::google::protobuf::uint64 value);
287
288 // optional int64 offset = 3 [default = 0];
289 inline bool has_offset() const;
290 inline void clear_offset();
291 static const int kOffsetFieldNumber = 3;
292 inline ::google::protobuf::int64 offset() const;
293 inline void set_offset(::google::protobuf::int64 value);
294
295 // repeated int64 strides = 4;
296 inline int strides_size() const;
297 inline void clear_strides();
298 static const int kStridesFieldNumber = 4;
299 inline ::google::protobuf::int64 strides(int index) const;
300 inline void set_strides(int index, ::google::protobuf::int64 value);
301 inline void add_strides(::google::protobuf::int64 value);
302 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
303 strides() const;
304 inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
305 mutable_strides();
306
307 // @@protoc_insertion_point(class_scope:caffe2.ExternalDataProto)
308 private:
309 inline void set_has_source_type();
310 inline void clear_has_source_type();
311 inline void set_has_record_id();
312 inline void clear_has_record_id();
313 inline void set_has_record_size();
314 inline void clear_has_record_size();
315 inline void set_has_offset();
316 inline void clear_has_offset();
317
318 ::google::protobuf::UnknownFieldSet _unknown_fields_;
319
320 ::google::protobuf::uint32 _has_bits_[1];
321 mutable int _cached_size_;
322 ::std::string* record_id_;
323 ::google::protobuf::uint64 record_size_;
324 ::google::protobuf::int64 offset_;
325 ::google::protobuf::RepeatedField< ::google::protobuf::int64 > strides_;
326 int source_type_;
327 friend void protobuf_AddDesc_caffe2_2eproto();
328 friend void protobuf_AssignDesc_caffe2_2eproto();
329 friend void protobuf_ShutdownFile_caffe2_2eproto();
330
331 void InitAsDefaultInstance();
332 static ExternalDataProto* default_instance_;
333};
334// -------------------------------------------------------------------
335
336class TensorProto_Segment : public ::google::protobuf::Message {
337 public:
338 TensorProto_Segment();
339 virtual ~TensorProto_Segment();
340
341 TensorProto_Segment(const TensorProto_Segment& from);
342
343 inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
344 CopyFrom(from);
345 return *this;
346 }
347
348 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
349 return _unknown_fields_;
350 }
351
352 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
353 return &_unknown_fields_;
354 }
355
356 static const ::google::protobuf::Descriptor* descriptor();
357 static const TensorProto_Segment& default_instance();
358
359 void Swap(TensorProto_Segment* other);
360
361 // implements Message ----------------------------------------------
362
363 TensorProto_Segment* New() const;
364 void CopyFrom(const ::google::protobuf::Message& from);
365 void MergeFrom(const ::google::protobuf::Message& from);
366 void CopyFrom(const TensorProto_Segment& from);
367 void MergeFrom(const TensorProto_Segment& from);
368 void Clear();
369 bool IsInitialized() const;
370
371 int ByteSize() const;
372 bool MergePartialFromCodedStream(
373 ::google::protobuf::io::CodedInputStream* input);
374 void SerializeWithCachedSizes(
375 ::google::protobuf::io::CodedOutputStream* output) const;
376 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
377 int GetCachedSize() const { return _cached_size_; }
378 private:
379 void SharedCtor();
380 void SharedDtor();
381 void SetCachedSize(int size) const;
382 public:
383 ::google::protobuf::Metadata GetMetadata() const;
384
385 // nested types ----------------------------------------------------
386
387 // accessors -------------------------------------------------------
388
389 // required int64 begin = 1;
390 inline bool has_begin() const;
391 inline void clear_begin();
392 static const int kBeginFieldNumber = 1;
393 inline ::google::protobuf::int64 begin() const;
394 inline void set_begin(::google::protobuf::int64 value);
395
396 // required int64 end = 2;
397 inline bool has_end() const;
398 inline void clear_end();
399 static const int kEndFieldNumber = 2;
400 inline ::google::protobuf::int64 end() const;
401 inline void set_end(::google::protobuf::int64 value);
402
403 // @@protoc_insertion_point(class_scope:caffe2.TensorProto.Segment)
404 private:
405 inline void set_has_begin();
406 inline void clear_has_begin();
407 inline void set_has_end();
408 inline void clear_has_end();
409
410 ::google::protobuf::UnknownFieldSet _unknown_fields_;
411
412 ::google::protobuf::uint32 _has_bits_[1];
413 mutable int _cached_size_;
414 ::google::protobuf::int64 begin_;
415 ::google::protobuf::int64 end_;
416 friend void protobuf_AddDesc_caffe2_2eproto();
417 friend void protobuf_AssignDesc_caffe2_2eproto();
418 friend void protobuf_ShutdownFile_caffe2_2eproto();
419
420 void InitAsDefaultInstance();
421 static TensorProto_Segment* default_instance_;
422};
423// -------------------------------------------------------------------
424
425class TensorProto : public ::google::protobuf::Message {
426 public:
427 TensorProto();
428 virtual ~TensorProto();
429
430 TensorProto(const TensorProto& from);
431
432 inline TensorProto& operator=(const TensorProto& from) {
433 CopyFrom(from);
434 return *this;
435 }
436
437 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
438 return _unknown_fields_;
439 }
440
441 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
442 return &_unknown_fields_;
443 }
444
445 static const ::google::protobuf::Descriptor* descriptor();
446 static const TensorProto& default_instance();
447
448 void Swap(TensorProto* other);
449
450 // implements Message ----------------------------------------------
451
452 TensorProto* New() const;
453 void CopyFrom(const ::google::protobuf::Message& from);
454 void MergeFrom(const ::google::protobuf::Message& from);
455 void CopyFrom(const TensorProto& from);
456 void MergeFrom(const TensorProto& from);
457 void Clear();
458 bool IsInitialized() const;
459
460 int ByteSize() const;
461 bool MergePartialFromCodedStream(
462 ::google::protobuf::io::CodedInputStream* input);
463 void SerializeWithCachedSizes(
464 ::google::protobuf::io::CodedOutputStream* output) const;
465 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
466 int GetCachedSize() const { return _cached_size_; }
467 private:
468 void SharedCtor();
469 void SharedDtor();
470 void SetCachedSize(int size) const;
471 public:
472 ::google::protobuf::Metadata GetMetadata() const;
473
474 // nested types ----------------------------------------------------
475
476 typedef TensorProto_Segment Segment;
477
478 typedef TensorProto_DataType DataType;
479 static const DataType UNDEFINED = TensorProto_DataType_UNDEFINED;
480 static const DataType FLOAT = TensorProto_DataType_FLOAT;
481 static const DataType INT32 = TensorProto_DataType_INT32;
482 static const DataType BYTE = TensorProto_DataType_BYTE;
483 static const DataType STRING = TensorProto_DataType_STRING;
484 static const DataType BOOL = TensorProto_DataType_BOOL;
485 static const DataType UINT8 = TensorProto_DataType_UINT8;
486 static const DataType INT8 = TensorProto_DataType_INT8;
487 static const DataType UINT16 = TensorProto_DataType_UINT16;
488 static const DataType INT16 = TensorProto_DataType_INT16;
489 static const DataType INT64 = TensorProto_DataType_INT64;
490 static const DataType FLOAT16 = TensorProto_DataType_FLOAT16;
491 static const DataType DOUBLE = TensorProto_DataType_DOUBLE;
492 static const DataType ZERO_COLLISION_HASH = TensorProto_DataType_ZERO_COLLISION_HASH;
493 static inline bool DataType_IsValid(int value) {
494 return TensorProto_DataType_IsValid(value);
495 }
496 static const DataType DataType_MIN =
497 TensorProto_DataType_DataType_MIN;
498 static const DataType DataType_MAX =
499 TensorProto_DataType_DataType_MAX;
500 static const int DataType_ARRAYSIZE =
501 TensorProto_DataType_DataType_ARRAYSIZE;
502 static inline const ::google::protobuf::EnumDescriptor*
503 DataType_descriptor() {
504 return TensorProto_DataType_descriptor();
505 }
506 static inline const ::std::string& DataType_Name(DataType value) {
507 return TensorProto_DataType_Name(value);
508 }
509 static inline bool DataType_Parse(const ::std::string& name,
510 DataType* value) {
511 return TensorProto_DataType_Parse(name, value);
512 }
513
514 typedef TensorProto_StorageType StorageType;
515 static const StorageType TYPED = TensorProto_StorageType_TYPED;
516 static const StorageType RAW = TensorProto_StorageType_RAW;
517 static const StorageType EXTERNAL = TensorProto_StorageType_EXTERNAL;
518 static const StorageType NO_CONTENT = TensorProto_StorageType_NO_CONTENT;
519 static inline bool StorageType_IsValid(int value) {
520 return TensorProto_StorageType_IsValid(value);
521 }
522 static const StorageType StorageType_MIN =
523 TensorProto_StorageType_StorageType_MIN;
524 static const StorageType StorageType_MAX =
525 TensorProto_StorageType_StorageType_MAX;
526 static const int StorageType_ARRAYSIZE =
527 TensorProto_StorageType_StorageType_ARRAYSIZE;
528 static inline const ::google::protobuf::EnumDescriptor*
529 StorageType_descriptor() {
530 return TensorProto_StorageType_descriptor();
531 }
532 static inline const ::std::string& StorageType_Name(StorageType value) {
533 return TensorProto_StorageType_Name(value);
534 }
535 static inline bool StorageType_Parse(const ::std::string& name,
536 StorageType* value) {
537 return TensorProto_StorageType_Parse(name, value);
538 }
539
540 // accessors -------------------------------------------------------
541
542 // repeated int64 dims = 1;
543 inline int dims_size() const;
544 inline void clear_dims();
545 static const int kDimsFieldNumber = 1;
546 inline ::google::protobuf::int64 dims(int index) const;
547 inline void set_dims(int index, ::google::protobuf::int64 value);
548 inline void add_dims(::google::protobuf::int64 value);
549 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
550 dims() const;
551 inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
552 mutable_dims();
553
554 // optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT];
555 inline bool has_data_type() const;
556 inline void clear_data_type();
557 static const int kDataTypeFieldNumber = 2;
558 inline ::caffe2::TensorProto_DataType data_type() const;
559 inline void set_data_type(::caffe2::TensorProto_DataType value);
560
561 // optional .caffe2.TensorProto.StorageType storage_type = 12 [default = TYPED];
562 inline bool has_storage_type() const;
563 inline void clear_storage_type();
564 static const int kStorageTypeFieldNumber = 12;
565 inline ::caffe2::TensorProto_StorageType storage_type() const;
566 inline void set_storage_type(::caffe2::TensorProto_StorageType value);
567
568 // repeated float float_data = 3 [packed = true];
569 inline int float_data_size() const;
570 inline void clear_float_data();
571 static const int kFloatDataFieldNumber = 3;
572 inline float float_data(int index) const;
573 inline void set_float_data(int index, float value);
574 inline void add_float_data(float value);
575 inline const ::google::protobuf::RepeatedField< float >&
576 float_data() const;
577 inline ::google::protobuf::RepeatedField< float >*
578 mutable_float_data();
579
580 // repeated int32 int32_data = 4 [packed = true];
581 inline int int32_data_size() const;
582 inline void clear_int32_data();
583 static const int kInt32DataFieldNumber = 4;
584 inline ::google::protobuf::int32 int32_data(int index) const;
585 inline void set_int32_data(int index, ::google::protobuf::int32 value);
586 inline void add_int32_data(::google::protobuf::int32 value);
587 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
588 int32_data() const;
589 inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
590 mutable_int32_data();
591
592 // optional bytes byte_data = 5;
593 inline bool has_byte_data() const;
594 inline void clear_byte_data();
595 static const int kByteDataFieldNumber = 5;
596 inline const ::std::string& byte_data() const;
597 inline void set_byte_data(const ::std::string& value);
598 inline void set_byte_data(const char* value);
599 inline void set_byte_data(const void* value, size_t size);
600 inline ::std::string* mutable_byte_data();
601 inline ::std::string* release_byte_data();
602 inline void set_allocated_byte_data(::std::string* byte_data);
603
604 // repeated bytes string_data = 6;
605 inline int string_data_size() const;
606 inline void clear_string_data();
607 static const int kStringDataFieldNumber = 6;
608 inline const ::std::string& string_data(int index) const;
609 inline ::std::string* mutable_string_data(int index);
610 inline void set_string_data(int index, const ::std::string& value);
611 inline void set_string_data(int index, const char* value);
612 inline void set_string_data(int index, const void* value, size_t size);
613 inline ::std::string* add_string_data();
614 inline void add_string_data(const ::std::string& value);
615 inline void add_string_data(const char* value);
616 inline void add_string_data(const void* value, size_t size);
617 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& string_data() const;
618 inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_string_data();
619
620 // repeated double double_data = 9 [packed = true];
621 inline int double_data_size() const;
622 inline void clear_double_data();
623 static const int kDoubleDataFieldNumber = 9;
624 inline double double_data(int index) const;
625 inline void set_double_data(int index, double value);
626 inline void add_double_data(double value);
627 inline const ::google::protobuf::RepeatedField< double >&
628 double_data() const;
629 inline ::google::protobuf::RepeatedField< double >*
630 mutable_double_data();
631
632 // repeated int64 int64_data = 10 [packed = true];
633 inline int int64_data_size() const;
634 inline void clear_int64_data();
635 static const int kInt64DataFieldNumber = 10;
636 inline ::google::protobuf::int64 int64_data(int index) const;
637 inline void set_int64_data(int index, ::google::protobuf::int64 value);
638 inline void add_int64_data(::google::protobuf::int64 value);
639 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
640 int64_data() const;
641 inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
642 mutable_int64_data();
643
644 // optional bytes raw_data = 13;
645 inline bool has_raw_data() const;
646 inline void clear_raw_data();
647 static const int kRawDataFieldNumber = 13;
648 inline const ::std::string& raw_data() const;
649 inline void set_raw_data(const ::std::string& value);
650 inline void set_raw_data(const char* value);
651 inline void set_raw_data(const void* value, size_t size);
652 inline ::std::string* mutable_raw_data();
653 inline ::std::string* release_raw_data();
654 inline void set_allocated_raw_data(::std::string* raw_data);
655
656 // optional .caffe2.ExternalDataProto external_data = 14;
657 inline bool has_external_data() const;
658 inline void clear_external_data();
659 static const int kExternalDataFieldNumber = 14;
660 inline const ::caffe2::ExternalDataProto& external_data() const;
661 inline ::caffe2::ExternalDataProto* mutable_external_data();
662 inline ::caffe2::ExternalDataProto* release_external_data();
663 inline void set_allocated_external_data(::caffe2::ExternalDataProto* external_data);
664
665 // optional string name = 7;
666 inline bool has_name() const;
667 inline void clear_name();
668 static const int kNameFieldNumber = 7;
669 inline const ::std::string& name() const;
670 inline void set_name(const ::std::string& value);
671 inline void set_name(const char* value);
672 inline void set_name(const char* value, size_t size);
673 inline ::std::string* mutable_name();
674 inline ::std::string* release_name();
675 inline void set_allocated_name(::std::string* name);
676
677 // optional .caffe2.DeviceOption device_detail = 8;
678 inline bool has_device_detail() const;
679 inline void clear_device_detail();
680 static const int kDeviceDetailFieldNumber = 8;
681 inline const ::caffe2::DeviceOption& device_detail() const;
682 inline ::caffe2::DeviceOption* mutable_device_detail();
683 inline ::caffe2::DeviceOption* release_device_detail();
684 inline void set_allocated_device_detail(::caffe2::DeviceOption* device_detail);
685
686 // optional .caffe2.TensorProto.Segment segment = 11;
687 inline bool has_segment() const;
688 inline void clear_segment();
689 static const int kSegmentFieldNumber = 11;
690 inline const ::caffe2::TensorProto_Segment& segment() const;
691 inline ::caffe2::TensorProto_Segment* mutable_segment();
692 inline ::caffe2::TensorProto_Segment* release_segment();
693 inline void set_allocated_segment(::caffe2::TensorProto_Segment* segment);
694
695 // @@protoc_insertion_point(class_scope:caffe2.TensorProto)
696 private:
697 inline void set_has_data_type();
698 inline void clear_has_data_type();
699 inline void set_has_storage_type();
700 inline void clear_has_storage_type();
701 inline void set_has_byte_data();
702 inline void clear_has_byte_data();
703 inline void set_has_raw_data();
704 inline void clear_has_raw_data();
705 inline void set_has_external_data();
706 inline void clear_has_external_data();
707 inline void set_has_name();
708 inline void clear_has_name();
709 inline void set_has_device_detail();
710 inline void clear_has_device_detail();
711 inline void set_has_segment();
712 inline void clear_has_segment();
713
714 ::google::protobuf::UnknownFieldSet _unknown_fields_;
715
716 ::google::protobuf::uint32 _has_bits_[1];
717 mutable int _cached_size_;
718 ::google::protobuf::RepeatedField< ::google::protobuf::int64 > dims_;
719 int data_type_;
720 int storage_type_;
721 ::google::protobuf::RepeatedField< float > float_data_;
722 mutable int _float_data_cached_byte_size_;
723 ::google::protobuf::RepeatedField< ::google::protobuf::int32 > int32_data_;
724 mutable int _int32_data_cached_byte_size_;
725 ::std::string* byte_data_;
726 ::google::protobuf::RepeatedPtrField< ::std::string> string_data_;
727 ::google::protobuf::RepeatedField< double > double_data_;
728 mutable int _double_data_cached_byte_size_;
729 ::google::protobuf::RepeatedField< ::google::protobuf::int64 > int64_data_;
730 mutable int _int64_data_cached_byte_size_;
731 ::std::string* raw_data_;
732 ::caffe2::ExternalDataProto* external_data_;
733 ::std::string* name_;
734 ::caffe2::DeviceOption* device_detail_;
735 ::caffe2::TensorProto_Segment* segment_;
736 friend void protobuf_AddDesc_caffe2_2eproto();
737 friend void protobuf_AssignDesc_caffe2_2eproto();
738 friend void protobuf_ShutdownFile_caffe2_2eproto();
739
740 void InitAsDefaultInstance();
741 static TensorProto* default_instance_;
742};
743// -------------------------------------------------------------------
744
745class QTensorProto : public ::google::protobuf::Message {
746 public:
747 QTensorProto();
748 virtual ~QTensorProto();
749
750 QTensorProto(const QTensorProto& from);
751
752 inline QTensorProto& operator=(const QTensorProto& from) {
753 CopyFrom(from);
754 return *this;
755 }
756
757 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
758 return _unknown_fields_;
759 }
760
761 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
762 return &_unknown_fields_;
763 }
764
765 static const ::google::protobuf::Descriptor* descriptor();
766 static const QTensorProto& default_instance();
767
768 void Swap(QTensorProto* other);
769
770 // implements Message ----------------------------------------------
771
772 QTensorProto* New() const;
773 void CopyFrom(const ::google::protobuf::Message& from);
774 void MergeFrom(const ::google::protobuf::Message& from);
775 void CopyFrom(const QTensorProto& from);
776 void MergeFrom(const QTensorProto& from);
777 void Clear();
778 bool IsInitialized() const;
779
780 int ByteSize() const;
781 bool MergePartialFromCodedStream(
782 ::google::protobuf::io::CodedInputStream* input);
783 void SerializeWithCachedSizes(
784 ::google::protobuf::io::CodedOutputStream* output) const;
785 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
786 int GetCachedSize() const { return _cached_size_; }
787 private:
788 void SharedCtor();
789 void SharedDtor();
790 void SetCachedSize(int size) const;
791 public:
792 ::google::protobuf::Metadata GetMetadata() const;
793
794 // nested types ----------------------------------------------------
795
796 // accessors -------------------------------------------------------
797
798 // repeated int64 dims = 1;
799 inline int dims_size() const;
800 inline void clear_dims();
801 static const int kDimsFieldNumber = 1;
802 inline ::google::protobuf::int64 dims(int index) const;
803 inline void set_dims(int index, ::google::protobuf::int64 value);
804 inline void add_dims(::google::protobuf::int64 value);
805 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
806 dims() const;
807 inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
808 mutable_dims();
809
810 // required int32 precision = 2;
811 inline bool has_precision() const;
812 inline void clear_precision();
813 static const int kPrecisionFieldNumber = 2;
814 inline ::google::protobuf::int32 precision() const;
815 inline void set_precision(::google::protobuf::int32 value);
816
817 // required double scale = 3;
818 inline bool has_scale() const;
819 inline void clear_scale();
820 static const int kScaleFieldNumber = 3;
821 inline double scale() const;
822 inline void set_scale(double value);
823
824 // required double bias = 4;
825 inline bool has_bias() const;
826 inline void clear_bias();
827 static const int kBiasFieldNumber = 4;
828 inline double bias() const;
829 inline void set_bias(double value);
830
831 // required bool is_signed = 5;
832 inline bool has_is_signed() const;
833 inline void clear_is_signed();
834 static const int kIsSignedFieldNumber = 5;
835 inline bool is_signed() const;
836 inline void set_is_signed(bool value);
837
838 // repeated int32 data = 6 [packed = true];
839 inline int data_size() const;
840 inline void clear_data();
841 static const int kDataFieldNumber = 6;
842 inline ::google::protobuf::int32 data(int index) const;
843 inline void set_data(int index, ::google::protobuf::int32 value);
844 inline void add_data(::google::protobuf::int32 value);
845 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
846 data() const;
847 inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
848 mutable_data();
849
850 // optional string name = 7;
851 inline bool has_name() const;
852 inline void clear_name();
853 static const int kNameFieldNumber = 7;
854 inline const ::std::string& name() const;
855 inline void set_name(const ::std::string& value);
856 inline void set_name(const char* value);
857 inline void set_name(const char* value, size_t size);
858 inline ::std::string* mutable_name();
859 inline ::std::string* release_name();
860 inline void set_allocated_name(::std::string* name);
861
862 // optional .caffe2.TensorProto.DataType data_type = 8 [default = INT32];
863 inline bool has_data_type() const;
864 inline void clear_data_type();
865 static const int kDataTypeFieldNumber = 8;
866 inline ::caffe2::TensorProto_DataType data_type() const;
867 inline void set_data_type(::caffe2::TensorProto_DataType value);
868
869 // repeated double scales = 9;
870 inline int scales_size() const;
871 inline void clear_scales();
872 static const int kScalesFieldNumber = 9;
873 inline double scales(int index) const;
874 inline void set_scales(int index, double value);
875 inline void add_scales(double value);
876 inline const ::google::protobuf::RepeatedField< double >&
877 scales() const;
878 inline ::google::protobuf::RepeatedField< double >*
879 mutable_scales();
880
881 // repeated double biases = 10;
882 inline int biases_size() const;
883 inline void clear_biases();
884 static const int kBiasesFieldNumber = 10;
885 inline double biases(int index) const;
886 inline void set_biases(int index, double value);
887 inline void add_biases(double value);
888 inline const ::google::protobuf::RepeatedField< double >&
889 biases() const;
890 inline ::google::protobuf::RepeatedField< double >*
891 mutable_biases();
892
893 // optional int32 axis = 11;
894 inline bool has_axis() const;
895 inline void clear_axis();
896 static const int kAxisFieldNumber = 11;
897 inline ::google::protobuf::int32 axis() const;
898 inline void set_axis(::google::protobuf::int32 value);
899
900 // optional bool is_multiparam = 12 [default = false];
901 inline bool has_is_multiparam() const;
902 inline void clear_is_multiparam();
903 static const int kIsMultiparamFieldNumber = 12;
904 inline bool is_multiparam() const;
905 inline void set_is_multiparam(bool value);
906
907 // @@protoc_insertion_point(class_scope:caffe2.QTensorProto)
908 private:
909 inline void set_has_precision();
910 inline void clear_has_precision();
911 inline void set_has_scale();
912 inline void clear_has_scale();
913 inline void set_has_bias();
914 inline void clear_has_bias();
915 inline void set_has_is_signed();
916 inline void clear_has_is_signed();
917 inline void set_has_name();
918 inline void clear_has_name();
919 inline void set_has_data_type();
920 inline void clear_has_data_type();
921 inline void set_has_axis();
922 inline void clear_has_axis();
923 inline void set_has_is_multiparam();
924 inline void clear_has_is_multiparam();
925
926 ::google::protobuf::UnknownFieldSet _unknown_fields_;
927
928 ::google::protobuf::uint32 _has_bits_[1];
929 mutable int _cached_size_;
930 ::google::protobuf::RepeatedField< ::google::protobuf::int64 > dims_;
931 double scale_;
932 double bias_;
933 ::google::protobuf::int32 precision_;
934 int data_type_;
935 ::google::protobuf::RepeatedField< ::google::protobuf::int32 > data_;
936 mutable int _data_cached_byte_size_;
937 ::std::string* name_;
938 ::google::protobuf::RepeatedField< double > scales_;
939 bool is_signed_;
940 bool is_multiparam_;
941 ::google::protobuf::int32 axis_;
942 ::google::protobuf::RepeatedField< double > biases_;
943 friend void protobuf_AddDesc_caffe2_2eproto();
944 friend void protobuf_AssignDesc_caffe2_2eproto();
945 friend void protobuf_ShutdownFile_caffe2_2eproto();
946
947 void InitAsDefaultInstance();
948 static QTensorProto* default_instance_;
949};
950// -------------------------------------------------------------------
951
952class TensorProtos : public ::google::protobuf::Message {
953 public:
954 TensorProtos();
955 virtual ~TensorProtos();
956
957 TensorProtos(const TensorProtos& from);
958
959 inline TensorProtos& operator=(const TensorProtos& from) {
960 CopyFrom(from);
961 return *this;
962 }
963
964 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
965 return _unknown_fields_;
966 }
967
968 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
969 return &_unknown_fields_;
970 }
971
972 static const ::google::protobuf::Descriptor* descriptor();
973 static const TensorProtos& default_instance();
974
975 void Swap(TensorProtos* other);
976
977 // implements Message ----------------------------------------------
978
979 TensorProtos* New() const;
980 void CopyFrom(const ::google::protobuf::Message& from);
981 void MergeFrom(const ::google::protobuf::Message& from);
982 void CopyFrom(const TensorProtos& from);
983 void MergeFrom(const TensorProtos& from);
984 void Clear();
985 bool IsInitialized() const;
986
987 int ByteSize() const;
988 bool MergePartialFromCodedStream(
989 ::google::protobuf::io::CodedInputStream* input);
990 void SerializeWithCachedSizes(
991 ::google::protobuf::io::CodedOutputStream* output) const;
992 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
993 int GetCachedSize() const { return _cached_size_; }
994 private:
995 void SharedCtor();
996 void SharedDtor();
997 void SetCachedSize(int size) const;
998 public:
999 ::google::protobuf::Metadata GetMetadata() const;
1000
1001 // nested types ----------------------------------------------------
1002
1003 // accessors -------------------------------------------------------
1004
1005 // repeated .caffe2.TensorProto protos = 1;
1006 inline int protos_size() const;
1007 inline void clear_protos();
1008 static const int kProtosFieldNumber = 1;
1009 inline const ::caffe2::TensorProto& protos(int index) const;
1010 inline ::caffe2::TensorProto* mutable_protos(int index);
1011 inline ::caffe2::TensorProto* add_protos();
1012 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::TensorProto >&
1013 protos() const;
1014 inline ::google::protobuf::RepeatedPtrField< ::caffe2::TensorProto >*
1015 mutable_protos();
1016
1017 // @@protoc_insertion_point(class_scope:caffe2.TensorProtos)
1018 private:
1019
1020 ::google::protobuf::UnknownFieldSet _unknown_fields_;
1021
1022 ::google::protobuf::uint32 _has_bits_[1];
1023 mutable int _cached_size_;
1024 ::google::protobuf::RepeatedPtrField< ::caffe2::TensorProto > protos_;
1025 friend void protobuf_AddDesc_caffe2_2eproto();
1026 friend void protobuf_AssignDesc_caffe2_2eproto();
1027 friend void protobuf_ShutdownFile_caffe2_2eproto();
1028
1029 void InitAsDefaultInstance();
1030 static TensorProtos* default_instance_;
1031};
1032// -------------------------------------------------------------------
1033
1034class TensorShape : public ::google::protobuf::Message {
1035 public:
1036 TensorShape();
1037 virtual ~TensorShape();
1038
1039 TensorShape(const TensorShape& from);
1040
1041 inline TensorShape& operator=(const TensorShape& from) {
1042 CopyFrom(from);
1043 return *this;
1044 }
1045
1046 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1047 return _unknown_fields_;
1048 }
1049
1050 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1051 return &_unknown_fields_;
1052 }
1053
1054 static const ::google::protobuf::Descriptor* descriptor();
1055 static const TensorShape& default_instance();
1056
1057 void Swap(TensorShape* other);
1058
1059 // implements Message ----------------------------------------------
1060
1061 TensorShape* New() const;
1062 void CopyFrom(const ::google::protobuf::Message& from);
1063 void MergeFrom(const ::google::protobuf::Message& from);
1064 void CopyFrom(const TensorShape& from);
1065 void MergeFrom(const TensorShape& from);
1066 void Clear();
1067 bool IsInitialized() const;
1068
1069 int ByteSize() const;
1070 bool MergePartialFromCodedStream(
1071 ::google::protobuf::io::CodedInputStream* input);
1072 void SerializeWithCachedSizes(
1073 ::google::protobuf::io::CodedOutputStream* output) const;
1074 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1075 int GetCachedSize() const { return _cached_size_; }
1076 private:
1077 void SharedCtor();
1078 void SharedDtor();
1079 void SetCachedSize(int size) const;
1080 public:
1081 ::google::protobuf::Metadata GetMetadata() const;
1082
1083 // nested types ----------------------------------------------------
1084
1085 // accessors -------------------------------------------------------
1086
1087 // repeated int64 dims = 1;
1088 inline int dims_size() const;
1089 inline void clear_dims();
1090 static const int kDimsFieldNumber = 1;
1091 inline ::google::protobuf::int64 dims(int index) const;
1092 inline void set_dims(int index, ::google::protobuf::int64 value);
1093 inline void add_dims(::google::protobuf::int64 value);
1094 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
1095 dims() const;
1096 inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
1097 mutable_dims();
1098
1099 // optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT];
1100 inline bool has_data_type() const;
1101 inline void clear_data_type();
1102 static const int kDataTypeFieldNumber = 2;
1103 inline ::caffe2::TensorProto_DataType data_type() const;
1104 inline void set_data_type(::caffe2::TensorProto_DataType value);
1105
1106 // repeated int32 unknown_dims = 3;
1107 inline int unknown_dims_size() const;
1108 inline void clear_unknown_dims();
1109 static const int kUnknownDimsFieldNumber = 3;
1110 inline ::google::protobuf::int32 unknown_dims(int index) const;
1111 inline void set_unknown_dims(int index, ::google::protobuf::int32 value);
1112 inline void add_unknown_dims(::google::protobuf::int32 value);
1113 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
1114 unknown_dims() const;
1115 inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
1116 mutable_unknown_dims();
1117
1118 // optional bool unknown_shape = 4 [default = false];
1119 inline bool has_unknown_shape() const;
1120 inline void clear_unknown_shape();
1121 static const int kUnknownShapeFieldNumber = 4;
1122 inline bool unknown_shape() const;
1123 inline void set_unknown_shape(bool value);
1124
1125 // optional string name = 5;
1126 inline bool has_name() const;
1127 inline void clear_name();
1128 static const int kNameFieldNumber = 5;
1129 inline const ::std::string& name() const;
1130 inline void set_name(const ::std::string& value);
1131 inline void set_name(const char* value);
1132 inline void set_name(const char* value, size_t size);
1133 inline ::std::string* mutable_name();
1134 inline ::std::string* release_name();
1135 inline void set_allocated_name(::std::string* name);
1136
1137 // @@protoc_insertion_point(class_scope:caffe2.TensorShape)
1138 private:
1139 inline void set_has_data_type();
1140 inline void clear_has_data_type();
1141 inline void set_has_unknown_shape();
1142 inline void clear_has_unknown_shape();
1143 inline void set_has_name();
1144 inline void clear_has_name();
1145
1146 ::google::protobuf::UnknownFieldSet _unknown_fields_;
1147
1148 ::google::protobuf::uint32 _has_bits_[1];
1149 mutable int _cached_size_;
1150 ::google::protobuf::RepeatedField< ::google::protobuf::int64 > dims_;
1151 ::google::protobuf::RepeatedField< ::google::protobuf::int32 > unknown_dims_;
1152 int data_type_;
1153 bool unknown_shape_;
1154 ::std::string* name_;
1155 friend void protobuf_AddDesc_caffe2_2eproto();
1156 friend void protobuf_AssignDesc_caffe2_2eproto();
1157 friend void protobuf_ShutdownFile_caffe2_2eproto();
1158
1159 void InitAsDefaultInstance();
1160 static TensorShape* default_instance_;
1161};
1162// -------------------------------------------------------------------
1163
1164class TensorShapes : public ::google::protobuf::Message {
1165 public:
1166 TensorShapes();
1167 virtual ~TensorShapes();
1168
1169 TensorShapes(const TensorShapes& from);
1170
1171 inline TensorShapes& operator=(const TensorShapes& from) {
1172 CopyFrom(from);
1173 return *this;
1174 }
1175
1176 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1177 return _unknown_fields_;
1178 }
1179
1180 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1181 return &_unknown_fields_;
1182 }
1183
1184 static const ::google::protobuf::Descriptor* descriptor();
1185 static const TensorShapes& default_instance();
1186
1187 void Swap(TensorShapes* other);
1188
1189 // implements Message ----------------------------------------------
1190
1191 TensorShapes* New() const;
1192 void CopyFrom(const ::google::protobuf::Message& from);
1193 void MergeFrom(const ::google::protobuf::Message& from);
1194 void CopyFrom(const TensorShapes& from);
1195 void MergeFrom(const TensorShapes& from);
1196 void Clear();
1197 bool IsInitialized() const;
1198
1199 int ByteSize() const;
1200 bool MergePartialFromCodedStream(
1201 ::google::protobuf::io::CodedInputStream* input);
1202 void SerializeWithCachedSizes(
1203 ::google::protobuf::io::CodedOutputStream* output) const;
1204 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1205 int GetCachedSize() const { return _cached_size_; }
1206 private:
1207 void SharedCtor();
1208 void SharedDtor();
1209 void SetCachedSize(int size) const;
1210 public:
1211 ::google::protobuf::Metadata GetMetadata() const;
1212
1213 // nested types ----------------------------------------------------
1214
1215 // accessors -------------------------------------------------------
1216
1217 // repeated .caffe2.TensorShape shapes = 1;
1218 inline int shapes_size() const;
1219 inline void clear_shapes();
1220 static const int kShapesFieldNumber = 1;
1221 inline const ::caffe2::TensorShape& shapes(int index) const;
1222 inline ::caffe2::TensorShape* mutable_shapes(int index);
1223 inline ::caffe2::TensorShape* add_shapes();
1224 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::TensorShape >&
1225 shapes() const;
1226 inline ::google::protobuf::RepeatedPtrField< ::caffe2::TensorShape >*
1227 mutable_shapes();
1228
1229 // @@protoc_insertion_point(class_scope:caffe2.TensorShapes)
1230 private:
1231
1232 ::google::protobuf::UnknownFieldSet _unknown_fields_;
1233
1234 ::google::protobuf::uint32 _has_bits_[1];
1235 mutable int _cached_size_;
1236 ::google::protobuf::RepeatedPtrField< ::caffe2::TensorShape > shapes_;
1237 friend void protobuf_AddDesc_caffe2_2eproto();
1238 friend void protobuf_AssignDesc_caffe2_2eproto();
1239 friend void protobuf_ShutdownFile_caffe2_2eproto();
1240
1241 void InitAsDefaultInstance();
1242 static TensorShapes* default_instance_;
1243};
1244// -------------------------------------------------------------------
1245
1246class TensorBoundShape : public ::google::protobuf::Message {
1247 public:
1248 TensorBoundShape();
1249 virtual ~TensorBoundShape();
1250
1251 TensorBoundShape(const TensorBoundShape& from);
1252
1253 inline TensorBoundShape& operator=(const TensorBoundShape& from) {
1254 CopyFrom(from);
1255 return *this;
1256 }
1257
1258 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1259 return _unknown_fields_;
1260 }
1261
1262 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1263 return &_unknown_fields_;
1264 }
1265
1266 static const ::google::protobuf::Descriptor* descriptor();
1267 static const TensorBoundShape& default_instance();
1268
1269 void Swap(TensorBoundShape* other);
1270
1271 // implements Message ----------------------------------------------
1272
1273 TensorBoundShape* New() const;
1274 void CopyFrom(const ::google::protobuf::Message& from);
1275 void MergeFrom(const ::google::protobuf::Message& from);
1276 void CopyFrom(const TensorBoundShape& from);
1277 void MergeFrom(const TensorBoundShape& from);
1278 void Clear();
1279 bool IsInitialized() const;
1280
1281 int ByteSize() const;
1282 bool MergePartialFromCodedStream(
1283 ::google::protobuf::io::CodedInputStream* input);
1284 void SerializeWithCachedSizes(
1285 ::google::protobuf::io::CodedOutputStream* output) const;
1286 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1287 int GetCachedSize() const { return _cached_size_; }
1288 private:
1289 void SharedCtor();
1290 void SharedDtor();
1291 void SetCachedSize(int size) const;
1292 public:
1293 ::google::protobuf::Metadata GetMetadata() const;
1294
1295 // nested types ----------------------------------------------------
1296
1297 typedef TensorBoundShape_DimType DimType;
1298 static const DimType UNKNOWN = TensorBoundShape_DimType_UNKNOWN;
1299 static const DimType CONSTANT = TensorBoundShape_DimType_CONSTANT;
1300 static const DimType BATCH = TensorBoundShape_DimType_BATCH;
1301 static const DimType BATCH_OF_FEATURE_MAX = TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX;
1302 static const DimType BATCH_OF_FEATURE_MAX_DEFAULT = TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX_DEFAULT;
1303 static const DimType FEATURE_MAX = TensorBoundShape_DimType_FEATURE_MAX;
1304 static const DimType FEATURE_MAX_DEFAULT = TensorBoundShape_DimType_FEATURE_MAX_DEFAULT;
1305 static inline bool DimType_IsValid(int value) {
1306 return TensorBoundShape_DimType_IsValid(value);
1307 }
1308 static const DimType DimType_MIN =
1309 TensorBoundShape_DimType_DimType_MIN;
1310 static const DimType DimType_MAX =
1311 TensorBoundShape_DimType_DimType_MAX;
1312 static const int DimType_ARRAYSIZE =
1313 TensorBoundShape_DimType_DimType_ARRAYSIZE;
1314 static inline const ::google::protobuf::EnumDescriptor*
1315 DimType_descriptor() {
1316 return TensorBoundShape_DimType_descriptor();
1317 }
1318 static inline const ::std::string& DimType_Name(DimType value) {
1319 return TensorBoundShape_DimType_Name(value);
1320 }
1321 static inline bool DimType_Parse(const ::std::string& name,
1322 DimType* value) {
1323 return TensorBoundShape_DimType_Parse(name, value);
1324 }
1325
1326 // accessors -------------------------------------------------------
1327
1328 // optional .caffe2.TensorShape shape = 1;
1329 inline bool has_shape() const;
1330 inline void clear_shape();
1331 static const int kShapeFieldNumber = 1;
1332 inline const ::caffe2::TensorShape& shape() const;
1333 inline ::caffe2::TensorShape* mutable_shape();
1334 inline ::caffe2::TensorShape* release_shape();
1335 inline void set_allocated_shape(::caffe2::TensorShape* shape);
1336
1337 // repeated .caffe2.TensorBoundShape.DimType dim_type = 2;
1338 inline int dim_type_size() const;
1339 inline void clear_dim_type();
1340 static const int kDimTypeFieldNumber = 2;
1341 inline ::caffe2::TensorBoundShape_DimType dim_type(int index) const;
1342 inline void set_dim_type(int index, ::caffe2::TensorBoundShape_DimType value);
1343 inline void add_dim_type(::caffe2::TensorBoundShape_DimType value);
1344 inline const ::google::protobuf::RepeatedField<int>& dim_type() const;
1345 inline ::google::protobuf::RepeatedField<int>* mutable_dim_type();
1346
1347 // optional string name = 3;
1348 inline bool has_name() const;
1349 inline void clear_name();
1350 static const int kNameFieldNumber = 3;
1351 inline const ::std::string& name() const;
1352 inline void set_name(const ::std::string& value);
1353 inline void set_name(const char* value);
1354 inline void set_name(const char* value, size_t size);
1355 inline ::std::string* mutable_name();
1356 inline ::std::string* release_name();
1357 inline void set_allocated_name(::std::string* name);
1358
1359 // @@protoc_insertion_point(class_scope:caffe2.TensorBoundShape)
1360 private:
1361 inline void set_has_shape();
1362 inline void clear_has_shape();
1363 inline void set_has_name();
1364 inline void clear_has_name();
1365
1366 ::google::protobuf::UnknownFieldSet _unknown_fields_;
1367
1368 ::google::protobuf::uint32 _has_bits_[1];
1369 mutable int _cached_size_;
1370 ::caffe2::TensorShape* shape_;
1371 ::google::protobuf::RepeatedField<int> dim_type_;
1372 ::std::string* name_;
1373 friend void protobuf_AddDesc_caffe2_2eproto();
1374 friend void protobuf_AssignDesc_caffe2_2eproto();
1375 friend void protobuf_ShutdownFile_caffe2_2eproto();
1376
1377 void InitAsDefaultInstance();
1378 static TensorBoundShape* default_instance_;
1379};
1380// -------------------------------------------------------------------
1381
1382class TensorBoundShapes : public ::google::protobuf::Message {
1383 public:
1384 TensorBoundShapes();
1385 virtual ~TensorBoundShapes();
1386
1387 TensorBoundShapes(const TensorBoundShapes& from);
1388
1389 inline TensorBoundShapes& operator=(const TensorBoundShapes& from) {
1390 CopyFrom(from);
1391 return *this;
1392 }
1393
1394 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1395 return _unknown_fields_;
1396 }
1397
1398 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1399 return &_unknown_fields_;
1400 }
1401
1402 static const ::google::protobuf::Descriptor* descriptor();
1403 static const TensorBoundShapes& default_instance();
1404
1405 void Swap(TensorBoundShapes* other);
1406
1407 // implements Message ----------------------------------------------
1408
1409 TensorBoundShapes* New() const;
1410 void CopyFrom(const ::google::protobuf::Message& from);
1411 void MergeFrom(const ::google::protobuf::Message& from);
1412 void CopyFrom(const TensorBoundShapes& from);
1413 void MergeFrom(const TensorBoundShapes& from);
1414 void Clear();
1415 bool IsInitialized() const;
1416
1417 int ByteSize() const;
1418 bool MergePartialFromCodedStream(
1419 ::google::protobuf::io::CodedInputStream* input);
1420 void SerializeWithCachedSizes(
1421 ::google::protobuf::io::CodedOutputStream* output) const;
1422 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1423 int GetCachedSize() const { return _cached_size_; }
1424 private:
1425 void SharedCtor();
1426 void SharedDtor();
1427 void SetCachedSize(int size) const;
1428 public:
1429 ::google::protobuf::Metadata GetMetadata() const;
1430
1431 // nested types ----------------------------------------------------
1432
1433 // accessors -------------------------------------------------------
1434
1435 // repeated .caffe2.TensorBoundShape shapes = 1;
1436 inline int shapes_size() const;
1437 inline void clear_shapes();
1438 static const int kShapesFieldNumber = 1;
1439 inline const ::caffe2::TensorBoundShape& shapes(int index) const;
1440 inline ::caffe2::TensorBoundShape* mutable_shapes(int index);
1441 inline ::caffe2::TensorBoundShape* add_shapes();
1442 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::TensorBoundShape >&
1443 shapes() const;
1444 inline ::google::protobuf::RepeatedPtrField< ::caffe2::TensorBoundShape >*
1445 mutable_shapes();
1446
1447 // optional int64 max_batch_size = 2;
1448 inline bool has_max_batch_size() const;
1449 inline void clear_max_batch_size();
1450 static const int kMaxBatchSizeFieldNumber = 2;
1451 inline ::google::protobuf::int64 max_batch_size() const;
1452 inline void set_max_batch_size(::google::protobuf::int64 value);
1453
1454 // optional int64 max_feature_len = 3;
1455 inline bool has_max_feature_len() const;
1456 inline void clear_max_feature_len();
1457 static const int kMaxFeatureLenFieldNumber = 3;
1458 inline ::google::protobuf::int64 max_feature_len() const;
1459 inline void set_max_feature_len(::google::protobuf::int64 value);
1460
1461 // @@protoc_insertion_point(class_scope:caffe2.TensorBoundShapes)
1462 private:
1463 inline void set_has_max_batch_size();
1464 inline void clear_has_max_batch_size();
1465 inline void set_has_max_feature_len();
1466 inline void clear_has_max_feature_len();
1467
1468 ::google::protobuf::UnknownFieldSet _unknown_fields_;
1469
1470 ::google::protobuf::uint32 _has_bits_[1];
1471 mutable int _cached_size_;
1472 ::google::protobuf::RepeatedPtrField< ::caffe2::TensorBoundShape > shapes_;
1473 ::google::protobuf::int64 max_batch_size_;
1474 ::google::protobuf::int64 max_feature_len_;
1475 friend void protobuf_AddDesc_caffe2_2eproto();
1476 friend void protobuf_AssignDesc_caffe2_2eproto();
1477 friend void protobuf_ShutdownFile_caffe2_2eproto();
1478
1479 void InitAsDefaultInstance();
1480 static TensorBoundShapes* default_instance_;
1481};
1482// -------------------------------------------------------------------
1483
1484class AOTConfig : public ::google::protobuf::Message {
1485 public:
1486 AOTConfig();
1487 virtual ~AOTConfig();
1488
1489 AOTConfig(const AOTConfig& from);
1490
1491 inline AOTConfig& operator=(const AOTConfig& from) {
1492 CopyFrom(from);
1493 return *this;
1494 }
1495
1496 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1497 return _unknown_fields_;
1498 }
1499
1500 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1501 return &_unknown_fields_;
1502 }
1503
1504 static const ::google::protobuf::Descriptor* descriptor();
1505 static const AOTConfig& default_instance();
1506
1507 void Swap(AOTConfig* other);
1508
1509 // implements Message ----------------------------------------------
1510
1511 AOTConfig* New() const;
1512 void CopyFrom(const ::google::protobuf::Message& from);
1513 void MergeFrom(const ::google::protobuf::Message& from);
1514 void CopyFrom(const AOTConfig& from);
1515 void MergeFrom(const AOTConfig& from);
1516 void Clear();
1517 bool IsInitialized() const;
1518
1519 int ByteSize() const;
1520 bool MergePartialFromCodedStream(
1521 ::google::protobuf::io::CodedInputStream* input);
1522 void SerializeWithCachedSizes(
1523 ::google::protobuf::io::CodedOutputStream* output) const;
1524 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1525 int GetCachedSize() const { return _cached_size_; }
1526 private:
1527 void SharedCtor();
1528 void SharedDtor();
1529 void SetCachedSize(int size) const;
1530 public:
1531 ::google::protobuf::Metadata GetMetadata() const;
1532
1533 // nested types ----------------------------------------------------
1534
1535 // accessors -------------------------------------------------------
1536
1537 // required int64 max_batch_size = 1;
1538 inline bool has_max_batch_size() const;
1539 inline void clear_max_batch_size();
1540 static const int kMaxBatchSizeFieldNumber = 1;
1541 inline ::google::protobuf::int64 max_batch_size() const;
1542 inline void set_max_batch_size(::google::protobuf::int64 value);
1543
1544 // required int64 max_seq_size = 2;
1545 inline bool has_max_seq_size() const;
1546 inline void clear_max_seq_size();
1547 static const int kMaxSeqSizeFieldNumber = 2;
1548 inline ::google::protobuf::int64 max_seq_size() const;
1549 inline void set_max_seq_size(::google::protobuf::int64 value);
1550
1551 // required bool in_batch_broadcast = 3;
1552 inline bool has_in_batch_broadcast() const;
1553 inline void clear_in_batch_broadcast();
1554 static const int kInBatchBroadcastFieldNumber = 3;
1555 inline bool in_batch_broadcast() const;
1556 inline void set_in_batch_broadcast(bool value);
1557
1558 // optional string onnxifi_blacklist_ops = 4;
1559 inline bool has_onnxifi_blacklist_ops() const;
1560 inline void clear_onnxifi_blacklist_ops();
1561 static const int kOnnxifiBlacklistOpsFieldNumber = 4;
1562 inline const ::std::string& onnxifi_blacklist_ops() const;
1563 inline void set_onnxifi_blacklist_ops(const ::std::string& value);
1564 inline void set_onnxifi_blacklist_ops(const char* value);
1565 inline void set_onnxifi_blacklist_ops(const char* value, size_t size);
1566 inline ::std::string* mutable_onnxifi_blacklist_ops();
1567 inline ::std::string* release_onnxifi_blacklist_ops();
1568 inline void set_allocated_onnxifi_blacklist_ops(::std::string* onnxifi_blacklist_ops);
1569
1570 // optional int32 onnxifi_min_ops = 5;
1571 inline bool has_onnxifi_min_ops() const;
1572 inline void clear_onnxifi_min_ops();
1573 static const int kOnnxifiMinOpsFieldNumber = 5;
1574 inline ::google::protobuf::int32 onnxifi_min_ops() const;
1575 inline void set_onnxifi_min_ops(::google::protobuf::int32 value);
1576
1577 // @@protoc_insertion_point(class_scope:caffe2.AOTConfig)
1578 private:
1579 inline void set_has_max_batch_size();
1580 inline void clear_has_max_batch_size();
1581 inline void set_has_max_seq_size();
1582 inline void clear_has_max_seq_size();
1583 inline void set_has_in_batch_broadcast();
1584 inline void clear_has_in_batch_broadcast();
1585 inline void set_has_onnxifi_blacklist_ops();
1586 inline void clear_has_onnxifi_blacklist_ops();
1587 inline void set_has_onnxifi_min_ops();
1588 inline void clear_has_onnxifi_min_ops();
1589
1590 ::google::protobuf::UnknownFieldSet _unknown_fields_;
1591
1592 ::google::protobuf::uint32 _has_bits_[1];
1593 mutable int _cached_size_;
1594 ::google::protobuf::int64 max_batch_size_;
1595 ::google::protobuf::int64 max_seq_size_;
1596 ::std::string* onnxifi_blacklist_ops_;
1597 bool in_batch_broadcast_;
1598 ::google::protobuf::int32 onnxifi_min_ops_;
1599 friend void protobuf_AddDesc_caffe2_2eproto();
1600 friend void protobuf_AssignDesc_caffe2_2eproto();
1601 friend void protobuf_ShutdownFile_caffe2_2eproto();
1602
1603 void InitAsDefaultInstance();
1604 static AOTConfig* default_instance_;
1605};
1606// -------------------------------------------------------------------
1607
1608class Argument : public ::google::protobuf::Message {
1609 public:
1610 Argument();
1611 virtual ~Argument();
1612
1613 Argument(const Argument& from);
1614
1615 inline Argument& operator=(const Argument& from) {
1616 CopyFrom(from);
1617 return *this;
1618 }
1619
1620 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1621 return _unknown_fields_;
1622 }
1623
1624 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1625 return &_unknown_fields_;
1626 }
1627
1628 static const ::google::protobuf::Descriptor* descriptor();
1629 static const Argument& default_instance();
1630
1631 void Swap(Argument* other);
1632
1633 // implements Message ----------------------------------------------
1634
1635 Argument* New() const;
1636 void CopyFrom(const ::google::protobuf::Message& from);
1637 void MergeFrom(const ::google::protobuf::Message& from);
1638 void CopyFrom(const Argument& from);
1639 void MergeFrom(const Argument& from);
1640 void Clear();
1641 bool IsInitialized() const;
1642
1643 int ByteSize() const;
1644 bool MergePartialFromCodedStream(
1645 ::google::protobuf::io::CodedInputStream* input);
1646 void SerializeWithCachedSizes(
1647 ::google::protobuf::io::CodedOutputStream* output) const;
1648 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1649 int GetCachedSize() const { return _cached_size_; }
1650 private:
1651 void SharedCtor();
1652 void SharedDtor();
1653 void SetCachedSize(int size) const;
1654 public:
1655 ::google::protobuf::Metadata GetMetadata() const;
1656
1657 // nested types ----------------------------------------------------
1658
1659 // accessors -------------------------------------------------------
1660
1661 // optional string name = 1;
1662 inline bool has_name() const;
1663 inline void clear_name();
1664 static const int kNameFieldNumber = 1;
1665 inline const ::std::string& name() const;
1666 inline void set_name(const ::std::string& value);
1667 inline void set_name(const char* value);
1668 inline void set_name(const char* value, size_t size);
1669 inline ::std::string* mutable_name();
1670 inline ::std::string* release_name();
1671 inline void set_allocated_name(::std::string* name);
1672
1673 // optional float f = 2;
1674 inline bool has_f() const;
1675 inline void clear_f();
1676 static const int kFFieldNumber = 2;
1677 inline float f() const;
1678 inline void set_f(float value);
1679
1680 // optional int64 i = 3;
1681 inline bool has_i() const;
1682 inline void clear_i();
1683 static const int kIFieldNumber = 3;
1684 inline ::google::protobuf::int64 i() const;
1685 inline void set_i(::google::protobuf::int64 value);
1686
1687 // optional bytes s = 4;
1688 inline bool has_s() const;
1689 inline void clear_s();
1690 static const int kSFieldNumber = 4;
1691 inline const ::std::string& s() const;
1692 inline void set_s(const ::std::string& value);
1693 inline void set_s(const char* value);
1694 inline void set_s(const void* value, size_t size);
1695 inline ::std::string* mutable_s();
1696 inline ::std::string* release_s();
1697 inline void set_allocated_s(::std::string* s);
1698
1699 // optional .caffe2.TensorProto t = 10;
1700 inline bool has_t() const;
1701 inline void clear_t();
1702 static const int kTFieldNumber = 10;
1703 inline const ::caffe2::TensorProto& t() const;
1704 inline ::caffe2::TensorProto* mutable_t();
1705 inline ::caffe2::TensorProto* release_t();
1706 inline void set_allocated_t(::caffe2::TensorProto* t);
1707
1708 // optional .caffe2.NetDef n = 8;
1709 inline bool has_n() const;
1710 inline void clear_n();
1711 static const int kNFieldNumber = 8;
1712 inline const ::caffe2::NetDef& n() const;
1713 inline ::caffe2::NetDef* mutable_n();
1714 inline ::caffe2::NetDef* release_n();
1715 inline void set_allocated_n(::caffe2::NetDef* n);
1716
1717 // repeated float floats = 5;
1718 inline int floats_size() const;
1719 inline void clear_floats();
1720 static const int kFloatsFieldNumber = 5;
1721 inline float floats(int index) const;
1722 inline void set_floats(int index, float value);
1723 inline void add_floats(float value);
1724 inline const ::google::protobuf::RepeatedField< float >&
1725 floats() const;
1726 inline ::google::protobuf::RepeatedField< float >*
1727 mutable_floats();
1728
1729 // repeated int64 ints = 6;
1730 inline int ints_size() const;
1731 inline void clear_ints();
1732 static const int kIntsFieldNumber = 6;
1733 inline ::google::protobuf::int64 ints(int index) const;
1734 inline void set_ints(int index, ::google::protobuf::int64 value);
1735 inline void add_ints(::google::protobuf::int64 value);
1736 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
1737 ints() const;
1738 inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
1739 mutable_ints();
1740
1741 // repeated bytes strings = 7;
1742 inline int strings_size() const;
1743 inline void clear_strings();
1744 static const int kStringsFieldNumber = 7;
1745 inline const ::std::string& strings(int index) const;
1746 inline ::std::string* mutable_strings(int index);
1747 inline void set_strings(int index, const ::std::string& value);
1748 inline void set_strings(int index, const char* value);
1749 inline void set_strings(int index, const void* value, size_t size);
1750 inline ::std::string* add_strings();
1751 inline void add_strings(const ::std::string& value);
1752 inline void add_strings(const char* value);
1753 inline void add_strings(const void* value, size_t size);
1754 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& strings() const;
1755 inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_strings();
1756
1757 // repeated .caffe2.TensorProto tensors = 11;
1758 inline int tensors_size() const;
1759 inline void clear_tensors();
1760 static const int kTensorsFieldNumber = 11;
1761 inline const ::caffe2::TensorProto& tensors(int index) const;
1762 inline ::caffe2::TensorProto* mutable_tensors(int index);
1763 inline ::caffe2::TensorProto* add_tensors();
1764 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::TensorProto >&
1765 tensors() const;
1766 inline ::google::protobuf::RepeatedPtrField< ::caffe2::TensorProto >*
1767 mutable_tensors();
1768
1769 // repeated .caffe2.NetDef nets = 9;
1770 inline int nets_size() const;
1771 inline void clear_nets();
1772 static const int kNetsFieldNumber = 9;
1773 inline const ::caffe2::NetDef& nets(int index) const;
1774 inline ::caffe2::NetDef* mutable_nets(int index);
1775 inline ::caffe2::NetDef* add_nets();
1776 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::NetDef >&
1777 nets() const;
1778 inline ::google::protobuf::RepeatedPtrField< ::caffe2::NetDef >*
1779 mutable_nets();
1780
1781 // repeated .caffe2.QTensorProto qtensors = 12;
1782 inline int qtensors_size() const;
1783 inline void clear_qtensors();
1784 static const int kQtensorsFieldNumber = 12;
1785 inline const ::caffe2::QTensorProto& qtensors(int index) const;
1786 inline ::caffe2::QTensorProto* mutable_qtensors(int index);
1787 inline ::caffe2::QTensorProto* add_qtensors();
1788 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::QTensorProto >&
1789 qtensors() const;
1790 inline ::google::protobuf::RepeatedPtrField< ::caffe2::QTensorProto >*
1791 mutable_qtensors();
1792
1793 // @@protoc_insertion_point(class_scope:caffe2.Argument)
1794 private:
1795 inline void set_has_name();
1796 inline void clear_has_name();
1797 inline void set_has_f();
1798 inline void clear_has_f();
1799 inline void set_has_i();
1800 inline void clear_has_i();
1801 inline void set_has_s();
1802 inline void clear_has_s();
1803 inline void set_has_t();
1804 inline void clear_has_t();
1805 inline void set_has_n();
1806 inline void clear_has_n();
1807
1808 ::google::protobuf::UnknownFieldSet _unknown_fields_;
1809
1810 ::google::protobuf::uint32 _has_bits_[1];
1811 mutable int _cached_size_;
1812 ::std::string* name_;
1813 ::google::protobuf::int64 i_;
1814 ::std::string* s_;
1815 ::caffe2::TensorProto* t_;
1816 ::caffe2::NetDef* n_;
1817 ::google::protobuf::RepeatedField< float > floats_;
1818 ::google::protobuf::RepeatedField< ::google::protobuf::int64 > ints_;
1819 ::google::protobuf::RepeatedPtrField< ::std::string> strings_;
1820 ::google::protobuf::RepeatedPtrField< ::caffe2::TensorProto > tensors_;
1821 ::google::protobuf::RepeatedPtrField< ::caffe2::NetDef > nets_;
1822 ::google::protobuf::RepeatedPtrField< ::caffe2::QTensorProto > qtensors_;
1823 float f_;
1824 friend void protobuf_AddDesc_caffe2_2eproto();
1825 friend void protobuf_AssignDesc_caffe2_2eproto();
1826 friend void protobuf_ShutdownFile_caffe2_2eproto();
1827
1828 void InitAsDefaultInstance();
1829 static Argument* default_instance_;
1830};
1831// -------------------------------------------------------------------
1832
1833class DeviceOption : public ::google::protobuf::Message {
1834 public:
1835 DeviceOption();
1836 virtual ~DeviceOption();
1837
1838 DeviceOption(const DeviceOption& from);
1839
1840 inline DeviceOption& operator=(const DeviceOption& from) {
1841 CopyFrom(from);
1842 return *this;
1843 }
1844
1845 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1846 return _unknown_fields_;
1847 }
1848
1849 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1850 return &_unknown_fields_;
1851 }
1852
1853 static const ::google::protobuf::Descriptor* descriptor();
1854 static const DeviceOption& default_instance();
1855
1856 void Swap(DeviceOption* other);
1857
1858 // implements Message ----------------------------------------------
1859
1860 DeviceOption* New() const;
1861 void CopyFrom(const ::google::protobuf::Message& from);
1862 void MergeFrom(const ::google::protobuf::Message& from);
1863 void CopyFrom(const DeviceOption& from);
1864 void MergeFrom(const DeviceOption& from);
1865 void Clear();
1866 bool IsInitialized() const;
1867
1868 int ByteSize() const;
1869 bool MergePartialFromCodedStream(
1870 ::google::protobuf::io::CodedInputStream* input);
1871 void SerializeWithCachedSizes(
1872 ::google::protobuf::io::CodedOutputStream* output) const;
1873 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1874 int GetCachedSize() const { return _cached_size_; }
1875 private:
1876 void SharedCtor();
1877 void SharedDtor();
1878 void SetCachedSize(int size) const;
1879 public:
1880 ::google::protobuf::Metadata GetMetadata() const;
1881
1882 // nested types ----------------------------------------------------
1883
1884 // accessors -------------------------------------------------------
1885
1886 // optional int32 device_type = 1 [default = 0];
1887 inline bool has_device_type() const;
1888 inline void clear_device_type();
1889 static const int kDeviceTypeFieldNumber = 1;
1890 inline ::google::protobuf::int32 device_type() const;
1891 inline void set_device_type(::google::protobuf::int32 value);
1892
1893 // optional int32 device_id = 2;
1894 inline bool has_device_id() const;
1895 inline void clear_device_id();
1896 static const int kDeviceIdFieldNumber = 2;
1897 inline ::google::protobuf::int32 device_id() const;
1898 inline void set_device_id(::google::protobuf::int32 value);
1899
1900 // optional uint32 random_seed = 3;
1901 inline bool has_random_seed() const;
1902 inline void clear_random_seed();
1903 static const int kRandomSeedFieldNumber = 3;
1904 inline ::google::protobuf::uint32 random_seed() const;
1905 inline void set_random_seed(::google::protobuf::uint32 value);
1906
1907 // optional string node_name = 4;
1908 inline bool has_node_name() const;
1909 inline void clear_node_name();
1910 static const int kNodeNameFieldNumber = 4;
1911 inline const ::std::string& node_name() const;
1912 inline void set_node_name(const ::std::string& value);
1913 inline void set_node_name(const char* value);
1914 inline void set_node_name(const char* value, size_t size);
1915 inline ::std::string* mutable_node_name();
1916 inline ::std::string* release_node_name();
1917 inline void set_allocated_node_name(::std::string* node_name);
1918
1919 // optional int32 numa_node_id = 5;
1920 inline bool has_numa_node_id() const;
1921 inline void clear_numa_node_id();
1922 static const int kNumaNodeIdFieldNumber = 5;
1923 inline ::google::protobuf::int32 numa_node_id() const;
1924 inline void set_numa_node_id(::google::protobuf::int32 value);
1925
1926 // repeated string extra_info = 6;
1927 inline int extra_info_size() const;
1928 inline void clear_extra_info();
1929 static const int kExtraInfoFieldNumber = 6;
1930 inline const ::std::string& extra_info(int index) const;
1931 inline ::std::string* mutable_extra_info(int index);
1932 inline void set_extra_info(int index, const ::std::string& value);
1933 inline void set_extra_info(int index, const char* value);
1934 inline void set_extra_info(int index, const char* value, size_t size);
1935 inline ::std::string* add_extra_info();
1936 inline void add_extra_info(const ::std::string& value);
1937 inline void add_extra_info(const char* value);
1938 inline void add_extra_info(const char* value, size_t size);
1939 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& extra_info() const;
1940 inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_extra_info();
1941
1942 // @@protoc_insertion_point(class_scope:caffe2.DeviceOption)
1943 private:
1944 inline void set_has_device_type();
1945 inline void clear_has_device_type();
1946 inline void set_has_device_id();
1947 inline void clear_has_device_id();
1948 inline void set_has_random_seed();
1949 inline void clear_has_random_seed();
1950 inline void set_has_node_name();
1951 inline void clear_has_node_name();
1952 inline void set_has_numa_node_id();
1953 inline void clear_has_numa_node_id();
1954
1955 ::google::protobuf::UnknownFieldSet _unknown_fields_;
1956
1957 ::google::protobuf::uint32 _has_bits_[1];
1958 mutable int _cached_size_;
1959 ::google::protobuf::int32 device_type_;
1960 ::google::protobuf::int32 device_id_;
1961 ::std::string* node_name_;
1962 ::google::protobuf::uint32 random_seed_;
1963 ::google::protobuf::int32 numa_node_id_;
1964 ::google::protobuf::RepeatedPtrField< ::std::string> extra_info_;
1965 friend void protobuf_AddDesc_caffe2_2eproto();
1966 friend void protobuf_AssignDesc_caffe2_2eproto();
1967 friend void protobuf_ShutdownFile_caffe2_2eproto();
1968
1969 void InitAsDefaultInstance();
1970 static DeviceOption* default_instance_;
1971};
1972// -------------------------------------------------------------------
1973
1974class OperatorDef : public ::google::protobuf::Message {
1975 public:
1976 OperatorDef();
1977 virtual ~OperatorDef();
1978
1979 OperatorDef(const OperatorDef& from);
1980
1981 inline OperatorDef& operator=(const OperatorDef& from) {
1982 CopyFrom(from);
1983 return *this;
1984 }
1985
1986 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1987 return _unknown_fields_;
1988 }
1989
1990 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1991 return &_unknown_fields_;
1992 }
1993
1994 static const ::google::protobuf::Descriptor* descriptor();
1995 static const OperatorDef& default_instance();
1996
1997 void Swap(OperatorDef* other);
1998
1999 // implements Message ----------------------------------------------
2000
2001 OperatorDef* New() const;
2002 void CopyFrom(const ::google::protobuf::Message& from);
2003 void MergeFrom(const ::google::protobuf::Message& from);
2004 void CopyFrom(const OperatorDef& from);
2005 void MergeFrom(const OperatorDef& from);
2006 void Clear();
2007 bool IsInitialized() const;
2008
2009 int ByteSize() const;
2010 bool MergePartialFromCodedStream(
2011 ::google::protobuf::io::CodedInputStream* input);
2012 void SerializeWithCachedSizes(
2013 ::google::protobuf::io::CodedOutputStream* output) const;
2014 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
2015 int GetCachedSize() const { return _cached_size_; }
2016 private:
2017 void SharedCtor();
2018 void SharedDtor();
2019 void SetCachedSize(int size) const;
2020 public:
2021 ::google::protobuf::Metadata GetMetadata() const;
2022
2023 // nested types ----------------------------------------------------
2024
2025 // accessors -------------------------------------------------------
2026
2027 // repeated string input = 1;
2028 inline int input_size() const;
2029 inline void clear_input();
2030 static const int kInputFieldNumber = 1;
2031 inline const ::std::string& input(int index) const;
2032 inline ::std::string* mutable_input(int index);
2033 inline void set_input(int index, const ::std::string& value);
2034 inline void set_input(int index, const char* value);
2035 inline void set_input(int index, const char* value, size_t size);
2036 inline ::std::string* add_input();
2037 inline void add_input(const ::std::string& value);
2038 inline void add_input(const char* value);
2039 inline void add_input(const char* value, size_t size);
2040 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& input() const;
2041 inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_input();
2042
2043 // repeated string output = 2;
2044 inline int output_size() const;
2045 inline void clear_output();
2046 static const int kOutputFieldNumber = 2;
2047 inline const ::std::string& output(int index) const;
2048 inline ::std::string* mutable_output(int index);
2049 inline void set_output(int index, const ::std::string& value);
2050 inline void set_output(int index, const char* value);
2051 inline void set_output(int index, const char* value, size_t size);
2052 inline ::std::string* add_output();
2053 inline void add_output(const ::std::string& value);
2054 inline void add_output(const char* value);
2055 inline void add_output(const char* value, size_t size);
2056 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& output() const;
2057 inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_output();
2058
2059 // optional string name = 3;
2060 inline bool has_name() const;
2061 inline void clear_name();
2062 static const int kNameFieldNumber = 3;
2063 inline const ::std::string& name() const;
2064 inline void set_name(const ::std::string& value);
2065 inline void set_name(const char* value);
2066 inline void set_name(const char* value, size_t size);
2067 inline ::std::string* mutable_name();
2068 inline ::std::string* release_name();
2069 inline void set_allocated_name(::std::string* name);
2070
2071 // optional string type = 4;
2072 inline bool has_type() const;
2073 inline void clear_type();
2074 static const int kTypeFieldNumber = 4;
2075 inline const ::std::string& type() const;
2076 inline void set_type(const ::std::string& value);
2077 inline void set_type(const char* value);
2078 inline void set_type(const char* value, size_t size);
2079 inline ::std::string* mutable_type();
2080 inline ::std::string* release_type();
2081 inline void set_allocated_type(::std::string* type);
2082
2083 // repeated .caffe2.Argument arg = 5;
2084 inline int arg_size() const;
2085 inline void clear_arg();
2086 static const int kArgFieldNumber = 5;
2087 inline const ::caffe2::Argument& arg(int index) const;
2088 inline ::caffe2::Argument* mutable_arg(int index);
2089 inline ::caffe2::Argument* add_arg();
2090 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::Argument >&
2091 arg() const;
2092 inline ::google::protobuf::RepeatedPtrField< ::caffe2::Argument >*
2093 mutable_arg();
2094
2095 // optional .caffe2.DeviceOption device_option = 6;
2096 inline bool has_device_option() const;
2097 inline void clear_device_option();
2098 static const int kDeviceOptionFieldNumber = 6;
2099 inline const ::caffe2::DeviceOption& device_option() const;
2100 inline ::caffe2::DeviceOption* mutable_device_option();
2101 inline ::caffe2::DeviceOption* release_device_option();
2102 inline void set_allocated_device_option(::caffe2::DeviceOption* device_option);
2103
2104 // optional string engine = 7;
2105 inline bool has_engine() const;
2106 inline void clear_engine();
2107 static const int kEngineFieldNumber = 7;
2108 inline const ::std::string& engine() const;
2109 inline void set_engine(const ::std::string& value);
2110 inline void set_engine(const char* value);
2111 inline void set_engine(const char* value, size_t size);
2112 inline ::std::string* mutable_engine();
2113 inline ::std::string* release_engine();
2114 inline void set_allocated_engine(::std::string* engine);
2115
2116 // repeated string control_input = 8;
2117 inline int control_input_size() const;
2118 inline void clear_control_input();
2119 static const int kControlInputFieldNumber = 8;
2120 inline const ::std::string& control_input(int index) const;
2121 inline ::std::string* mutable_control_input(int index);
2122 inline void set_control_input(int index, const ::std::string& value);
2123 inline void set_control_input(int index, const char* value);
2124 inline void set_control_input(int index, const char* value, size_t size);
2125 inline ::std::string* add_control_input();
2126 inline void add_control_input(const ::std::string& value);
2127 inline void add_control_input(const char* value);
2128 inline void add_control_input(const char* value, size_t size);
2129 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& control_input() const;
2130 inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_control_input();
2131
2132 // optional bool is_gradient_op = 9 [default = false];
2133 inline bool has_is_gradient_op() const;
2134 inline void clear_is_gradient_op();
2135 static const int kIsGradientOpFieldNumber = 9;
2136 inline bool is_gradient_op() const;
2137 inline void set_is_gradient_op(bool value);
2138
2139 // optional string debug_info = 10;
2140 inline bool has_debug_info() const;
2141 inline void clear_debug_info();
2142 static const int kDebugInfoFieldNumber = 10;
2143 inline const ::std::string& debug_info() const;
2144 inline void set_debug_info(const ::std::string& value);
2145 inline void set_debug_info(const char* value);
2146 inline void set_debug_info(const char* value, size_t size);
2147 inline ::std::string* mutable_debug_info();
2148 inline ::std::string* release_debug_info();
2149 inline void set_allocated_debug_info(::std::string* debug_info);
2150
2151 // optional string domain = 11;
2152 inline bool has_domain() const;
2153 inline void clear_domain();
2154 static const int kDomainFieldNumber = 11;
2155 inline const ::std::string& domain() const;
2156 inline void set_domain(const ::std::string& value);
2157 inline void set_domain(const char* value);
2158 inline void set_domain(const char* value, size_t size);
2159 inline ::std::string* mutable_domain();
2160 inline ::std::string* release_domain();
2161 inline void set_allocated_domain(::std::string* domain);
2162
2163 // optional int64 op_version = 12;
2164 inline bool has_op_version() const;
2165 inline void clear_op_version();
2166 static const int kOpVersionFieldNumber = 12;
2167 inline ::google::protobuf::int64 op_version() const;
2168 inline void set_op_version(::google::protobuf::int64 value);
2169
2170 // @@protoc_insertion_point(class_scope:caffe2.OperatorDef)
2171 private:
2172 inline void set_has_name();
2173 inline void clear_has_name();
2174 inline void set_has_type();
2175 inline void clear_has_type();
2176 inline void set_has_device_option();
2177 inline void clear_has_device_option();
2178 inline void set_has_engine();
2179 inline void clear_has_engine();
2180 inline void set_has_is_gradient_op();
2181 inline void clear_has_is_gradient_op();
2182 inline void set_has_debug_info();
2183 inline void clear_has_debug_info();
2184 inline void set_has_domain();
2185 inline void clear_has_domain();
2186 inline void set_has_op_version();
2187 inline void clear_has_op_version();
2188
2189 ::google::protobuf::UnknownFieldSet _unknown_fields_;
2190
2191 ::google::protobuf::uint32 _has_bits_[1];
2192 mutable int _cached_size_;
2193 ::google::protobuf::RepeatedPtrField< ::std::string> input_;
2194 ::google::protobuf::RepeatedPtrField< ::std::string> output_;
2195 ::std::string* name_;
2196 ::std::string* type_;
2197 ::google::protobuf::RepeatedPtrField< ::caffe2::Argument > arg_;
2198 ::caffe2::DeviceOption* device_option_;
2199 ::std::string* engine_;
2200 ::google::protobuf::RepeatedPtrField< ::std::string> control_input_;
2201 ::std::string* debug_info_;
2202 ::std::string* domain_;
2203 ::google::protobuf::int64 op_version_;
2204 bool is_gradient_op_;
2205 friend void protobuf_AddDesc_caffe2_2eproto();
2206 friend void protobuf_AssignDesc_caffe2_2eproto();
2207 friend void protobuf_ShutdownFile_caffe2_2eproto();
2208
2209 void InitAsDefaultInstance();
2210 static OperatorDef* default_instance_;
2211};
2212// -------------------------------------------------------------------
2213
2214class MapFieldEntry : public ::google::protobuf::Message {
2215 public:
2216 MapFieldEntry();
2217 virtual ~MapFieldEntry();
2218
2219 MapFieldEntry(const MapFieldEntry& from);
2220
2221 inline MapFieldEntry& operator=(const MapFieldEntry& from) {
2222 CopyFrom(from);
2223 return *this;
2224 }
2225
2226 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2227 return _unknown_fields_;
2228 }
2229
2230 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2231 return &_unknown_fields_;
2232 }
2233
2234 static const ::google::protobuf::Descriptor* descriptor();
2235 static const MapFieldEntry& default_instance();
2236
2237 void Swap(MapFieldEntry* other);
2238
2239 // implements Message ----------------------------------------------
2240
2241 MapFieldEntry* New() const;
2242 void CopyFrom(const ::google::protobuf::Message& from);
2243 void MergeFrom(const ::google::protobuf::Message& from);
2244 void CopyFrom(const MapFieldEntry& from);
2245 void MergeFrom(const MapFieldEntry& from);
2246 void Clear();
2247 bool IsInitialized() const;
2248
2249 int ByteSize() const;
2250 bool MergePartialFromCodedStream(
2251 ::google::protobuf::io::CodedInputStream* input);
2252 void SerializeWithCachedSizes(
2253 ::google::protobuf::io::CodedOutputStream* output) const;
2254 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
2255 int GetCachedSize() const { return _cached_size_; }
2256 private:
2257 void SharedCtor();
2258 void SharedDtor();
2259 void SetCachedSize(int size) const;
2260 public:
2261 ::google::protobuf::Metadata GetMetadata() const;
2262
2263 // nested types ----------------------------------------------------
2264
2265 // accessors -------------------------------------------------------
2266
2267 // required string key = 1;
2268 inline bool has_key() const;
2269 inline void clear_key();
2270 static const int kKeyFieldNumber = 1;
2271 inline const ::std::string& key() const;
2272 inline void set_key(const ::std::string& value);
2273 inline void set_key(const char* value);
2274 inline void set_key(const char* value, size_t size);
2275 inline ::std::string* mutable_key();
2276 inline ::std::string* release_key();
2277 inline void set_allocated_key(::std::string* key);
2278
2279 // required string val = 2;
2280 inline bool has_val() const;
2281 inline void clear_val();
2282 static const int kValFieldNumber = 2;
2283 inline const ::std::string& val() const;
2284 inline void set_val(const ::std::string& value);
2285 inline void set_val(const char* value);
2286 inline void set_val(const char* value, size_t size);
2287 inline ::std::string* mutable_val();
2288 inline ::std::string* release_val();
2289 inline void set_allocated_val(::std::string* val);
2290
2291 // @@protoc_insertion_point(class_scope:caffe2.MapFieldEntry)
2292 private:
2293 inline void set_has_key();
2294 inline void clear_has_key();
2295 inline void set_has_val();
2296 inline void clear_has_val();
2297
2298 ::google::protobuf::UnknownFieldSet _unknown_fields_;
2299
2300 ::google::protobuf::uint32 _has_bits_[1];
2301 mutable int _cached_size_;
2302 ::std::string* key_;
2303 ::std::string* val_;
2304 friend void protobuf_AddDesc_caffe2_2eproto();
2305 friend void protobuf_AssignDesc_caffe2_2eproto();
2306 friend void protobuf_ShutdownFile_caffe2_2eproto();
2307
2308 void InitAsDefaultInstance();
2309 static MapFieldEntry* default_instance_;
2310};
2311// -------------------------------------------------------------------
2312
2313class BackendOptions : public ::google::protobuf::Message {
2314 public:
2315 BackendOptions();
2316 virtual ~BackendOptions();
2317
2318 BackendOptions(const BackendOptions& from);
2319
2320 inline BackendOptions& operator=(const BackendOptions& from) {
2321 CopyFrom(from);
2322 return *this;
2323 }
2324
2325 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2326 return _unknown_fields_;
2327 }
2328
2329 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2330 return &_unknown_fields_;
2331 }
2332
2333 static const ::google::protobuf::Descriptor* descriptor();
2334 static const BackendOptions& default_instance();
2335
2336 void Swap(BackendOptions* other);
2337
2338 // implements Message ----------------------------------------------
2339
2340 BackendOptions* New() const;
2341 void CopyFrom(const ::google::protobuf::Message& from);
2342 void MergeFrom(const ::google::protobuf::Message& from);
2343 void CopyFrom(const BackendOptions& from);
2344 void MergeFrom(const BackendOptions& from);
2345 void Clear();
2346 bool IsInitialized() const;
2347
2348 int ByteSize() const;
2349 bool MergePartialFromCodedStream(
2350 ::google::protobuf::io::CodedInputStream* input);
2351 void SerializeWithCachedSizes(
2352 ::google::protobuf::io::CodedOutputStream* output) const;
2353 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
2354 int GetCachedSize() const { return _cached_size_; }
2355 private:
2356 void SharedCtor();
2357 void SharedDtor();
2358 void SetCachedSize(int size) const;
2359 public:
2360 ::google::protobuf::Metadata GetMetadata() const;
2361
2362 // nested types ----------------------------------------------------
2363
2364 // accessors -------------------------------------------------------
2365
2366 // required string backend_name = 1;
2367 inline bool has_backend_name() const;
2368 inline void clear_backend_name();
2369 static const int kBackendNameFieldNumber = 1;
2370 inline const ::std::string& backend_name() const;
2371 inline void set_backend_name(const ::std::string& value);
2372 inline void set_backend_name(const char* value);
2373 inline void set_backend_name(const char* value, size_t size);
2374 inline ::std::string* mutable_backend_name();
2375 inline ::std::string* release_backend_name();
2376 inline void set_allocated_backend_name(::std::string* backend_name);
2377
2378 // repeated .caffe2.MapFieldEntry option = 2;
2379 inline int option_size() const;
2380 inline void clear_option();
2381 static const int kOptionFieldNumber = 2;
2382 inline const ::caffe2::MapFieldEntry& option(int index) const;
2383 inline ::caffe2::MapFieldEntry* mutable_option(int index);
2384 inline ::caffe2::MapFieldEntry* add_option();
2385 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::MapFieldEntry >&
2386 option() const;
2387 inline ::google::protobuf::RepeatedPtrField< ::caffe2::MapFieldEntry >*
2388 mutable_option();
2389
2390 // @@protoc_insertion_point(class_scope:caffe2.BackendOptions)
2391 private:
2392 inline void set_has_backend_name();
2393 inline void clear_has_backend_name();
2394
2395 ::google::protobuf::UnknownFieldSet _unknown_fields_;
2396
2397 ::google::protobuf::uint32 _has_bits_[1];
2398 mutable int _cached_size_;
2399 ::std::string* backend_name_;
2400 ::google::protobuf::RepeatedPtrField< ::caffe2::MapFieldEntry > option_;
2401 friend void protobuf_AddDesc_caffe2_2eproto();
2402 friend void protobuf_AssignDesc_caffe2_2eproto();
2403 friend void protobuf_ShutdownFile_caffe2_2eproto();
2404
2405 void InitAsDefaultInstance();
2406 static BackendOptions* default_instance_;
2407};
2408// -------------------------------------------------------------------
2409
2410class PartitionInfo : public ::google::protobuf::Message {
2411 public:
2412 PartitionInfo();
2413 virtual ~PartitionInfo();
2414
2415 PartitionInfo(const PartitionInfo& from);
2416
2417 inline PartitionInfo& operator=(const PartitionInfo& from) {
2418 CopyFrom(from);
2419 return *this;
2420 }
2421
2422 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2423 return _unknown_fields_;
2424 }
2425
2426 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2427 return &_unknown_fields_;
2428 }
2429
2430 static const ::google::protobuf::Descriptor* descriptor();
2431 static const PartitionInfo& default_instance();
2432
2433 void Swap(PartitionInfo* other);
2434
2435 // implements Message ----------------------------------------------
2436
2437 PartitionInfo* New() const;
2438 void CopyFrom(const ::google::protobuf::Message& from);
2439 void MergeFrom(const ::google::protobuf::Message& from);
2440 void CopyFrom(const PartitionInfo& from);
2441 void MergeFrom(const PartitionInfo& from);
2442 void Clear();
2443 bool IsInitialized() const;
2444
2445 int ByteSize() const;
2446 bool MergePartialFromCodedStream(
2447 ::google::protobuf::io::CodedInputStream* input);
2448 void SerializeWithCachedSizes(
2449 ::google::protobuf::io::CodedOutputStream* output) const;
2450 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
2451 int GetCachedSize() const { return _cached_size_; }
2452 private:
2453 void SharedCtor();
2454 void SharedDtor();
2455 void SetCachedSize(int size) const;
2456 public:
2457 ::google::protobuf::Metadata GetMetadata() const;
2458
2459 // nested types ----------------------------------------------------
2460
2461 // accessors -------------------------------------------------------
2462
2463 // required string name = 1;
2464 inline bool has_name() const;
2465 inline void clear_name();
2466 static const int kNameFieldNumber = 1;
2467 inline const ::std::string& name() const;
2468 inline void set_name(const ::std::string& value);
2469 inline void set_name(const char* value);
2470 inline void set_name(const char* value, size_t size);
2471 inline ::std::string* mutable_name();
2472 inline ::std::string* release_name();
2473 inline void set_allocated_name(::std::string* name);
2474
2475 // repeated int32 device_id = 2;
2476 inline int device_id_size() const;
2477 inline void clear_device_id();
2478 static const int kDeviceIdFieldNumber = 2;
2479 inline ::google::protobuf::int32 device_id(int index) const;
2480 inline void set_device_id(int index, ::google::protobuf::int32 value);
2481 inline void add_device_id(::google::protobuf::int32 value);
2482 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
2483 device_id() const;
2484 inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
2485 mutable_device_id();
2486
2487 // optional string extra_info = 3;
2488 inline bool has_extra_info() const;
2489 inline void clear_extra_info();
2490 static const int kExtraInfoFieldNumber = 3;
2491 inline const ::std::string& extra_info() const;
2492 inline void set_extra_info(const ::std::string& value);
2493 inline void set_extra_info(const char* value);
2494 inline void set_extra_info(const char* value, size_t size);
2495 inline ::std::string* mutable_extra_info();
2496 inline ::std::string* release_extra_info();
2497 inline void set_allocated_extra_info(::std::string* extra_info);
2498
2499 // repeated .caffe2.BackendOptions backend_options = 4;
2500 inline int backend_options_size() const;
2501 inline void clear_backend_options();
2502 static const int kBackendOptionsFieldNumber = 4;
2503 inline const ::caffe2::BackendOptions& backend_options(int index) const;
2504 inline ::caffe2::BackendOptions* mutable_backend_options(int index);
2505 inline ::caffe2::BackendOptions* add_backend_options();
2506 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::BackendOptions >&
2507 backend_options() const;
2508 inline ::google::protobuf::RepeatedPtrField< ::caffe2::BackendOptions >*
2509 mutable_backend_options();
2510
2511 // @@protoc_insertion_point(class_scope:caffe2.PartitionInfo)
2512 private:
2513 inline void set_has_name();
2514 inline void clear_has_name();
2515 inline void set_has_extra_info();
2516 inline void clear_has_extra_info();
2517
2518 ::google::protobuf::UnknownFieldSet _unknown_fields_;
2519
2520 ::google::protobuf::uint32 _has_bits_[1];
2521 mutable int _cached_size_;
2522 ::std::string* name_;
2523 ::google::protobuf::RepeatedField< ::google::protobuf::int32 > device_id_;
2524 ::std::string* extra_info_;
2525 ::google::protobuf::RepeatedPtrField< ::caffe2::BackendOptions > backend_options_;
2526 friend void protobuf_AddDesc_caffe2_2eproto();
2527 friend void protobuf_AssignDesc_caffe2_2eproto();
2528 friend void protobuf_ShutdownFile_caffe2_2eproto();
2529
2530 void InitAsDefaultInstance();
2531 static PartitionInfo* default_instance_;
2532};
2533// -------------------------------------------------------------------
2534
2535class NetDef : public ::google::protobuf::Message {
2536 public:
2537 NetDef();
2538 virtual ~NetDef();
2539
2540 NetDef(const NetDef& from);
2541
2542 inline NetDef& operator=(const NetDef& from) {
2543 CopyFrom(from);
2544 return *this;
2545 }
2546
2547 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2548 return _unknown_fields_;
2549 }
2550
2551 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2552 return &_unknown_fields_;
2553 }
2554
2555 static const ::google::protobuf::Descriptor* descriptor();
2556 static const NetDef& default_instance();
2557
2558 void Swap(NetDef* other);
2559
2560 // implements Message ----------------------------------------------
2561
2562 NetDef* New() const;
2563 void CopyFrom(const ::google::protobuf::Message& from);
2564 void MergeFrom(const ::google::protobuf::Message& from);
2565 void CopyFrom(const NetDef& from);
2566 void MergeFrom(const NetDef& from);
2567 void Clear();
2568 bool IsInitialized() const;
2569
2570 int ByteSize() const;
2571 bool MergePartialFromCodedStream(
2572 ::google::protobuf::io::CodedInputStream* input);
2573 void SerializeWithCachedSizes(
2574 ::google::protobuf::io::CodedOutputStream* output) const;
2575 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
2576 int GetCachedSize() const { return _cached_size_; }
2577 private:
2578 void SharedCtor();
2579 void SharedDtor();
2580 void SetCachedSize(int size) const;
2581 public:
2582 ::google::protobuf::Metadata GetMetadata() const;
2583
2584 // nested types ----------------------------------------------------
2585
2586 // accessors -------------------------------------------------------
2587
2588 // optional string name = 1;
2589 inline bool has_name() const;
2590 inline void clear_name();
2591 static const int kNameFieldNumber = 1;
2592 inline const ::std::string& name() const;
2593 inline void set_name(const ::std::string& value);
2594 inline void set_name(const char* value);
2595 inline void set_name(const char* value, size_t size);
2596 inline ::std::string* mutable_name();
2597 inline ::std::string* release_name();
2598 inline void set_allocated_name(::std::string* name);
2599
2600 // repeated .caffe2.OperatorDef op = 2;
2601 inline int op_size() const;
2602 inline void clear_op();
2603 static const int kOpFieldNumber = 2;
2604 inline const ::caffe2::OperatorDef& op(int index) const;
2605 inline ::caffe2::OperatorDef* mutable_op(int index);
2606 inline ::caffe2::OperatorDef* add_op();
2607 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::OperatorDef >&
2608 op() const;
2609 inline ::google::protobuf::RepeatedPtrField< ::caffe2::OperatorDef >*
2610 mutable_op();
2611
2612 // optional string type = 3;
2613 inline bool has_type() const;
2614 inline void clear_type();
2615 static const int kTypeFieldNumber = 3;
2616 inline const ::std::string& type() const;
2617 inline void set_type(const ::std::string& value);
2618 inline void set_type(const char* value);
2619 inline void set_type(const char* value, size_t size);
2620 inline ::std::string* mutable_type();
2621 inline ::std::string* release_type();
2622 inline void set_allocated_type(::std::string* type);
2623
2624 // optional int32 num_workers = 4;
2625 inline bool has_num_workers() const;
2626 inline void clear_num_workers();
2627 static const int kNumWorkersFieldNumber = 4;
2628 inline ::google::protobuf::int32 num_workers() const;
2629 inline void set_num_workers(::google::protobuf::int32 value);
2630
2631 // optional .caffe2.DeviceOption device_option = 5;
2632 inline bool has_device_option() const;
2633 inline void clear_device_option();
2634 static const int kDeviceOptionFieldNumber = 5;
2635 inline const ::caffe2::DeviceOption& device_option() const;
2636 inline ::caffe2::DeviceOption* mutable_device_option();
2637 inline ::caffe2::DeviceOption* release_device_option();
2638 inline void set_allocated_device_option(::caffe2::DeviceOption* device_option);
2639
2640 // repeated .caffe2.Argument arg = 6;
2641 inline int arg_size() const;
2642 inline void clear_arg();
2643 static const int kArgFieldNumber = 6;
2644 inline const ::caffe2::Argument& arg(int index) const;
2645 inline ::caffe2::Argument* mutable_arg(int index);
2646 inline ::caffe2::Argument* add_arg();
2647 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::Argument >&
2648 arg() const;
2649 inline ::google::protobuf::RepeatedPtrField< ::caffe2::Argument >*
2650 mutable_arg();
2651
2652 // repeated string external_input = 7;
2653 inline int external_input_size() const;
2654 inline void clear_external_input();
2655 static const int kExternalInputFieldNumber = 7;
2656 inline const ::std::string& external_input(int index) const;
2657 inline ::std::string* mutable_external_input(int index);
2658 inline void set_external_input(int index, const ::std::string& value);
2659 inline void set_external_input(int index, const char* value);
2660 inline void set_external_input(int index, const char* value, size_t size);
2661 inline ::std::string* add_external_input();
2662 inline void add_external_input(const ::std::string& value);
2663 inline void add_external_input(const char* value);
2664 inline void add_external_input(const char* value, size_t size);
2665 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& external_input() const;
2666 inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_external_input();
2667
2668 // repeated string external_output = 8;
2669 inline int external_output_size() const;
2670 inline void clear_external_output();
2671 static const int kExternalOutputFieldNumber = 8;
2672 inline const ::std::string& external_output(int index) const;
2673 inline ::std::string* mutable_external_output(int index);
2674 inline void set_external_output(int index, const ::std::string& value);
2675 inline void set_external_output(int index, const char* value);
2676 inline void set_external_output(int index, const char* value, size_t size);
2677 inline ::std::string* add_external_output();
2678 inline void add_external_output(const ::std::string& value);
2679 inline void add_external_output(const char* value);
2680 inline void add_external_output(const char* value, size_t size);
2681 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& external_output() const;
2682 inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_external_output();
2683
2684 // repeated .caffe2.PartitionInfo partition_info = 9;
2685 inline int partition_info_size() const;
2686 inline void clear_partition_info();
2687 static const int kPartitionInfoFieldNumber = 9;
2688 inline const ::caffe2::PartitionInfo& partition_info(int index) const;
2689 inline ::caffe2::PartitionInfo* mutable_partition_info(int index);
2690 inline ::caffe2::PartitionInfo* add_partition_info();
2691 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::PartitionInfo >&
2692 partition_info() const;
2693 inline ::google::protobuf::RepeatedPtrField< ::caffe2::PartitionInfo >*
2694 mutable_partition_info();
2695
2696 // @@protoc_insertion_point(class_scope:caffe2.NetDef)
2697 private:
2698 inline void set_has_name();
2699 inline void clear_has_name();
2700 inline void set_has_type();
2701 inline void clear_has_type();
2702 inline void set_has_num_workers();
2703 inline void clear_has_num_workers();
2704 inline void set_has_device_option();
2705 inline void clear_has_device_option();
2706
2707 ::google::protobuf::UnknownFieldSet _unknown_fields_;
2708
2709 ::google::protobuf::uint32 _has_bits_[1];
2710 mutable int _cached_size_;
2711 ::std::string* name_;
2712 ::google::protobuf::RepeatedPtrField< ::caffe2::OperatorDef > op_;
2713 ::std::string* type_;
2714 ::caffe2::DeviceOption* device_option_;
2715 ::google::protobuf::RepeatedPtrField< ::caffe2::Argument > arg_;
2716 ::google::protobuf::RepeatedPtrField< ::std::string> external_input_;
2717 ::google::protobuf::RepeatedPtrField< ::std::string> external_output_;
2718 ::google::protobuf::RepeatedPtrField< ::caffe2::PartitionInfo > partition_info_;
2719 ::google::protobuf::int32 num_workers_;
2720 friend void protobuf_AddDesc_caffe2_2eproto();
2721 friend void protobuf_AssignDesc_caffe2_2eproto();
2722 friend void protobuf_ShutdownFile_caffe2_2eproto();
2723
2724 void InitAsDefaultInstance();
2725 static NetDef* default_instance_;
2726};
2727// -------------------------------------------------------------------
2728
2729class ExecutionStep : public ::google::protobuf::Message {
2730 public:
2731 ExecutionStep();
2732 virtual ~ExecutionStep();
2733
2734 ExecutionStep(const ExecutionStep& from);
2735
2736 inline ExecutionStep& operator=(const ExecutionStep& from) {
2737 CopyFrom(from);
2738 return *this;
2739 }
2740
2741 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2742 return _unknown_fields_;
2743 }
2744
2745 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2746 return &_unknown_fields_;
2747 }
2748
2749 static const ::google::protobuf::Descriptor* descriptor();
2750 static const ExecutionStep& default_instance();
2751
2752 void Swap(ExecutionStep* other);
2753
2754 // implements Message ----------------------------------------------
2755
2756 ExecutionStep* New() const;
2757 void CopyFrom(const ::google::protobuf::Message& from);
2758 void MergeFrom(const ::google::protobuf::Message& from);
2759 void CopyFrom(const ExecutionStep& from);
2760 void MergeFrom(const ExecutionStep& from);
2761 void Clear();
2762 bool IsInitialized() const;
2763
2764 int ByteSize() const;
2765 bool MergePartialFromCodedStream(
2766 ::google::protobuf::io::CodedInputStream* input);
2767 void SerializeWithCachedSizes(
2768 ::google::protobuf::io::CodedOutputStream* output) const;
2769 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
2770 int GetCachedSize() const { return _cached_size_; }
2771 private:
2772 void SharedCtor();
2773 void SharedDtor();
2774 void SetCachedSize(int size) const;
2775 public:
2776 ::google::protobuf::Metadata GetMetadata() const;
2777
2778 // nested types ----------------------------------------------------
2779
2780 // accessors -------------------------------------------------------
2781
2782 // optional string name = 1;
2783 inline bool has_name() const;
2784 inline void clear_name();
2785 static const int kNameFieldNumber = 1;
2786 inline const ::std::string& name() const;
2787 inline void set_name(const ::std::string& value);
2788 inline void set_name(const char* value);
2789 inline void set_name(const char* value, size_t size);
2790 inline ::std::string* mutable_name();
2791 inline ::std::string* release_name();
2792 inline void set_allocated_name(::std::string* name);
2793
2794 // repeated .caffe2.ExecutionStep substep = 2;
2795 inline int substep_size() const;
2796 inline void clear_substep();
2797 static const int kSubstepFieldNumber = 2;
2798 inline const ::caffe2::ExecutionStep& substep(int index) const;
2799 inline ::caffe2::ExecutionStep* mutable_substep(int index);
2800 inline ::caffe2::ExecutionStep* add_substep();
2801 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::ExecutionStep >&
2802 substep() const;
2803 inline ::google::protobuf::RepeatedPtrField< ::caffe2::ExecutionStep >*
2804 mutable_substep();
2805
2806 // repeated string network = 3;
2807 inline int network_size() const;
2808 inline void clear_network();
2809 static const int kNetworkFieldNumber = 3;
2810 inline const ::std::string& network(int index) const;
2811 inline ::std::string* mutable_network(int index);
2812 inline void set_network(int index, const ::std::string& value);
2813 inline void set_network(int index, const char* value);
2814 inline void set_network(int index, const char* value, size_t size);
2815 inline ::std::string* add_network();
2816 inline void add_network(const ::std::string& value);
2817 inline void add_network(const char* value);
2818 inline void add_network(const char* value, size_t size);
2819 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& network() const;
2820 inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_network();
2821
2822 // optional int64 num_iter = 4;
2823 inline bool has_num_iter() const;
2824 inline void clear_num_iter();
2825 static const int kNumIterFieldNumber = 4;
2826 inline ::google::protobuf::int64 num_iter() const;
2827 inline void set_num_iter(::google::protobuf::int64 value);
2828
2829 // optional string criteria_network = 5 [deprecated = true];
2830 inline bool has_criteria_network() const PROTOBUF_DEPRECATED;
2831 inline void clear_criteria_network() PROTOBUF_DEPRECATED;
2832 static const int kCriteriaNetworkFieldNumber = 5;
2833 inline const ::std::string& criteria_network() const PROTOBUF_DEPRECATED;
2834 inline void set_criteria_network(const ::std::string& value) PROTOBUF_DEPRECATED;
2835 inline void set_criteria_network(const char* value) PROTOBUF_DEPRECATED;
2836 inline void set_criteria_network(const char* value, size_t size) PROTOBUF_DEPRECATED;
2837 inline ::std::string* mutable_criteria_network() PROTOBUF_DEPRECATED;
2838 inline ::std::string* release_criteria_network() PROTOBUF_DEPRECATED;
2839 inline void set_allocated_criteria_network(::std::string* criteria_network) PROTOBUF_DEPRECATED;
2840
2841 // optional string report_net = 7;
2842 inline bool has_report_net() const;
2843 inline void clear_report_net();
2844 static const int kReportNetFieldNumber = 7;
2845 inline const ::std::string& report_net() const;
2846 inline void set_report_net(const ::std::string& value);
2847 inline void set_report_net(const char* value);
2848 inline void set_report_net(const char* value, size_t size);
2849 inline ::std::string* mutable_report_net();
2850 inline ::std::string* release_report_net();
2851 inline void set_allocated_report_net(::std::string* report_net);
2852
2853 // optional int32 report_interval = 8;
2854 inline bool has_report_interval() const;
2855 inline void clear_report_interval();
2856 static const int kReportIntervalFieldNumber = 8;
2857 inline ::google::protobuf::int32 report_interval() const;
2858 inline void set_report_interval(::google::protobuf::int32 value);
2859
2860 // optional int64 run_every_ms = 11;
2861 inline bool has_run_every_ms() const;
2862 inline void clear_run_every_ms();
2863 static const int kRunEveryMsFieldNumber = 11;
2864 inline ::google::protobuf::int64 run_every_ms() const;
2865 inline void set_run_every_ms(::google::protobuf::int64 value);
2866
2867 // optional bool concurrent_substeps = 6;
2868 inline bool has_concurrent_substeps() const;
2869 inline void clear_concurrent_substeps();
2870 static const int kConcurrentSubstepsFieldNumber = 6;
2871 inline bool concurrent_substeps() const;
2872 inline void set_concurrent_substeps(bool value);
2873
2874 // optional string should_stop_blob = 9;
2875 inline bool has_should_stop_blob() const;
2876 inline void clear_should_stop_blob();
2877 static const int kShouldStopBlobFieldNumber = 9;
2878 inline const ::std::string& should_stop_blob() const;
2879 inline void set_should_stop_blob(const ::std::string& value);
2880 inline void set_should_stop_blob(const char* value);
2881 inline void set_should_stop_blob(const char* value, size_t size);
2882 inline ::std::string* mutable_should_stop_blob();
2883 inline ::std::string* release_should_stop_blob();
2884 inline void set_allocated_should_stop_blob(::std::string* should_stop_blob);
2885
2886 // optional bool only_once = 10;
2887 inline bool has_only_once() const;
2888 inline void clear_only_once();
2889 static const int kOnlyOnceFieldNumber = 10;
2890 inline bool only_once() const;
2891 inline void set_only_once(bool value);
2892
2893 // optional bool create_workspace = 12;
2894 inline bool has_create_workspace() const;
2895 inline void clear_create_workspace();
2896 static const int kCreateWorkspaceFieldNumber = 12;
2897 inline bool create_workspace() const;
2898 inline void set_create_workspace(bool value);
2899
2900 // optional int32 num_concurrent_instances = 13;
2901 inline bool has_num_concurrent_instances() const;
2902 inline void clear_num_concurrent_instances();
2903 static const int kNumConcurrentInstancesFieldNumber = 13;
2904 inline ::google::protobuf::int32 num_concurrent_instances() const;
2905 inline void set_num_concurrent_instances(::google::protobuf::int32 value);
2906
2907 // @@protoc_insertion_point(class_scope:caffe2.ExecutionStep)
2908 private:
2909 inline void set_has_name();
2910 inline void clear_has_name();
2911 inline void set_has_num_iter();
2912 inline void clear_has_num_iter();
2913 inline void set_has_criteria_network();
2914 inline void clear_has_criteria_network();
2915 inline void set_has_report_net();
2916 inline void clear_has_report_net();
2917 inline void set_has_report_interval();
2918 inline void clear_has_report_interval();
2919 inline void set_has_run_every_ms();
2920 inline void clear_has_run_every_ms();
2921 inline void set_has_concurrent_substeps();
2922 inline void clear_has_concurrent_substeps();
2923 inline void set_has_should_stop_blob();
2924 inline void clear_has_should_stop_blob();
2925 inline void set_has_only_once();
2926 inline void clear_has_only_once();
2927 inline void set_has_create_workspace();
2928 inline void clear_has_create_workspace();
2929 inline void set_has_num_concurrent_instances();
2930 inline void clear_has_num_concurrent_instances();
2931
2932 ::google::protobuf::UnknownFieldSet _unknown_fields_;
2933
2934 ::google::protobuf::uint32 _has_bits_[1];
2935 mutable int _cached_size_;
2936 ::std::string* name_;
2937 ::google::protobuf::RepeatedPtrField< ::caffe2::ExecutionStep > substep_;
2938 ::google::protobuf::RepeatedPtrField< ::std::string> network_;
2939 ::google::protobuf::int64 num_iter_;
2940 ::std::string* criteria_network_;
2941 ::std::string* report_net_;
2942 ::google::protobuf::int64 run_every_ms_;
2943 ::google::protobuf::int32 report_interval_;
2944 bool concurrent_substeps_;
2945 bool only_once_;
2946 bool create_workspace_;
2947 ::std::string* should_stop_blob_;
2948 ::google::protobuf::int32 num_concurrent_instances_;
2949 friend void protobuf_AddDesc_caffe2_2eproto();
2950 friend void protobuf_AssignDesc_caffe2_2eproto();
2951 friend void protobuf_ShutdownFile_caffe2_2eproto();
2952
2953 void InitAsDefaultInstance();
2954 static ExecutionStep* default_instance_;
2955};
2956// -------------------------------------------------------------------
2957
2958class PlanDef : public ::google::protobuf::Message {
2959 public:
2960 PlanDef();
2961 virtual ~PlanDef();
2962
2963 PlanDef(const PlanDef& from);
2964
2965 inline PlanDef& operator=(const PlanDef& from) {
2966 CopyFrom(from);
2967 return *this;
2968 }
2969
2970 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2971 return _unknown_fields_;
2972 }
2973
2974 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2975 return &_unknown_fields_;
2976 }
2977
2978 static const ::google::protobuf::Descriptor* descriptor();
2979 static const PlanDef& default_instance();
2980
2981 void Swap(PlanDef* other);
2982
2983 // implements Message ----------------------------------------------
2984
2985 PlanDef* New() const;
2986 void CopyFrom(const ::google::protobuf::Message& from);
2987 void MergeFrom(const ::google::protobuf::Message& from);
2988 void CopyFrom(const PlanDef& from);
2989 void MergeFrom(const PlanDef& from);
2990 void Clear();
2991 bool IsInitialized() const;
2992
2993 int ByteSize() const;
2994 bool MergePartialFromCodedStream(
2995 ::google::protobuf::io::CodedInputStream* input);
2996 void SerializeWithCachedSizes(
2997 ::google::protobuf::io::CodedOutputStream* output) const;
2998 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
2999 int GetCachedSize() const { return _cached_size_; }
3000 private:
3001 void SharedCtor();
3002 void SharedDtor();
3003 void SetCachedSize(int size) const;
3004 public:
3005 ::google::protobuf::Metadata GetMetadata() const;
3006
3007 // nested types ----------------------------------------------------
3008
3009 // accessors -------------------------------------------------------
3010
3011 // optional string name = 1;
3012 inline bool has_name() const;
3013 inline void clear_name();
3014 static const int kNameFieldNumber = 1;
3015 inline const ::std::string& name() const;
3016 inline void set_name(const ::std::string& value);
3017 inline void set_name(const char* value);
3018 inline void set_name(const char* value, size_t size);
3019 inline ::std::string* mutable_name();
3020 inline ::std::string* release_name();
3021 inline void set_allocated_name(::std::string* name);
3022
3023 // repeated .caffe2.NetDef network = 2;
3024 inline int network_size() const;
3025 inline void clear_network();
3026 static const int kNetworkFieldNumber = 2;
3027 inline const ::caffe2::NetDef& network(int index) const;
3028 inline ::caffe2::NetDef* mutable_network(int index);
3029 inline ::caffe2::NetDef* add_network();
3030 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::NetDef >&
3031 network() const;
3032 inline ::google::protobuf::RepeatedPtrField< ::caffe2::NetDef >*
3033 mutable_network();
3034
3035 // repeated .caffe2.ExecutionStep execution_step = 3;
3036 inline int execution_step_size() const;
3037 inline void clear_execution_step();
3038 static const int kExecutionStepFieldNumber = 3;
3039 inline const ::caffe2::ExecutionStep& execution_step(int index) const;
3040 inline ::caffe2::ExecutionStep* mutable_execution_step(int index);
3041 inline ::caffe2::ExecutionStep* add_execution_step();
3042 inline const ::google::protobuf::RepeatedPtrField< ::caffe2::ExecutionStep >&
3043 execution_step() const;
3044 inline ::google::protobuf::RepeatedPtrField< ::caffe2::ExecutionStep >*
3045 mutable_execution_step();
3046
3047 // @@protoc_insertion_point(class_scope:caffe2.PlanDef)
3048 private:
3049 inline void set_has_name();
3050 inline void clear_has_name();
3051
3052 ::google::protobuf::UnknownFieldSet _unknown_fields_;
3053
3054 ::google::protobuf::uint32 _has_bits_[1];
3055 mutable int _cached_size_;
3056 ::std::string* name_;
3057 ::google::protobuf::RepeatedPtrField< ::caffe2::NetDef > network_;
3058 ::google::protobuf::RepeatedPtrField< ::caffe2::ExecutionStep > execution_step_;
3059 friend void protobuf_AddDesc_caffe2_2eproto();
3060 friend void protobuf_AssignDesc_caffe2_2eproto();
3061 friend void protobuf_ShutdownFile_caffe2_2eproto();
3062
3063 void InitAsDefaultInstance();
3064 static PlanDef* default_instance_;
3065};
3066// -------------------------------------------------------------------
3067
3068class BlobProto : public ::google::protobuf::Message {
3069 public:
3070 BlobProto();
3071 virtual ~BlobProto();
3072
3073 BlobProto(const BlobProto& from);
3074
3075 inline BlobProto& operator=(const BlobProto& from) {
3076 CopyFrom(from);
3077 return *this;
3078 }
3079
3080 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
3081 return _unknown_fields_;
3082 }
3083
3084 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
3085 return &_unknown_fields_;
3086 }
3087
3088 static const ::google::protobuf::Descriptor* descriptor();
3089 static const BlobProto& default_instance();
3090
3091 void Swap(BlobProto* other);
3092
3093 // implements Message ----------------------------------------------
3094
3095 BlobProto* New() const;
3096 void CopyFrom(const ::google::protobuf::Message& from);
3097 void MergeFrom(const ::google::protobuf::Message& from);
3098 void CopyFrom(const BlobProto& from);
3099 void MergeFrom(const BlobProto& from);
3100 void Clear();
3101 bool IsInitialized() const;
3102
3103 int ByteSize() const;
3104 bool MergePartialFromCodedStream(
3105 ::google::protobuf::io::CodedInputStream* input);
3106 void SerializeWithCachedSizes(
3107 ::google::protobuf::io::CodedOutputStream* output) const;
3108 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
3109 int GetCachedSize() const { return _cached_size_; }
3110 private:
3111 void SharedCtor();
3112 void SharedDtor();
3113 void SetCachedSize(int size) const;
3114 public:
3115 ::google::protobuf::Metadata GetMetadata() const;
3116
3117 // nested types ----------------------------------------------------
3118
3119 // accessors -------------------------------------------------------
3120
3121 // optional string name = 1;
3122 inline bool has_name() const;
3123 inline void clear_name();
3124 static const int kNameFieldNumber = 1;
3125 inline const ::std::string& name() const;
3126 inline void set_name(const ::std::string& value);
3127 inline void set_name(const char* value);
3128 inline void set_name(const char* value, size_t size);
3129 inline ::std::string* mutable_name();
3130 inline ::std::string* release_name();
3131 inline void set_allocated_name(::std::string* name);
3132
3133 // optional string type = 2;
3134 inline bool has_type() const;
3135 inline void clear_type();
3136 static const int kTypeFieldNumber = 2;
3137 inline const ::std::string& type() const;
3138 inline void set_type(const ::std::string& value);
3139 inline void set_type(const char* value);
3140 inline void set_type(const char* value, size_t size);
3141 inline ::std::string* mutable_type();
3142 inline ::std::string* release_type();
3143 inline void set_allocated_type(::std::string* type);
3144
3145 // optional .caffe2.TensorProto tensor = 3;
3146 inline bool has_tensor() const;
3147 inline void clear_tensor();
3148 static const int kTensorFieldNumber = 3;
3149 inline const ::caffe2::TensorProto& tensor() const;
3150 inline ::caffe2::TensorProto* mutable_tensor();
3151 inline ::caffe2::TensorProto* release_tensor();
3152 inline void set_allocated_tensor(::caffe2::TensorProto* tensor);
3153
3154 // optional bytes content = 4;
3155 inline bool has_content() const;
3156 inline void clear_content();
3157 static const int kContentFieldNumber = 4;
3158 inline const ::std::string& content() const;
3159 inline void set_content(const ::std::string& value);
3160 inline void set_content(const char* value);
3161 inline void set_content(const void* value, size_t size);
3162 inline ::std::string* mutable_content();
3163 inline ::std::string* release_content();
3164 inline void set_allocated_content(::std::string* content);
3165
3166 // optional .caffe2.QTensorProto qtensor = 5;
3167 inline bool has_qtensor() const;
3168 inline void clear_qtensor();
3169 static const int kQtensorFieldNumber = 5;
3170 inline const ::caffe2::QTensorProto& qtensor() const;
3171 inline ::caffe2::QTensorProto* mutable_qtensor();
3172 inline ::caffe2::QTensorProto* release_qtensor();
3173 inline void set_allocated_qtensor(::caffe2::QTensorProto* qtensor);
3174
3175 // optional int32 content_num_chunks = 6;
3176 inline bool has_content_num_chunks() const;
3177 inline void clear_content_num_chunks();
3178 static const int kContentNumChunksFieldNumber = 6;
3179 inline ::google::protobuf::int32 content_num_chunks() const;
3180 inline void set_content_num_chunks(::google::protobuf::int32 value);
3181
3182 // optional int32 content_chunk_id = 7;
3183 inline bool has_content_chunk_id() const;
3184 inline void clear_content_chunk_id();
3185 static const int kContentChunkIdFieldNumber = 7;
3186 inline ::google::protobuf::int32 content_chunk_id() const;
3187 inline void set_content_chunk_id(::google::protobuf::int32 value);
3188
3189 // @@protoc_insertion_point(class_scope:caffe2.BlobProto)
3190 private:
3191 inline void set_has_name();
3192 inline void clear_has_name();
3193 inline void set_has_type();
3194 inline void clear_has_type();
3195 inline void set_has_tensor();
3196 inline void clear_has_tensor();
3197 inline void set_has_content();
3198 inline void clear_has_content();
3199 inline void set_has_qtensor();
3200 inline void clear_has_qtensor();
3201 inline void set_has_content_num_chunks();
3202 inline void clear_has_content_num_chunks();
3203 inline void set_has_content_chunk_id();
3204 inline void clear_has_content_chunk_id();
3205
3206 ::google::protobuf::UnknownFieldSet _unknown_fields_;
3207
3208 ::google::protobuf::uint32 _has_bits_[1];
3209 mutable int _cached_size_;
3210 ::std::string* name_;
3211 ::std::string* type_;
3212 ::caffe2::TensorProto* tensor_;
3213 ::std::string* content_;
3214 ::caffe2::QTensorProto* qtensor_;
3215 ::google::protobuf::int32 content_num_chunks_;
3216 ::google::protobuf::int32 content_chunk_id_;
3217 friend void protobuf_AddDesc_caffe2_2eproto();
3218 friend void protobuf_AssignDesc_caffe2_2eproto();
3219 friend void protobuf_ShutdownFile_caffe2_2eproto();
3220
3221 void InitAsDefaultInstance();
3222 static BlobProto* default_instance_;
3223};
3224// -------------------------------------------------------------------
3225
3226class DBReaderProto : public ::google::protobuf::Message {
3227 public:
3228 DBReaderProto();
3229 virtual ~DBReaderProto();
3230
3231 DBReaderProto(const DBReaderProto& from);
3232
3233 inline DBReaderProto& operator=(const DBReaderProto& from) {
3234 CopyFrom(from);
3235 return *this;
3236 }
3237
3238 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
3239 return _unknown_fields_;
3240 }
3241
3242 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
3243 return &_unknown_fields_;
3244 }
3245
3246 static const ::google::protobuf::Descriptor* descriptor();
3247 static const DBReaderProto& default_instance();
3248
3249 void Swap(DBReaderProto* other);
3250
3251 // implements Message ----------------------------------------------
3252
3253 DBReaderProto* New() const;
3254 void CopyFrom(const ::google::protobuf::Message& from);
3255 void MergeFrom(const ::google::protobuf::Message& from);
3256 void CopyFrom(const DBReaderProto& from);
3257 void MergeFrom(const DBReaderProto& from);
3258 void Clear();
3259 bool IsInitialized() const;
3260
3261 int ByteSize() const;
3262 bool MergePartialFromCodedStream(
3263 ::google::protobuf::io::CodedInputStream* input);
3264 void SerializeWithCachedSizes(
3265 ::google::protobuf::io::CodedOutputStream* output) const;
3266 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
3267 int GetCachedSize() const { return _cached_size_; }
3268 private:
3269 void SharedCtor();
3270 void SharedDtor();
3271 void SetCachedSize(int size) const;
3272 public:
3273 ::google::protobuf::Metadata GetMetadata() const;
3274
3275 // nested types ----------------------------------------------------
3276
3277 // accessors -------------------------------------------------------
3278
3279 // optional string name = 1;
3280 inline bool has_name() const;
3281 inline void clear_name();
3282 static const int kNameFieldNumber = 1;
3283 inline const ::std::string& name() const;
3284 inline void set_name(const ::std::string& value);
3285 inline void set_name(const char* value);
3286 inline void set_name(const char* value, size_t size);
3287 inline ::std::string* mutable_name();
3288 inline ::std::string* release_name();
3289 inline void set_allocated_name(::std::string* name);
3290
3291 // optional string source = 2;
3292 inline bool has_source() const;
3293 inline void clear_source();
3294 static const int kSourceFieldNumber = 2;
3295 inline const ::std::string& source() const;
3296 inline void set_source(const ::std::string& value);
3297 inline void set_source(const char* value);
3298 inline void set_source(const char* value, size_t size);
3299 inline ::std::string* mutable_source();
3300 inline ::std::string* release_source();
3301 inline void set_allocated_source(::std::string* source);
3302
3303 // optional string db_type = 3;
3304 inline bool has_db_type() const;
3305 inline void clear_db_type();
3306 static const int kDbTypeFieldNumber = 3;
3307 inline const ::std::string& db_type() const;
3308 inline void set_db_type(const ::std::string& value);
3309 inline void set_db_type(const char* value);
3310 inline void set_db_type(const char* value, size_t size);
3311 inline ::std::string* mutable_db_type();
3312 inline ::std::string* release_db_type();
3313 inline void set_allocated_db_type(::std::string* db_type);
3314
3315 // optional string key = 4;
3316 inline bool has_key() const;
3317 inline void clear_key();
3318 static const int kKeyFieldNumber = 4;
3319 inline const ::std::string& key() const;
3320 inline void set_key(const ::std::string& value);
3321 inline void set_key(const char* value);
3322 inline void set_key(const char* value, size_t size);
3323 inline ::std::string* mutable_key();
3324 inline ::std::string* release_key();
3325 inline void set_allocated_key(::std::string* key);
3326
3327 // @@protoc_insertion_point(class_scope:caffe2.DBReaderProto)
3328 private:
3329 inline void set_has_name();
3330 inline void clear_has_name();
3331 inline void set_has_source();
3332 inline void clear_has_source();
3333 inline void set_has_db_type();
3334 inline void clear_has_db_type();
3335 inline void set_has_key();
3336 inline void clear_has_key();
3337
3338 ::google::protobuf::UnknownFieldSet _unknown_fields_;
3339
3340 ::google::protobuf::uint32 _has_bits_[1];
3341 mutable int _cached_size_;
3342 ::std::string* name_;
3343 ::std::string* source_;
3344 ::std::string* db_type_;
3345 ::std::string* key_;
3346 friend void protobuf_AddDesc_caffe2_2eproto();
3347 friend void protobuf_AssignDesc_caffe2_2eproto();
3348 friend void protobuf_ShutdownFile_caffe2_2eproto();
3349
3350 void InitAsDefaultInstance();
3351 static DBReaderProto* default_instance_;
3352};
3353// ===================================================================
3354
3355
3356// ===================================================================
3357
3358// ExternalDataProto
3359
3360// optional .caffe2.ExternalDataProto.SourceType source_type = 1 [default = INLINE_CONTAINER];
3361inline bool ExternalDataProto::has_source_type() const {
3362 return (_has_bits_[0] & 0x00000001u) != 0;
3363}
3364inline void ExternalDataProto::set_has_source_type() {
3365 _has_bits_[0] |= 0x00000001u;
3366}
3367inline void ExternalDataProto::clear_has_source_type() {
3368 _has_bits_[0] &= ~0x00000001u;
3369}
3370inline void ExternalDataProto::clear_source_type() {
3371 source_type_ = 0;
3372 clear_has_source_type();
3373}
3374inline ::caffe2::ExternalDataProto_SourceType ExternalDataProto::source_type() const {
3375 // @@protoc_insertion_point(field_get:caffe2.ExternalDataProto.source_type)
3376 return static_cast< ::caffe2::ExternalDataProto_SourceType >(source_type_);
3377}
3378inline void ExternalDataProto::set_source_type(::caffe2::ExternalDataProto_SourceType value) {
3379 assert(::caffe2::ExternalDataProto_SourceType_IsValid(value));
3380 set_has_source_type();
3381 source_type_ = value;
3382 // @@protoc_insertion_point(field_set:caffe2.ExternalDataProto.source_type)
3383}
3384
3385// optional string record_id = 2;
3386inline bool ExternalDataProto::has_record_id() const {
3387 return (_has_bits_[0] & 0x00000002u) != 0;
3388}
3389inline void ExternalDataProto::set_has_record_id() {
3390 _has_bits_[0] |= 0x00000002u;
3391}
3392inline void ExternalDataProto::clear_has_record_id() {
3393 _has_bits_[0] &= ~0x00000002u;
3394}
3395inline void ExternalDataProto::clear_record_id() {
3396 if (record_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3397 record_id_->clear();
3398 }
3399 clear_has_record_id();
3400}
3401inline const ::std::string& ExternalDataProto::record_id() const {
3402 // @@protoc_insertion_point(field_get:caffe2.ExternalDataProto.record_id)
3403 return *record_id_;
3404}
3405inline void ExternalDataProto::set_record_id(const ::std::string& value) {
3406 set_has_record_id();
3407 if (record_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3408 record_id_ = new ::std::string;
3409 }
3410 record_id_->assign(value);
3411 // @@protoc_insertion_point(field_set:caffe2.ExternalDataProto.record_id)
3412}
3413inline void ExternalDataProto::set_record_id(const char* value) {
3414 set_has_record_id();
3415 if (record_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3416 record_id_ = new ::std::string;
3417 }
3418 record_id_->assign(value);
3419 // @@protoc_insertion_point(field_set_char:caffe2.ExternalDataProto.record_id)
3420}
3421inline void ExternalDataProto::set_record_id(const char* value, size_t size) {
3422 set_has_record_id();
3423 if (record_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3424 record_id_ = new ::std::string;
3425 }
3426 record_id_->assign(reinterpret_cast<const char*>(value), size);
3427 // @@protoc_insertion_point(field_set_pointer:caffe2.ExternalDataProto.record_id)
3428}
3429inline ::std::string* ExternalDataProto::mutable_record_id() {
3430 set_has_record_id();
3431 if (record_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3432 record_id_ = new ::std::string;
3433 }
3434 // @@protoc_insertion_point(field_mutable:caffe2.ExternalDataProto.record_id)
3435 return record_id_;
3436}
3437inline ::std::string* ExternalDataProto::release_record_id() {
3438 clear_has_record_id();
3439 if (record_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3440 return NULL;
3441 } else {
3442 ::std::string* temp = record_id_;
3443 record_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3444 return temp;
3445 }
3446}
3447inline void ExternalDataProto::set_allocated_record_id(::std::string* record_id) {
3448 if (record_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3449 delete record_id_;
3450 }
3451 if (record_id) {
3452 set_has_record_id();
3453 record_id_ = record_id;
3454 } else {
3455 clear_has_record_id();
3456 record_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3457 }
3458 // @@protoc_insertion_point(field_set_allocated:caffe2.ExternalDataProto.record_id)
3459}
3460
3461// optional uint64 record_size = 5;
3462inline bool ExternalDataProto::has_record_size() const {
3463 return (_has_bits_[0] & 0x00000004u) != 0;
3464}
3465inline void ExternalDataProto::set_has_record_size() {
3466 _has_bits_[0] |= 0x00000004u;
3467}
3468inline void ExternalDataProto::clear_has_record_size() {
3469 _has_bits_[0] &= ~0x00000004u;
3470}
3471inline void ExternalDataProto::clear_record_size() {
3472 record_size_ = GOOGLE_ULONGLONG(0);
3473 clear_has_record_size();
3474}
3475inline ::google::protobuf::uint64 ExternalDataProto::record_size() const {
3476 // @@protoc_insertion_point(field_get:caffe2.ExternalDataProto.record_size)
3477 return record_size_;
3478}
3479inline void ExternalDataProto::set_record_size(::google::protobuf::uint64 value) {
3480 set_has_record_size();
3481 record_size_ = value;
3482 // @@protoc_insertion_point(field_set:caffe2.ExternalDataProto.record_size)
3483}
3484
3485// optional int64 offset = 3 [default = 0];
3486inline bool ExternalDataProto::has_offset() const {
3487 return (_has_bits_[0] & 0x00000008u) != 0;
3488}
3489inline void ExternalDataProto::set_has_offset() {
3490 _has_bits_[0] |= 0x00000008u;
3491}
3492inline void ExternalDataProto::clear_has_offset() {
3493 _has_bits_[0] &= ~0x00000008u;
3494}
3495inline void ExternalDataProto::clear_offset() {
3496 offset_ = GOOGLE_LONGLONG(0);
3497 clear_has_offset();
3498}
3499inline ::google::protobuf::int64 ExternalDataProto::offset() const {
3500 // @@protoc_insertion_point(field_get:caffe2.ExternalDataProto.offset)
3501 return offset_;
3502}
3503inline void ExternalDataProto::set_offset(::google::protobuf::int64 value) {
3504 set_has_offset();
3505 offset_ = value;
3506 // @@protoc_insertion_point(field_set:caffe2.ExternalDataProto.offset)
3507}
3508
3509// repeated int64 strides = 4;
3510inline int ExternalDataProto::strides_size() const {
3511 return strides_.size();
3512}
3513inline void ExternalDataProto::clear_strides() {
3514 strides_.Clear();
3515}
3516inline ::google::protobuf::int64 ExternalDataProto::strides(int index) const {
3517 // @@protoc_insertion_point(field_get:caffe2.ExternalDataProto.strides)
3518 return strides_.Get(index);
3519}
3520inline void ExternalDataProto::set_strides(int index, ::google::protobuf::int64 value) {
3521 strides_.Set(index, value);
3522 // @@protoc_insertion_point(field_set:caffe2.ExternalDataProto.strides)
3523}
3524inline void ExternalDataProto::add_strides(::google::protobuf::int64 value) {
3525 strides_.Add(value);
3526 // @@protoc_insertion_point(field_add:caffe2.ExternalDataProto.strides)
3527}
3528inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
3529ExternalDataProto::strides() const {
3530 // @@protoc_insertion_point(field_list:caffe2.ExternalDataProto.strides)
3531 return strides_;
3532}
3533inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
3534ExternalDataProto::mutable_strides() {
3535 // @@protoc_insertion_point(field_mutable_list:caffe2.ExternalDataProto.strides)
3536 return &strides_;
3537}
3538
3539// -------------------------------------------------------------------
3540
3541// TensorProto_Segment
3542
3543// required int64 begin = 1;
3544inline bool TensorProto_Segment::has_begin() const {
3545 return (_has_bits_[0] & 0x00000001u) != 0;
3546}
3547inline void TensorProto_Segment::set_has_begin() {
3548 _has_bits_[0] |= 0x00000001u;
3549}
3550inline void TensorProto_Segment::clear_has_begin() {
3551 _has_bits_[0] &= ~0x00000001u;
3552}
3553inline void TensorProto_Segment::clear_begin() {
3554 begin_ = GOOGLE_LONGLONG(0);
3555 clear_has_begin();
3556}
3557inline ::google::protobuf::int64 TensorProto_Segment::begin() const {
3558 // @@protoc_insertion_point(field_get:caffe2.TensorProto.Segment.begin)
3559 return begin_;
3560}
3561inline void TensorProto_Segment::set_begin(::google::protobuf::int64 value) {
3562 set_has_begin();
3563 begin_ = value;
3564 // @@protoc_insertion_point(field_set:caffe2.TensorProto.Segment.begin)
3565}
3566
3567// required int64 end = 2;
3568inline bool TensorProto_Segment::has_end() const {
3569 return (_has_bits_[0] & 0x00000002u) != 0;
3570}
3571inline void TensorProto_Segment::set_has_end() {
3572 _has_bits_[0] |= 0x00000002u;
3573}
3574inline void TensorProto_Segment::clear_has_end() {
3575 _has_bits_[0] &= ~0x00000002u;
3576}
3577inline void TensorProto_Segment::clear_end() {
3578 end_ = GOOGLE_LONGLONG(0);
3579 clear_has_end();
3580}
3581inline ::google::protobuf::int64 TensorProto_Segment::end() const {
3582 // @@protoc_insertion_point(field_get:caffe2.TensorProto.Segment.end)
3583 return end_;
3584}
3585inline void TensorProto_Segment::set_end(::google::protobuf::int64 value) {
3586 set_has_end();
3587 end_ = value;
3588 // @@protoc_insertion_point(field_set:caffe2.TensorProto.Segment.end)
3589}
3590
3591// -------------------------------------------------------------------
3592
3593// TensorProto
3594
3595// repeated int64 dims = 1;
3596inline int TensorProto::dims_size() const {
3597 return dims_.size();
3598}
3599inline void TensorProto::clear_dims() {
3600 dims_.Clear();
3601}
3602inline ::google::protobuf::int64 TensorProto::dims(int index) const {
3603 // @@protoc_insertion_point(field_get:caffe2.TensorProto.dims)
3604 return dims_.Get(index);
3605}
3606inline void TensorProto::set_dims(int index, ::google::protobuf::int64 value) {
3607 dims_.Set(index, value);
3608 // @@protoc_insertion_point(field_set:caffe2.TensorProto.dims)
3609}
3610inline void TensorProto::add_dims(::google::protobuf::int64 value) {
3611 dims_.Add(value);
3612 // @@protoc_insertion_point(field_add:caffe2.TensorProto.dims)
3613}
3614inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
3615TensorProto::dims() const {
3616 // @@protoc_insertion_point(field_list:caffe2.TensorProto.dims)
3617 return dims_;
3618}
3619inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
3620TensorProto::mutable_dims() {
3621 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.dims)
3622 return &dims_;
3623}
3624
3625// optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT];
3626inline bool TensorProto::has_data_type() const {
3627 return (_has_bits_[0] & 0x00000002u) != 0;
3628}
3629inline void TensorProto::set_has_data_type() {
3630 _has_bits_[0] |= 0x00000002u;
3631}
3632inline void TensorProto::clear_has_data_type() {
3633 _has_bits_[0] &= ~0x00000002u;
3634}
3635inline void TensorProto::clear_data_type() {
3636 data_type_ = 1;
3637 clear_has_data_type();
3638}
3639inline ::caffe2::TensorProto_DataType TensorProto::data_type() const {
3640 // @@protoc_insertion_point(field_get:caffe2.TensorProto.data_type)
3641 return static_cast< ::caffe2::TensorProto_DataType >(data_type_);
3642}
3643inline void TensorProto::set_data_type(::caffe2::TensorProto_DataType value) {
3644 assert(::caffe2::TensorProto_DataType_IsValid(value));
3645 set_has_data_type();
3646 data_type_ = value;
3647 // @@protoc_insertion_point(field_set:caffe2.TensorProto.data_type)
3648}
3649
3650// optional .caffe2.TensorProto.StorageType storage_type = 12 [default = TYPED];
3651inline bool TensorProto::has_storage_type() const {
3652 return (_has_bits_[0] & 0x00000004u) != 0;
3653}
3654inline void TensorProto::set_has_storage_type() {
3655 _has_bits_[0] |= 0x00000004u;
3656}
3657inline void TensorProto::clear_has_storage_type() {
3658 _has_bits_[0] &= ~0x00000004u;
3659}
3660inline void TensorProto::clear_storage_type() {
3661 storage_type_ = 1;
3662 clear_has_storage_type();
3663}
3664inline ::caffe2::TensorProto_StorageType TensorProto::storage_type() const {
3665 // @@protoc_insertion_point(field_get:caffe2.TensorProto.storage_type)
3666 return static_cast< ::caffe2::TensorProto_StorageType >(storage_type_);
3667}
3668inline void TensorProto::set_storage_type(::caffe2::TensorProto_StorageType value) {
3669 assert(::caffe2::TensorProto_StorageType_IsValid(value));
3670 set_has_storage_type();
3671 storage_type_ = value;
3672 // @@protoc_insertion_point(field_set:caffe2.TensorProto.storage_type)
3673}
3674
3675// repeated float float_data = 3 [packed = true];
3676inline int TensorProto::float_data_size() const {
3677 return float_data_.size();
3678}
3679inline void TensorProto::clear_float_data() {
3680 float_data_.Clear();
3681}
3682inline float TensorProto::float_data(int index) const {
3683 // @@protoc_insertion_point(field_get:caffe2.TensorProto.float_data)
3684 return float_data_.Get(index);
3685}
3686inline void TensorProto::set_float_data(int index, float value) {
3687 float_data_.Set(index, value);
3688 // @@protoc_insertion_point(field_set:caffe2.TensorProto.float_data)
3689}
3690inline void TensorProto::add_float_data(float value) {
3691 float_data_.Add(value);
3692 // @@protoc_insertion_point(field_add:caffe2.TensorProto.float_data)
3693}
3694inline const ::google::protobuf::RepeatedField< float >&
3695TensorProto::float_data() const {
3696 // @@protoc_insertion_point(field_list:caffe2.TensorProto.float_data)
3697 return float_data_;
3698}
3699inline ::google::protobuf::RepeatedField< float >*
3700TensorProto::mutable_float_data() {
3701 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.float_data)
3702 return &float_data_;
3703}
3704
3705// repeated int32 int32_data = 4 [packed = true];
3706inline int TensorProto::int32_data_size() const {
3707 return int32_data_.size();
3708}
3709inline void TensorProto::clear_int32_data() {
3710 int32_data_.Clear();
3711}
3712inline ::google::protobuf::int32 TensorProto::int32_data(int index) const {
3713 // @@protoc_insertion_point(field_get:caffe2.TensorProto.int32_data)
3714 return int32_data_.Get(index);
3715}
3716inline void TensorProto::set_int32_data(int index, ::google::protobuf::int32 value) {
3717 int32_data_.Set(index, value);
3718 // @@protoc_insertion_point(field_set:caffe2.TensorProto.int32_data)
3719}
3720inline void TensorProto::add_int32_data(::google::protobuf::int32 value) {
3721 int32_data_.Add(value);
3722 // @@protoc_insertion_point(field_add:caffe2.TensorProto.int32_data)
3723}
3724inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
3725TensorProto::int32_data() const {
3726 // @@protoc_insertion_point(field_list:caffe2.TensorProto.int32_data)
3727 return int32_data_;
3728}
3729inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
3730TensorProto::mutable_int32_data() {
3731 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.int32_data)
3732 return &int32_data_;
3733}
3734
3735// optional bytes byte_data = 5;
3736inline bool TensorProto::has_byte_data() const {
3737 return (_has_bits_[0] & 0x00000020u) != 0;
3738}
3739inline void TensorProto::set_has_byte_data() {
3740 _has_bits_[0] |= 0x00000020u;
3741}
3742inline void TensorProto::clear_has_byte_data() {
3743 _has_bits_[0] &= ~0x00000020u;
3744}
3745inline void TensorProto::clear_byte_data() {
3746 if (byte_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3747 byte_data_->clear();
3748 }
3749 clear_has_byte_data();
3750}
3751inline const ::std::string& TensorProto::byte_data() const {
3752 // @@protoc_insertion_point(field_get:caffe2.TensorProto.byte_data)
3753 return *byte_data_;
3754}
3755inline void TensorProto::set_byte_data(const ::std::string& value) {
3756 set_has_byte_data();
3757 if (byte_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3758 byte_data_ = new ::std::string;
3759 }
3760 byte_data_->assign(value);
3761 // @@protoc_insertion_point(field_set:caffe2.TensorProto.byte_data)
3762}
3763inline void TensorProto::set_byte_data(const char* value) {
3764 set_has_byte_data();
3765 if (byte_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3766 byte_data_ = new ::std::string;
3767 }
3768 byte_data_->assign(value);
3769 // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.byte_data)
3770}
3771inline void TensorProto::set_byte_data(const void* value, size_t size) {
3772 set_has_byte_data();
3773 if (byte_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3774 byte_data_ = new ::std::string;
3775 }
3776 byte_data_->assign(reinterpret_cast<const char*>(value), size);
3777 // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.byte_data)
3778}
3779inline ::std::string* TensorProto::mutable_byte_data() {
3780 set_has_byte_data();
3781 if (byte_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3782 byte_data_ = new ::std::string;
3783 }
3784 // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.byte_data)
3785 return byte_data_;
3786}
3787inline ::std::string* TensorProto::release_byte_data() {
3788 clear_has_byte_data();
3789 if (byte_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3790 return NULL;
3791 } else {
3792 ::std::string* temp = byte_data_;
3793 byte_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3794 return temp;
3795 }
3796}
3797inline void TensorProto::set_allocated_byte_data(::std::string* byte_data) {
3798 if (byte_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3799 delete byte_data_;
3800 }
3801 if (byte_data) {
3802 set_has_byte_data();
3803 byte_data_ = byte_data;
3804 } else {
3805 clear_has_byte_data();
3806 byte_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3807 }
3808 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.byte_data)
3809}
3810
3811// repeated bytes string_data = 6;
3812inline int TensorProto::string_data_size() const {
3813 return string_data_.size();
3814}
3815inline void TensorProto::clear_string_data() {
3816 string_data_.Clear();
3817}
3818inline const ::std::string& TensorProto::string_data(int index) const {
3819 // @@protoc_insertion_point(field_get:caffe2.TensorProto.string_data)
3820 return string_data_.Get(index);
3821}
3822inline ::std::string* TensorProto::mutable_string_data(int index) {
3823 // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.string_data)
3824 return string_data_.Mutable(index);
3825}
3826inline void TensorProto::set_string_data(int index, const ::std::string& value) {
3827 // @@protoc_insertion_point(field_set:caffe2.TensorProto.string_data)
3828 string_data_.Mutable(index)->assign(value);
3829}
3830inline void TensorProto::set_string_data(int index, const char* value) {
3831 string_data_.Mutable(index)->assign(value);
3832 // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.string_data)
3833}
3834inline void TensorProto::set_string_data(int index, const void* value, size_t size) {
3835 string_data_.Mutable(index)->assign(
3836 reinterpret_cast<const char*>(value), size);
3837 // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.string_data)
3838}
3839inline ::std::string* TensorProto::add_string_data() {
3840 return string_data_.Add();
3841}
3842inline void TensorProto::add_string_data(const ::std::string& value) {
3843 string_data_.Add()->assign(value);
3844 // @@protoc_insertion_point(field_add:caffe2.TensorProto.string_data)
3845}
3846inline void TensorProto::add_string_data(const char* value) {
3847 string_data_.Add()->assign(value);
3848 // @@protoc_insertion_point(field_add_char:caffe2.TensorProto.string_data)
3849}
3850inline void TensorProto::add_string_data(const void* value, size_t size) {
3851 string_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
3852 // @@protoc_insertion_point(field_add_pointer:caffe2.TensorProto.string_data)
3853}
3854inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
3855TensorProto::string_data() const {
3856 // @@protoc_insertion_point(field_list:caffe2.TensorProto.string_data)
3857 return string_data_;
3858}
3859inline ::google::protobuf::RepeatedPtrField< ::std::string>*
3860TensorProto::mutable_string_data() {
3861 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.string_data)
3862 return &string_data_;
3863}
3864
3865// repeated double double_data = 9 [packed = true];
3866inline int TensorProto::double_data_size() const {
3867 return double_data_.size();
3868}
3869inline void TensorProto::clear_double_data() {
3870 double_data_.Clear();
3871}
3872inline double TensorProto::double_data(int index) const {
3873 // @@protoc_insertion_point(field_get:caffe2.TensorProto.double_data)
3874 return double_data_.Get(index);
3875}
3876inline void TensorProto::set_double_data(int index, double value) {
3877 double_data_.Set(index, value);
3878 // @@protoc_insertion_point(field_set:caffe2.TensorProto.double_data)
3879}
3880inline void TensorProto::add_double_data(double value) {
3881 double_data_.Add(value);
3882 // @@protoc_insertion_point(field_add:caffe2.TensorProto.double_data)
3883}
3884inline const ::google::protobuf::RepeatedField< double >&
3885TensorProto::double_data() const {
3886 // @@protoc_insertion_point(field_list:caffe2.TensorProto.double_data)
3887 return double_data_;
3888}
3889inline ::google::protobuf::RepeatedField< double >*
3890TensorProto::mutable_double_data() {
3891 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.double_data)
3892 return &double_data_;
3893}
3894
3895// repeated int64 int64_data = 10 [packed = true];
3896inline int TensorProto::int64_data_size() const {
3897 return int64_data_.size();
3898}
3899inline void TensorProto::clear_int64_data() {
3900 int64_data_.Clear();
3901}
3902inline ::google::protobuf::int64 TensorProto::int64_data(int index) const {
3903 // @@protoc_insertion_point(field_get:caffe2.TensorProto.int64_data)
3904 return int64_data_.Get(index);
3905}
3906inline void TensorProto::set_int64_data(int index, ::google::protobuf::int64 value) {
3907 int64_data_.Set(index, value);
3908 // @@protoc_insertion_point(field_set:caffe2.TensorProto.int64_data)
3909}
3910inline void TensorProto::add_int64_data(::google::protobuf::int64 value) {
3911 int64_data_.Add(value);
3912 // @@protoc_insertion_point(field_add:caffe2.TensorProto.int64_data)
3913}
3914inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
3915TensorProto::int64_data() const {
3916 // @@protoc_insertion_point(field_list:caffe2.TensorProto.int64_data)
3917 return int64_data_;
3918}
3919inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
3920TensorProto::mutable_int64_data() {
3921 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.int64_data)
3922 return &int64_data_;
3923}
3924
3925// optional bytes raw_data = 13;
3926inline bool TensorProto::has_raw_data() const {
3927 return (_has_bits_[0] & 0x00000200u) != 0;
3928}
3929inline void TensorProto::set_has_raw_data() {
3930 _has_bits_[0] |= 0x00000200u;
3931}
3932inline void TensorProto::clear_has_raw_data() {
3933 _has_bits_[0] &= ~0x00000200u;
3934}
3935inline void TensorProto::clear_raw_data() {
3936 if (raw_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3937 raw_data_->clear();
3938 }
3939 clear_has_raw_data();
3940}
3941inline const ::std::string& TensorProto::raw_data() const {
3942 // @@protoc_insertion_point(field_get:caffe2.TensorProto.raw_data)
3943 return *raw_data_;
3944}
3945inline void TensorProto::set_raw_data(const ::std::string& value) {
3946 set_has_raw_data();
3947 if (raw_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3948 raw_data_ = new ::std::string;
3949 }
3950 raw_data_->assign(value);
3951 // @@protoc_insertion_point(field_set:caffe2.TensorProto.raw_data)
3952}
3953inline void TensorProto::set_raw_data(const char* value) {
3954 set_has_raw_data();
3955 if (raw_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3956 raw_data_ = new ::std::string;
3957 }
3958 raw_data_->assign(value);
3959 // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.raw_data)
3960}
3961inline void TensorProto::set_raw_data(const void* value, size_t size) {
3962 set_has_raw_data();
3963 if (raw_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3964 raw_data_ = new ::std::string;
3965 }
3966 raw_data_->assign(reinterpret_cast<const char*>(value), size);
3967 // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.raw_data)
3968}
3969inline ::std::string* TensorProto::mutable_raw_data() {
3970 set_has_raw_data();
3971 if (raw_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3972 raw_data_ = new ::std::string;
3973 }
3974 // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.raw_data)
3975 return raw_data_;
3976}
3977inline ::std::string* TensorProto::release_raw_data() {
3978 clear_has_raw_data();
3979 if (raw_data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3980 return NULL;
3981 } else {
3982 ::std::string* temp = raw_data_;
3983 raw_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3984 return temp;
3985 }
3986}
3987inline void TensorProto::set_allocated_raw_data(::std::string* raw_data) {
3988 if (raw_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
3989 delete raw_data_;
3990 }
3991 if (raw_data) {
3992 set_has_raw_data();
3993 raw_data_ = raw_data;
3994 } else {
3995 clear_has_raw_data();
3996 raw_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
3997 }
3998 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.raw_data)
3999}
4000
4001// optional .caffe2.ExternalDataProto external_data = 14;
4002inline bool TensorProto::has_external_data() const {
4003 return (_has_bits_[0] & 0x00000400u) != 0;
4004}
4005inline void TensorProto::set_has_external_data() {
4006 _has_bits_[0] |= 0x00000400u;
4007}
4008inline void TensorProto::clear_has_external_data() {
4009 _has_bits_[0] &= ~0x00000400u;
4010}
4011inline void TensorProto::clear_external_data() {
4012 if (external_data_ != NULL) external_data_->::caffe2::ExternalDataProto::Clear();
4013 clear_has_external_data();
4014}
4015inline const ::caffe2::ExternalDataProto& TensorProto::external_data() const {
4016 // @@protoc_insertion_point(field_get:caffe2.TensorProto.external_data)
4017 return external_data_ != NULL ? *external_data_ : *default_instance_->external_data_;
4018}
4019inline ::caffe2::ExternalDataProto* TensorProto::mutable_external_data() {
4020 set_has_external_data();
4021 if (external_data_ == NULL) external_data_ = new ::caffe2::ExternalDataProto;
4022 // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.external_data)
4023 return external_data_;
4024}
4025inline ::caffe2::ExternalDataProto* TensorProto::release_external_data() {
4026 clear_has_external_data();
4027 ::caffe2::ExternalDataProto* temp = external_data_;
4028 external_data_ = NULL;
4029 return temp;
4030}
4031inline void TensorProto::set_allocated_external_data(::caffe2::ExternalDataProto* external_data) {
4032 delete external_data_;
4033 external_data_ = external_data;
4034 if (external_data) {
4035 set_has_external_data();
4036 } else {
4037 clear_has_external_data();
4038 }
4039 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.external_data)
4040}
4041
4042// optional string name = 7;
4043inline bool TensorProto::has_name() const {
4044 return (_has_bits_[0] & 0x00000800u) != 0;
4045}
4046inline void TensorProto::set_has_name() {
4047 _has_bits_[0] |= 0x00000800u;
4048}
4049inline void TensorProto::clear_has_name() {
4050 _has_bits_[0] &= ~0x00000800u;
4051}
4052inline void TensorProto::clear_name() {
4053 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4054 name_->clear();
4055 }
4056 clear_has_name();
4057}
4058inline const ::std::string& TensorProto::name() const {
4059 // @@protoc_insertion_point(field_get:caffe2.TensorProto.name)
4060 return *name_;
4061}
4062inline void TensorProto::set_name(const ::std::string& value) {
4063 set_has_name();
4064 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4065 name_ = new ::std::string;
4066 }
4067 name_->assign(value);
4068 // @@protoc_insertion_point(field_set:caffe2.TensorProto.name)
4069}
4070inline void TensorProto::set_name(const char* value) {
4071 set_has_name();
4072 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4073 name_ = new ::std::string;
4074 }
4075 name_->assign(value);
4076 // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.name)
4077}
4078inline void TensorProto::set_name(const char* value, size_t size) {
4079 set_has_name();
4080 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4081 name_ = new ::std::string;
4082 }
4083 name_->assign(reinterpret_cast<const char*>(value), size);
4084 // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.name)
4085}
4086inline ::std::string* TensorProto::mutable_name() {
4087 set_has_name();
4088 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4089 name_ = new ::std::string;
4090 }
4091 // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.name)
4092 return name_;
4093}
4094inline ::std::string* TensorProto::release_name() {
4095 clear_has_name();
4096 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4097 return NULL;
4098 } else {
4099 ::std::string* temp = name_;
4100 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4101 return temp;
4102 }
4103}
4104inline void TensorProto::set_allocated_name(::std::string* name) {
4105 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4106 delete name_;
4107 }
4108 if (name) {
4109 set_has_name();
4110 name_ = name;
4111 } else {
4112 clear_has_name();
4113 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4114 }
4115 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.name)
4116}
4117
4118// optional .caffe2.DeviceOption device_detail = 8;
4119inline bool TensorProto::has_device_detail() const {
4120 return (_has_bits_[0] & 0x00001000u) != 0;
4121}
4122inline void TensorProto::set_has_device_detail() {
4123 _has_bits_[0] |= 0x00001000u;
4124}
4125inline void TensorProto::clear_has_device_detail() {
4126 _has_bits_[0] &= ~0x00001000u;
4127}
4128inline void TensorProto::clear_device_detail() {
4129 if (device_detail_ != NULL) device_detail_->::caffe2::DeviceOption::Clear();
4130 clear_has_device_detail();
4131}
4132inline const ::caffe2::DeviceOption& TensorProto::device_detail() const {
4133 // @@protoc_insertion_point(field_get:caffe2.TensorProto.device_detail)
4134 return device_detail_ != NULL ? *device_detail_ : *default_instance_->device_detail_;
4135}
4136inline ::caffe2::DeviceOption* TensorProto::mutable_device_detail() {
4137 set_has_device_detail();
4138 if (device_detail_ == NULL) device_detail_ = new ::caffe2::DeviceOption;
4139 // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.device_detail)
4140 return device_detail_;
4141}
4142inline ::caffe2::DeviceOption* TensorProto::release_device_detail() {
4143 clear_has_device_detail();
4144 ::caffe2::DeviceOption* temp = device_detail_;
4145 device_detail_ = NULL;
4146 return temp;
4147}
4148inline void TensorProto::set_allocated_device_detail(::caffe2::DeviceOption* device_detail) {
4149 delete device_detail_;
4150 device_detail_ = device_detail;
4151 if (device_detail) {
4152 set_has_device_detail();
4153 } else {
4154 clear_has_device_detail();
4155 }
4156 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.device_detail)
4157}
4158
4159// optional .caffe2.TensorProto.Segment segment = 11;
4160inline bool TensorProto::has_segment() const {
4161 return (_has_bits_[0] & 0x00002000u) != 0;
4162}
4163inline void TensorProto::set_has_segment() {
4164 _has_bits_[0] |= 0x00002000u;
4165}
4166inline void TensorProto::clear_has_segment() {
4167 _has_bits_[0] &= ~0x00002000u;
4168}
4169inline void TensorProto::clear_segment() {
4170 if (segment_ != NULL) segment_->::caffe2::TensorProto_Segment::Clear();
4171 clear_has_segment();
4172}
4173inline const ::caffe2::TensorProto_Segment& TensorProto::segment() const {
4174 // @@protoc_insertion_point(field_get:caffe2.TensorProto.segment)
4175 return segment_ != NULL ? *segment_ : *default_instance_->segment_;
4176}
4177inline ::caffe2::TensorProto_Segment* TensorProto::mutable_segment() {
4178 set_has_segment();
4179 if (segment_ == NULL) segment_ = new ::caffe2::TensorProto_Segment;
4180 // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.segment)
4181 return segment_;
4182}
4183inline ::caffe2::TensorProto_Segment* TensorProto::release_segment() {
4184 clear_has_segment();
4185 ::caffe2::TensorProto_Segment* temp = segment_;
4186 segment_ = NULL;
4187 return temp;
4188}
4189inline void TensorProto::set_allocated_segment(::caffe2::TensorProto_Segment* segment) {
4190 delete segment_;
4191 segment_ = segment;
4192 if (segment) {
4193 set_has_segment();
4194 } else {
4195 clear_has_segment();
4196 }
4197 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.segment)
4198}
4199
4200// -------------------------------------------------------------------
4201
4202// QTensorProto
4203
4204// repeated int64 dims = 1;
4205inline int QTensorProto::dims_size() const {
4206 return dims_.size();
4207}
4208inline void QTensorProto::clear_dims() {
4209 dims_.Clear();
4210}
4211inline ::google::protobuf::int64 QTensorProto::dims(int index) const {
4212 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.dims)
4213 return dims_.Get(index);
4214}
4215inline void QTensorProto::set_dims(int index, ::google::protobuf::int64 value) {
4216 dims_.Set(index, value);
4217 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.dims)
4218}
4219inline void QTensorProto::add_dims(::google::protobuf::int64 value) {
4220 dims_.Add(value);
4221 // @@protoc_insertion_point(field_add:caffe2.QTensorProto.dims)
4222}
4223inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
4224QTensorProto::dims() const {
4225 // @@protoc_insertion_point(field_list:caffe2.QTensorProto.dims)
4226 return dims_;
4227}
4228inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
4229QTensorProto::mutable_dims() {
4230 // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.dims)
4231 return &dims_;
4232}
4233
4234// required int32 precision = 2;
4235inline bool QTensorProto::has_precision() const {
4236 return (_has_bits_[0] & 0x00000002u) != 0;
4237}
4238inline void QTensorProto::set_has_precision() {
4239 _has_bits_[0] |= 0x00000002u;
4240}
4241inline void QTensorProto::clear_has_precision() {
4242 _has_bits_[0] &= ~0x00000002u;
4243}
4244inline void QTensorProto::clear_precision() {
4245 precision_ = 0;
4246 clear_has_precision();
4247}
4248inline ::google::protobuf::int32 QTensorProto::precision() const {
4249 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.precision)
4250 return precision_;
4251}
4252inline void QTensorProto::set_precision(::google::protobuf::int32 value) {
4253 set_has_precision();
4254 precision_ = value;
4255 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.precision)
4256}
4257
4258// required double scale = 3;
4259inline bool QTensorProto::has_scale() const {
4260 return (_has_bits_[0] & 0x00000004u) != 0;
4261}
4262inline void QTensorProto::set_has_scale() {
4263 _has_bits_[0] |= 0x00000004u;
4264}
4265inline void QTensorProto::clear_has_scale() {
4266 _has_bits_[0] &= ~0x00000004u;
4267}
4268inline void QTensorProto::clear_scale() {
4269 scale_ = 0;
4270 clear_has_scale();
4271}
4272inline double QTensorProto::scale() const {
4273 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.scale)
4274 return scale_;
4275}
4276inline void QTensorProto::set_scale(double value) {
4277 set_has_scale();
4278 scale_ = value;
4279 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.scale)
4280}
4281
4282// required double bias = 4;
4283inline bool QTensorProto::has_bias() const {
4284 return (_has_bits_[0] & 0x00000008u) != 0;
4285}
4286inline void QTensorProto::set_has_bias() {
4287 _has_bits_[0] |= 0x00000008u;
4288}
4289inline void QTensorProto::clear_has_bias() {
4290 _has_bits_[0] &= ~0x00000008u;
4291}
4292inline void QTensorProto::clear_bias() {
4293 bias_ = 0;
4294 clear_has_bias();
4295}
4296inline double QTensorProto::bias() const {
4297 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.bias)
4298 return bias_;
4299}
4300inline void QTensorProto::set_bias(double value) {
4301 set_has_bias();
4302 bias_ = value;
4303 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.bias)
4304}
4305
4306// required bool is_signed = 5;
4307inline bool QTensorProto::has_is_signed() const {
4308 return (_has_bits_[0] & 0x00000010u) != 0;
4309}
4310inline void QTensorProto::set_has_is_signed() {
4311 _has_bits_[0] |= 0x00000010u;
4312}
4313inline void QTensorProto::clear_has_is_signed() {
4314 _has_bits_[0] &= ~0x00000010u;
4315}
4316inline void QTensorProto::clear_is_signed() {
4317 is_signed_ = false;
4318 clear_has_is_signed();
4319}
4320inline bool QTensorProto::is_signed() const {
4321 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.is_signed)
4322 return is_signed_;
4323}
4324inline void QTensorProto::set_is_signed(bool value) {
4325 set_has_is_signed();
4326 is_signed_ = value;
4327 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.is_signed)
4328}
4329
4330// repeated int32 data = 6 [packed = true];
4331inline int QTensorProto::data_size() const {
4332 return data_.size();
4333}
4334inline void QTensorProto::clear_data() {
4335 data_.Clear();
4336}
4337inline ::google::protobuf::int32 QTensorProto::data(int index) const {
4338 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.data)
4339 return data_.Get(index);
4340}
4341inline void QTensorProto::set_data(int index, ::google::protobuf::int32 value) {
4342 data_.Set(index, value);
4343 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.data)
4344}
4345inline void QTensorProto::add_data(::google::protobuf::int32 value) {
4346 data_.Add(value);
4347 // @@protoc_insertion_point(field_add:caffe2.QTensorProto.data)
4348}
4349inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
4350QTensorProto::data() const {
4351 // @@protoc_insertion_point(field_list:caffe2.QTensorProto.data)
4352 return data_;
4353}
4354inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
4355QTensorProto::mutable_data() {
4356 // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.data)
4357 return &data_;
4358}
4359
4360// optional string name = 7;
4361inline bool QTensorProto::has_name() const {
4362 return (_has_bits_[0] & 0x00000040u) != 0;
4363}
4364inline void QTensorProto::set_has_name() {
4365 _has_bits_[0] |= 0x00000040u;
4366}
4367inline void QTensorProto::clear_has_name() {
4368 _has_bits_[0] &= ~0x00000040u;
4369}
4370inline void QTensorProto::clear_name() {
4371 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4372 name_->clear();
4373 }
4374 clear_has_name();
4375}
4376inline const ::std::string& QTensorProto::name() const {
4377 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.name)
4378 return *name_;
4379}
4380inline void QTensorProto::set_name(const ::std::string& value) {
4381 set_has_name();
4382 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4383 name_ = new ::std::string;
4384 }
4385 name_->assign(value);
4386 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.name)
4387}
4388inline void QTensorProto::set_name(const char* value) {
4389 set_has_name();
4390 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4391 name_ = new ::std::string;
4392 }
4393 name_->assign(value);
4394 // @@protoc_insertion_point(field_set_char:caffe2.QTensorProto.name)
4395}
4396inline void QTensorProto::set_name(const char* value, size_t size) {
4397 set_has_name();
4398 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4399 name_ = new ::std::string;
4400 }
4401 name_->assign(reinterpret_cast<const char*>(value), size);
4402 // @@protoc_insertion_point(field_set_pointer:caffe2.QTensorProto.name)
4403}
4404inline ::std::string* QTensorProto::mutable_name() {
4405 set_has_name();
4406 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4407 name_ = new ::std::string;
4408 }
4409 // @@protoc_insertion_point(field_mutable:caffe2.QTensorProto.name)
4410 return name_;
4411}
4412inline ::std::string* QTensorProto::release_name() {
4413 clear_has_name();
4414 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4415 return NULL;
4416 } else {
4417 ::std::string* temp = name_;
4418 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4419 return temp;
4420 }
4421}
4422inline void QTensorProto::set_allocated_name(::std::string* name) {
4423 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4424 delete name_;
4425 }
4426 if (name) {
4427 set_has_name();
4428 name_ = name;
4429 } else {
4430 clear_has_name();
4431 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4432 }
4433 // @@protoc_insertion_point(field_set_allocated:caffe2.QTensorProto.name)
4434}
4435
4436// optional .caffe2.TensorProto.DataType data_type = 8 [default = INT32];
4437inline bool QTensorProto::has_data_type() const {
4438 return (_has_bits_[0] & 0x00000080u) != 0;
4439}
4440inline void QTensorProto::set_has_data_type() {
4441 _has_bits_[0] |= 0x00000080u;
4442}
4443inline void QTensorProto::clear_has_data_type() {
4444 _has_bits_[0] &= ~0x00000080u;
4445}
4446inline void QTensorProto::clear_data_type() {
4447 data_type_ = 2;
4448 clear_has_data_type();
4449}
4450inline ::caffe2::TensorProto_DataType QTensorProto::data_type() const {
4451 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.data_type)
4452 return static_cast< ::caffe2::TensorProto_DataType >(data_type_);
4453}
4454inline void QTensorProto::set_data_type(::caffe2::TensorProto_DataType value) {
4455 assert(::caffe2::TensorProto_DataType_IsValid(value));
4456 set_has_data_type();
4457 data_type_ = value;
4458 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.data_type)
4459}
4460
4461// repeated double scales = 9;
4462inline int QTensorProto::scales_size() const {
4463 return scales_.size();
4464}
4465inline void QTensorProto::clear_scales() {
4466 scales_.Clear();
4467}
4468inline double QTensorProto::scales(int index) const {
4469 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.scales)
4470 return scales_.Get(index);
4471}
4472inline void QTensorProto::set_scales(int index, double value) {
4473 scales_.Set(index, value);
4474 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.scales)
4475}
4476inline void QTensorProto::add_scales(double value) {
4477 scales_.Add(value);
4478 // @@protoc_insertion_point(field_add:caffe2.QTensorProto.scales)
4479}
4480inline const ::google::protobuf::RepeatedField< double >&
4481QTensorProto::scales() const {
4482 // @@protoc_insertion_point(field_list:caffe2.QTensorProto.scales)
4483 return scales_;
4484}
4485inline ::google::protobuf::RepeatedField< double >*
4486QTensorProto::mutable_scales() {
4487 // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.scales)
4488 return &scales_;
4489}
4490
4491// repeated double biases = 10;
4492inline int QTensorProto::biases_size() const {
4493 return biases_.size();
4494}
4495inline void QTensorProto::clear_biases() {
4496 biases_.Clear();
4497}
4498inline double QTensorProto::biases(int index) const {
4499 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.biases)
4500 return biases_.Get(index);
4501}
4502inline void QTensorProto::set_biases(int index, double value) {
4503 biases_.Set(index, value);
4504 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.biases)
4505}
4506inline void QTensorProto::add_biases(double value) {
4507 biases_.Add(value);
4508 // @@protoc_insertion_point(field_add:caffe2.QTensorProto.biases)
4509}
4510inline const ::google::protobuf::RepeatedField< double >&
4511QTensorProto::biases() const {
4512 // @@protoc_insertion_point(field_list:caffe2.QTensorProto.biases)
4513 return biases_;
4514}
4515inline ::google::protobuf::RepeatedField< double >*
4516QTensorProto::mutable_biases() {
4517 // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.biases)
4518 return &biases_;
4519}
4520
4521// optional int32 axis = 11;
4522inline bool QTensorProto::has_axis() const {
4523 return (_has_bits_[0] & 0x00000400u) != 0;
4524}
4525inline void QTensorProto::set_has_axis() {
4526 _has_bits_[0] |= 0x00000400u;
4527}
4528inline void QTensorProto::clear_has_axis() {
4529 _has_bits_[0] &= ~0x00000400u;
4530}
4531inline void QTensorProto::clear_axis() {
4532 axis_ = 0;
4533 clear_has_axis();
4534}
4535inline ::google::protobuf::int32 QTensorProto::axis() const {
4536 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.axis)
4537 return axis_;
4538}
4539inline void QTensorProto::set_axis(::google::protobuf::int32 value) {
4540 set_has_axis();
4541 axis_ = value;
4542 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.axis)
4543}
4544
4545// optional bool is_multiparam = 12 [default = false];
4546inline bool QTensorProto::has_is_multiparam() const {
4547 return (_has_bits_[0] & 0x00000800u) != 0;
4548}
4549inline void QTensorProto::set_has_is_multiparam() {
4550 _has_bits_[0] |= 0x00000800u;
4551}
4552inline void QTensorProto::clear_has_is_multiparam() {
4553 _has_bits_[0] &= ~0x00000800u;
4554}
4555inline void QTensorProto::clear_is_multiparam() {
4556 is_multiparam_ = false;
4557 clear_has_is_multiparam();
4558}
4559inline bool QTensorProto::is_multiparam() const {
4560 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.is_multiparam)
4561 return is_multiparam_;
4562}
4563inline void QTensorProto::set_is_multiparam(bool value) {
4564 set_has_is_multiparam();
4565 is_multiparam_ = value;
4566 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.is_multiparam)
4567}
4568
4569// -------------------------------------------------------------------
4570
4571// TensorProtos
4572
4573// repeated .caffe2.TensorProto protos = 1;
4574inline int TensorProtos::protos_size() const {
4575 return protos_.size();
4576}
4577inline void TensorProtos::clear_protos() {
4578 protos_.Clear();
4579}
4580inline const ::caffe2::TensorProto& TensorProtos::protos(int index) const {
4581 // @@protoc_insertion_point(field_get:caffe2.TensorProtos.protos)
4582 return protos_.Get(index);
4583}
4584inline ::caffe2::TensorProto* TensorProtos::mutable_protos(int index) {
4585 // @@protoc_insertion_point(field_mutable:caffe2.TensorProtos.protos)
4586 return protos_.Mutable(index);
4587}
4588inline ::caffe2::TensorProto* TensorProtos::add_protos() {
4589 // @@protoc_insertion_point(field_add:caffe2.TensorProtos.protos)
4590 return protos_.Add();
4591}
4592inline const ::google::protobuf::RepeatedPtrField< ::caffe2::TensorProto >&
4593TensorProtos::protos() const {
4594 // @@protoc_insertion_point(field_list:caffe2.TensorProtos.protos)
4595 return protos_;
4596}
4597inline ::google::protobuf::RepeatedPtrField< ::caffe2::TensorProto >*
4598TensorProtos::mutable_protos() {
4599 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProtos.protos)
4600 return &protos_;
4601}
4602
4603// -------------------------------------------------------------------
4604
4605// TensorShape
4606
4607// repeated int64 dims = 1;
4608inline int TensorShape::dims_size() const {
4609 return dims_.size();
4610}
4611inline void TensorShape::clear_dims() {
4612 dims_.Clear();
4613}
4614inline ::google::protobuf::int64 TensorShape::dims(int index) const {
4615 // @@protoc_insertion_point(field_get:caffe2.TensorShape.dims)
4616 return dims_.Get(index);
4617}
4618inline void TensorShape::set_dims(int index, ::google::protobuf::int64 value) {
4619 dims_.Set(index, value);
4620 // @@protoc_insertion_point(field_set:caffe2.TensorShape.dims)
4621}
4622inline void TensorShape::add_dims(::google::protobuf::int64 value) {
4623 dims_.Add(value);
4624 // @@protoc_insertion_point(field_add:caffe2.TensorShape.dims)
4625}
4626inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
4627TensorShape::dims() const {
4628 // @@protoc_insertion_point(field_list:caffe2.TensorShape.dims)
4629 return dims_;
4630}
4631inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
4632TensorShape::mutable_dims() {
4633 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorShape.dims)
4634 return &dims_;
4635}
4636
4637// optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT];
4638inline bool TensorShape::has_data_type() const {
4639 return (_has_bits_[0] & 0x00000002u) != 0;
4640}
4641inline void TensorShape::set_has_data_type() {
4642 _has_bits_[0] |= 0x00000002u;
4643}
4644inline void TensorShape::clear_has_data_type() {
4645 _has_bits_[0] &= ~0x00000002u;
4646}
4647inline void TensorShape::clear_data_type() {
4648 data_type_ = 1;
4649 clear_has_data_type();
4650}
4651inline ::caffe2::TensorProto_DataType TensorShape::data_type() const {
4652 // @@protoc_insertion_point(field_get:caffe2.TensorShape.data_type)
4653 return static_cast< ::caffe2::TensorProto_DataType >(data_type_);
4654}
4655inline void TensorShape::set_data_type(::caffe2::TensorProto_DataType value) {
4656 assert(::caffe2::TensorProto_DataType_IsValid(value));
4657 set_has_data_type();
4658 data_type_ = value;
4659 // @@protoc_insertion_point(field_set:caffe2.TensorShape.data_type)
4660}
4661
4662// repeated int32 unknown_dims = 3;
4663inline int TensorShape::unknown_dims_size() const {
4664 return unknown_dims_.size();
4665}
4666inline void TensorShape::clear_unknown_dims() {
4667 unknown_dims_.Clear();
4668}
4669inline ::google::protobuf::int32 TensorShape::unknown_dims(int index) const {
4670 // @@protoc_insertion_point(field_get:caffe2.TensorShape.unknown_dims)
4671 return unknown_dims_.Get(index);
4672}
4673inline void TensorShape::set_unknown_dims(int index, ::google::protobuf::int32 value) {
4674 unknown_dims_.Set(index, value);
4675 // @@protoc_insertion_point(field_set:caffe2.TensorShape.unknown_dims)
4676}
4677inline void TensorShape::add_unknown_dims(::google::protobuf::int32 value) {
4678 unknown_dims_.Add(value);
4679 // @@protoc_insertion_point(field_add:caffe2.TensorShape.unknown_dims)
4680}
4681inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
4682TensorShape::unknown_dims() const {
4683 // @@protoc_insertion_point(field_list:caffe2.TensorShape.unknown_dims)
4684 return unknown_dims_;
4685}
4686inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
4687TensorShape::mutable_unknown_dims() {
4688 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorShape.unknown_dims)
4689 return &unknown_dims_;
4690}
4691
4692// optional bool unknown_shape = 4 [default = false];
4693inline bool TensorShape::has_unknown_shape() const {
4694 return (_has_bits_[0] & 0x00000008u) != 0;
4695}
4696inline void TensorShape::set_has_unknown_shape() {
4697 _has_bits_[0] |= 0x00000008u;
4698}
4699inline void TensorShape::clear_has_unknown_shape() {
4700 _has_bits_[0] &= ~0x00000008u;
4701}
4702inline void TensorShape::clear_unknown_shape() {
4703 unknown_shape_ = false;
4704 clear_has_unknown_shape();
4705}
4706inline bool TensorShape::unknown_shape() const {
4707 // @@protoc_insertion_point(field_get:caffe2.TensorShape.unknown_shape)
4708 return unknown_shape_;
4709}
4710inline void TensorShape::set_unknown_shape(bool value) {
4711 set_has_unknown_shape();
4712 unknown_shape_ = value;
4713 // @@protoc_insertion_point(field_set:caffe2.TensorShape.unknown_shape)
4714}
4715
4716// optional string name = 5;
4717inline bool TensorShape::has_name() const {
4718 return (_has_bits_[0] & 0x00000010u) != 0;
4719}
4720inline void TensorShape::set_has_name() {
4721 _has_bits_[0] |= 0x00000010u;
4722}
4723inline void TensorShape::clear_has_name() {
4724 _has_bits_[0] &= ~0x00000010u;
4725}
4726inline void TensorShape::clear_name() {
4727 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4728 name_->clear();
4729 }
4730 clear_has_name();
4731}
4732inline const ::std::string& TensorShape::name() const {
4733 // @@protoc_insertion_point(field_get:caffe2.TensorShape.name)
4734 return *name_;
4735}
4736inline void TensorShape::set_name(const ::std::string& value) {
4737 set_has_name();
4738 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4739 name_ = new ::std::string;
4740 }
4741 name_->assign(value);
4742 // @@protoc_insertion_point(field_set:caffe2.TensorShape.name)
4743}
4744inline void TensorShape::set_name(const char* value) {
4745 set_has_name();
4746 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4747 name_ = new ::std::string;
4748 }
4749 name_->assign(value);
4750 // @@protoc_insertion_point(field_set_char:caffe2.TensorShape.name)
4751}
4752inline void TensorShape::set_name(const char* value, size_t size) {
4753 set_has_name();
4754 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4755 name_ = new ::std::string;
4756 }
4757 name_->assign(reinterpret_cast<const char*>(value), size);
4758 // @@protoc_insertion_point(field_set_pointer:caffe2.TensorShape.name)
4759}
4760inline ::std::string* TensorShape::mutable_name() {
4761 set_has_name();
4762 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4763 name_ = new ::std::string;
4764 }
4765 // @@protoc_insertion_point(field_mutable:caffe2.TensorShape.name)
4766 return name_;
4767}
4768inline ::std::string* TensorShape::release_name() {
4769 clear_has_name();
4770 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4771 return NULL;
4772 } else {
4773 ::std::string* temp = name_;
4774 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4775 return temp;
4776 }
4777}
4778inline void TensorShape::set_allocated_name(::std::string* name) {
4779 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4780 delete name_;
4781 }
4782 if (name) {
4783 set_has_name();
4784 name_ = name;
4785 } else {
4786 clear_has_name();
4787 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4788 }
4789 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorShape.name)
4790}
4791
4792// -------------------------------------------------------------------
4793
4794// TensorShapes
4795
4796// repeated .caffe2.TensorShape shapes = 1;
4797inline int TensorShapes::shapes_size() const {
4798 return shapes_.size();
4799}
4800inline void TensorShapes::clear_shapes() {
4801 shapes_.Clear();
4802}
4803inline const ::caffe2::TensorShape& TensorShapes::shapes(int index) const {
4804 // @@protoc_insertion_point(field_get:caffe2.TensorShapes.shapes)
4805 return shapes_.Get(index);
4806}
4807inline ::caffe2::TensorShape* TensorShapes::mutable_shapes(int index) {
4808 // @@protoc_insertion_point(field_mutable:caffe2.TensorShapes.shapes)
4809 return shapes_.Mutable(index);
4810}
4811inline ::caffe2::TensorShape* TensorShapes::add_shapes() {
4812 // @@protoc_insertion_point(field_add:caffe2.TensorShapes.shapes)
4813 return shapes_.Add();
4814}
4815inline const ::google::protobuf::RepeatedPtrField< ::caffe2::TensorShape >&
4816TensorShapes::shapes() const {
4817 // @@protoc_insertion_point(field_list:caffe2.TensorShapes.shapes)
4818 return shapes_;
4819}
4820inline ::google::protobuf::RepeatedPtrField< ::caffe2::TensorShape >*
4821TensorShapes::mutable_shapes() {
4822 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorShapes.shapes)
4823 return &shapes_;
4824}
4825
4826// -------------------------------------------------------------------
4827
4828// TensorBoundShape
4829
4830// optional .caffe2.TensorShape shape = 1;
4831inline bool TensorBoundShape::has_shape() const {
4832 return (_has_bits_[0] & 0x00000001u) != 0;
4833}
4834inline void TensorBoundShape::set_has_shape() {
4835 _has_bits_[0] |= 0x00000001u;
4836}
4837inline void TensorBoundShape::clear_has_shape() {
4838 _has_bits_[0] &= ~0x00000001u;
4839}
4840inline void TensorBoundShape::clear_shape() {
4841 if (shape_ != NULL) shape_->::caffe2::TensorShape::Clear();
4842 clear_has_shape();
4843}
4844inline const ::caffe2::TensorShape& TensorBoundShape::shape() const {
4845 // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.shape)
4846 return shape_ != NULL ? *shape_ : *default_instance_->shape_;
4847}
4848inline ::caffe2::TensorShape* TensorBoundShape::mutable_shape() {
4849 set_has_shape();
4850 if (shape_ == NULL) shape_ = new ::caffe2::TensorShape;
4851 // @@protoc_insertion_point(field_mutable:caffe2.TensorBoundShape.shape)
4852 return shape_;
4853}
4854inline ::caffe2::TensorShape* TensorBoundShape::release_shape() {
4855 clear_has_shape();
4856 ::caffe2::TensorShape* temp = shape_;
4857 shape_ = NULL;
4858 return temp;
4859}
4860inline void TensorBoundShape::set_allocated_shape(::caffe2::TensorShape* shape) {
4861 delete shape_;
4862 shape_ = shape;
4863 if (shape) {
4864 set_has_shape();
4865 } else {
4866 clear_has_shape();
4867 }
4868 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorBoundShape.shape)
4869}
4870
4871// repeated .caffe2.TensorBoundShape.DimType dim_type = 2;
4872inline int TensorBoundShape::dim_type_size() const {
4873 return dim_type_.size();
4874}
4875inline void TensorBoundShape::clear_dim_type() {
4876 dim_type_.Clear();
4877}
4878inline ::caffe2::TensorBoundShape_DimType TensorBoundShape::dim_type(int index) const {
4879 // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.dim_type)
4880 return static_cast< ::caffe2::TensorBoundShape_DimType >(dim_type_.Get(index));
4881}
4882inline void TensorBoundShape::set_dim_type(int index, ::caffe2::TensorBoundShape_DimType value) {
4883 assert(::caffe2::TensorBoundShape_DimType_IsValid(value));
4884 dim_type_.Set(index, value);
4885 // @@protoc_insertion_point(field_set:caffe2.TensorBoundShape.dim_type)
4886}
4887inline void TensorBoundShape::add_dim_type(::caffe2::TensorBoundShape_DimType value) {
4888 assert(::caffe2::TensorBoundShape_DimType_IsValid(value));
4889 dim_type_.Add(value);
4890 // @@protoc_insertion_point(field_add:caffe2.TensorBoundShape.dim_type)
4891}
4892inline const ::google::protobuf::RepeatedField<int>&
4893TensorBoundShape::dim_type() const {
4894 // @@protoc_insertion_point(field_list:caffe2.TensorBoundShape.dim_type)
4895 return dim_type_;
4896}
4897inline ::google::protobuf::RepeatedField<int>*
4898TensorBoundShape::mutable_dim_type() {
4899 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorBoundShape.dim_type)
4900 return &dim_type_;
4901}
4902
4903// optional string name = 3;
4904inline bool TensorBoundShape::has_name() const {
4905 return (_has_bits_[0] & 0x00000004u) != 0;
4906}
4907inline void TensorBoundShape::set_has_name() {
4908 _has_bits_[0] |= 0x00000004u;
4909}
4910inline void TensorBoundShape::clear_has_name() {
4911 _has_bits_[0] &= ~0x00000004u;
4912}
4913inline void TensorBoundShape::clear_name() {
4914 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4915 name_->clear();
4916 }
4917 clear_has_name();
4918}
4919inline const ::std::string& TensorBoundShape::name() const {
4920 // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.name)
4921 return *name_;
4922}
4923inline void TensorBoundShape::set_name(const ::std::string& value) {
4924 set_has_name();
4925 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4926 name_ = new ::std::string;
4927 }
4928 name_->assign(value);
4929 // @@protoc_insertion_point(field_set:caffe2.TensorBoundShape.name)
4930}
4931inline void TensorBoundShape::set_name(const char* value) {
4932 set_has_name();
4933 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4934 name_ = new ::std::string;
4935 }
4936 name_->assign(value);
4937 // @@protoc_insertion_point(field_set_char:caffe2.TensorBoundShape.name)
4938}
4939inline void TensorBoundShape::set_name(const char* value, size_t size) {
4940 set_has_name();
4941 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4942 name_ = new ::std::string;
4943 }
4944 name_->assign(reinterpret_cast<const char*>(value), size);
4945 // @@protoc_insertion_point(field_set_pointer:caffe2.TensorBoundShape.name)
4946}
4947inline ::std::string* TensorBoundShape::mutable_name() {
4948 set_has_name();
4949 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4950 name_ = new ::std::string;
4951 }
4952 // @@protoc_insertion_point(field_mutable:caffe2.TensorBoundShape.name)
4953 return name_;
4954}
4955inline ::std::string* TensorBoundShape::release_name() {
4956 clear_has_name();
4957 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4958 return NULL;
4959 } else {
4960 ::std::string* temp = name_;
4961 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4962 return temp;
4963 }
4964}
4965inline void TensorBoundShape::set_allocated_name(::std::string* name) {
4966 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
4967 delete name_;
4968 }
4969 if (name) {
4970 set_has_name();
4971 name_ = name;
4972 } else {
4973 clear_has_name();
4974 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
4975 }
4976 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorBoundShape.name)
4977}
4978
4979// -------------------------------------------------------------------
4980
4981// TensorBoundShapes
4982
4983// repeated .caffe2.TensorBoundShape shapes = 1;
4984inline int TensorBoundShapes::shapes_size() const {
4985 return shapes_.size();
4986}
4987inline void TensorBoundShapes::clear_shapes() {
4988 shapes_.Clear();
4989}
4990inline const ::caffe2::TensorBoundShape& TensorBoundShapes::shapes(int index) const {
4991 // @@protoc_insertion_point(field_get:caffe2.TensorBoundShapes.shapes)
4992 return shapes_.Get(index);
4993}
4994inline ::caffe2::TensorBoundShape* TensorBoundShapes::mutable_shapes(int index) {
4995 // @@protoc_insertion_point(field_mutable:caffe2.TensorBoundShapes.shapes)
4996 return shapes_.Mutable(index);
4997}
4998inline ::caffe2::TensorBoundShape* TensorBoundShapes::add_shapes() {
4999 // @@protoc_insertion_point(field_add:caffe2.TensorBoundShapes.shapes)
5000 return shapes_.Add();
5001}
5002inline const ::google::protobuf::RepeatedPtrField< ::caffe2::TensorBoundShape >&
5003TensorBoundShapes::shapes() const {
5004 // @@protoc_insertion_point(field_list:caffe2.TensorBoundShapes.shapes)
5005 return shapes_;
5006}
5007inline ::google::protobuf::RepeatedPtrField< ::caffe2::TensorBoundShape >*
5008TensorBoundShapes::mutable_shapes() {
5009 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorBoundShapes.shapes)
5010 return &shapes_;
5011}
5012
5013// optional int64 max_batch_size = 2;
5014inline bool TensorBoundShapes::has_max_batch_size() const {
5015 return (_has_bits_[0] & 0x00000002u) != 0;
5016}
5017inline void TensorBoundShapes::set_has_max_batch_size() {
5018 _has_bits_[0] |= 0x00000002u;
5019}
5020inline void TensorBoundShapes::clear_has_max_batch_size() {
5021 _has_bits_[0] &= ~0x00000002u;
5022}
5023inline void TensorBoundShapes::clear_max_batch_size() {
5024 max_batch_size_ = GOOGLE_LONGLONG(0);
5025 clear_has_max_batch_size();
5026}
5027inline ::google::protobuf::int64 TensorBoundShapes::max_batch_size() const {
5028 // @@protoc_insertion_point(field_get:caffe2.TensorBoundShapes.max_batch_size)
5029 return max_batch_size_;
5030}
5031inline void TensorBoundShapes::set_max_batch_size(::google::protobuf::int64 value) {
5032 set_has_max_batch_size();
5033 max_batch_size_ = value;
5034 // @@protoc_insertion_point(field_set:caffe2.TensorBoundShapes.max_batch_size)
5035}
5036
5037// optional int64 max_feature_len = 3;
5038inline bool TensorBoundShapes::has_max_feature_len() const {
5039 return (_has_bits_[0] & 0x00000004u) != 0;
5040}
5041inline void TensorBoundShapes::set_has_max_feature_len() {
5042 _has_bits_[0] |= 0x00000004u;
5043}
5044inline void TensorBoundShapes::clear_has_max_feature_len() {
5045 _has_bits_[0] &= ~0x00000004u;
5046}
5047inline void TensorBoundShapes::clear_max_feature_len() {
5048 max_feature_len_ = GOOGLE_LONGLONG(0);
5049 clear_has_max_feature_len();
5050}
5051inline ::google::protobuf::int64 TensorBoundShapes::max_feature_len() const {
5052 // @@protoc_insertion_point(field_get:caffe2.TensorBoundShapes.max_feature_len)
5053 return max_feature_len_;
5054}
5055inline void TensorBoundShapes::set_max_feature_len(::google::protobuf::int64 value) {
5056 set_has_max_feature_len();
5057 max_feature_len_ = value;
5058 // @@protoc_insertion_point(field_set:caffe2.TensorBoundShapes.max_feature_len)
5059}
5060
5061// -------------------------------------------------------------------
5062
5063// AOTConfig
5064
5065// required int64 max_batch_size = 1;
5066inline bool AOTConfig::has_max_batch_size() const {
5067 return (_has_bits_[0] & 0x00000001u) != 0;
5068}
5069inline void AOTConfig::set_has_max_batch_size() {
5070 _has_bits_[0] |= 0x00000001u;
5071}
5072inline void AOTConfig::clear_has_max_batch_size() {
5073 _has_bits_[0] &= ~0x00000001u;
5074}
5075inline void AOTConfig::clear_max_batch_size() {
5076 max_batch_size_ = GOOGLE_LONGLONG(0);
5077 clear_has_max_batch_size();
5078}
5079inline ::google::protobuf::int64 AOTConfig::max_batch_size() const {
5080 // @@protoc_insertion_point(field_get:caffe2.AOTConfig.max_batch_size)
5081 return max_batch_size_;
5082}
5083inline void AOTConfig::set_max_batch_size(::google::protobuf::int64 value) {
5084 set_has_max_batch_size();
5085 max_batch_size_ = value;
5086 // @@protoc_insertion_point(field_set:caffe2.AOTConfig.max_batch_size)
5087}
5088
5089// required int64 max_seq_size = 2;
5090inline bool AOTConfig::has_max_seq_size() const {
5091 return (_has_bits_[0] & 0x00000002u) != 0;
5092}
5093inline void AOTConfig::set_has_max_seq_size() {
5094 _has_bits_[0] |= 0x00000002u;
5095}
5096inline void AOTConfig::clear_has_max_seq_size() {
5097 _has_bits_[0] &= ~0x00000002u;
5098}
5099inline void AOTConfig::clear_max_seq_size() {
5100 max_seq_size_ = GOOGLE_LONGLONG(0);
5101 clear_has_max_seq_size();
5102}
5103inline ::google::protobuf::int64 AOTConfig::max_seq_size() const {
5104 // @@protoc_insertion_point(field_get:caffe2.AOTConfig.max_seq_size)
5105 return max_seq_size_;
5106}
5107inline void AOTConfig::set_max_seq_size(::google::protobuf::int64 value) {
5108 set_has_max_seq_size();
5109 max_seq_size_ = value;
5110 // @@protoc_insertion_point(field_set:caffe2.AOTConfig.max_seq_size)
5111}
5112
5113// required bool in_batch_broadcast = 3;
5114inline bool AOTConfig::has_in_batch_broadcast() const {
5115 return (_has_bits_[0] & 0x00000004u) != 0;
5116}
5117inline void AOTConfig::set_has_in_batch_broadcast() {
5118 _has_bits_[0] |= 0x00000004u;
5119}
5120inline void AOTConfig::clear_has_in_batch_broadcast() {
5121 _has_bits_[0] &= ~0x00000004u;
5122}
5123inline void AOTConfig::clear_in_batch_broadcast() {
5124 in_batch_broadcast_ = false;
5125 clear_has_in_batch_broadcast();
5126}
5127inline bool AOTConfig::in_batch_broadcast() const {
5128 // @@protoc_insertion_point(field_get:caffe2.AOTConfig.in_batch_broadcast)
5129 return in_batch_broadcast_;
5130}
5131inline void AOTConfig::set_in_batch_broadcast(bool value) {
5132 set_has_in_batch_broadcast();
5133 in_batch_broadcast_ = value;
5134 // @@protoc_insertion_point(field_set:caffe2.AOTConfig.in_batch_broadcast)
5135}
5136
5137// optional string onnxifi_blacklist_ops = 4;
5138inline bool AOTConfig::has_onnxifi_blacklist_ops() const {
5139 return (_has_bits_[0] & 0x00000008u) != 0;
5140}
5141inline void AOTConfig::set_has_onnxifi_blacklist_ops() {
5142 _has_bits_[0] |= 0x00000008u;
5143}
5144inline void AOTConfig::clear_has_onnxifi_blacklist_ops() {
5145 _has_bits_[0] &= ~0x00000008u;
5146}
5147inline void AOTConfig::clear_onnxifi_blacklist_ops() {
5148 if (onnxifi_blacklist_ops_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5149 onnxifi_blacklist_ops_->clear();
5150 }
5151 clear_has_onnxifi_blacklist_ops();
5152}
5153inline const ::std::string& AOTConfig::onnxifi_blacklist_ops() const {
5154 // @@protoc_insertion_point(field_get:caffe2.AOTConfig.onnxifi_blacklist_ops)
5155 return *onnxifi_blacklist_ops_;
5156}
5157inline void AOTConfig::set_onnxifi_blacklist_ops(const ::std::string& value) {
5158 set_has_onnxifi_blacklist_ops();
5159 if (onnxifi_blacklist_ops_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5160 onnxifi_blacklist_ops_ = new ::std::string;
5161 }
5162 onnxifi_blacklist_ops_->assign(value);
5163 // @@protoc_insertion_point(field_set:caffe2.AOTConfig.onnxifi_blacklist_ops)
5164}
5165inline void AOTConfig::set_onnxifi_blacklist_ops(const char* value) {
5166 set_has_onnxifi_blacklist_ops();
5167 if (onnxifi_blacklist_ops_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5168 onnxifi_blacklist_ops_ = new ::std::string;
5169 }
5170 onnxifi_blacklist_ops_->assign(value);
5171 // @@protoc_insertion_point(field_set_char:caffe2.AOTConfig.onnxifi_blacklist_ops)
5172}
5173inline void AOTConfig::set_onnxifi_blacklist_ops(const char* value, size_t size) {
5174 set_has_onnxifi_blacklist_ops();
5175 if (onnxifi_blacklist_ops_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5176 onnxifi_blacklist_ops_ = new ::std::string;
5177 }
5178 onnxifi_blacklist_ops_->assign(reinterpret_cast<const char*>(value), size);
5179 // @@protoc_insertion_point(field_set_pointer:caffe2.AOTConfig.onnxifi_blacklist_ops)
5180}
5181inline ::std::string* AOTConfig::mutable_onnxifi_blacklist_ops() {
5182 set_has_onnxifi_blacklist_ops();
5183 if (onnxifi_blacklist_ops_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5184 onnxifi_blacklist_ops_ = new ::std::string;
5185 }
5186 // @@protoc_insertion_point(field_mutable:caffe2.AOTConfig.onnxifi_blacklist_ops)
5187 return onnxifi_blacklist_ops_;
5188}
5189inline ::std::string* AOTConfig::release_onnxifi_blacklist_ops() {
5190 clear_has_onnxifi_blacklist_ops();
5191 if (onnxifi_blacklist_ops_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5192 return NULL;
5193 } else {
5194 ::std::string* temp = onnxifi_blacklist_ops_;
5195 onnxifi_blacklist_ops_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5196 return temp;
5197 }
5198}
5199inline void AOTConfig::set_allocated_onnxifi_blacklist_ops(::std::string* onnxifi_blacklist_ops) {
5200 if (onnxifi_blacklist_ops_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5201 delete onnxifi_blacklist_ops_;
5202 }
5203 if (onnxifi_blacklist_ops) {
5204 set_has_onnxifi_blacklist_ops();
5205 onnxifi_blacklist_ops_ = onnxifi_blacklist_ops;
5206 } else {
5207 clear_has_onnxifi_blacklist_ops();
5208 onnxifi_blacklist_ops_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5209 }
5210 // @@protoc_insertion_point(field_set_allocated:caffe2.AOTConfig.onnxifi_blacklist_ops)
5211}
5212
5213// optional int32 onnxifi_min_ops = 5;
5214inline bool AOTConfig::has_onnxifi_min_ops() const {
5215 return (_has_bits_[0] & 0x00000010u) != 0;
5216}
5217inline void AOTConfig::set_has_onnxifi_min_ops() {
5218 _has_bits_[0] |= 0x00000010u;
5219}
5220inline void AOTConfig::clear_has_onnxifi_min_ops() {
5221 _has_bits_[0] &= ~0x00000010u;
5222}
5223inline void AOTConfig::clear_onnxifi_min_ops() {
5224 onnxifi_min_ops_ = 0;
5225 clear_has_onnxifi_min_ops();
5226}
5227inline ::google::protobuf::int32 AOTConfig::onnxifi_min_ops() const {
5228 // @@protoc_insertion_point(field_get:caffe2.AOTConfig.onnxifi_min_ops)
5229 return onnxifi_min_ops_;
5230}
5231inline void AOTConfig::set_onnxifi_min_ops(::google::protobuf::int32 value) {
5232 set_has_onnxifi_min_ops();
5233 onnxifi_min_ops_ = value;
5234 // @@protoc_insertion_point(field_set:caffe2.AOTConfig.onnxifi_min_ops)
5235}
5236
5237// -------------------------------------------------------------------
5238
5239// Argument
5240
5241// optional string name = 1;
5242inline bool Argument::has_name() const {
5243 return (_has_bits_[0] & 0x00000001u) != 0;
5244}
5245inline void Argument::set_has_name() {
5246 _has_bits_[0] |= 0x00000001u;
5247}
5248inline void Argument::clear_has_name() {
5249 _has_bits_[0] &= ~0x00000001u;
5250}
5251inline void Argument::clear_name() {
5252 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5253 name_->clear();
5254 }
5255 clear_has_name();
5256}
5257inline const ::std::string& Argument::name() const {
5258 // @@protoc_insertion_point(field_get:caffe2.Argument.name)
5259 return *name_;
5260}
5261inline void Argument::set_name(const ::std::string& value) {
5262 set_has_name();
5263 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5264 name_ = new ::std::string;
5265 }
5266 name_->assign(value);
5267 // @@protoc_insertion_point(field_set:caffe2.Argument.name)
5268}
5269inline void Argument::set_name(const char* value) {
5270 set_has_name();
5271 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5272 name_ = new ::std::string;
5273 }
5274 name_->assign(value);
5275 // @@protoc_insertion_point(field_set_char:caffe2.Argument.name)
5276}
5277inline void Argument::set_name(const char* value, size_t size) {
5278 set_has_name();
5279 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5280 name_ = new ::std::string;
5281 }
5282 name_->assign(reinterpret_cast<const char*>(value), size);
5283 // @@protoc_insertion_point(field_set_pointer:caffe2.Argument.name)
5284}
5285inline ::std::string* Argument::mutable_name() {
5286 set_has_name();
5287 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5288 name_ = new ::std::string;
5289 }
5290 // @@protoc_insertion_point(field_mutable:caffe2.Argument.name)
5291 return name_;
5292}
5293inline ::std::string* Argument::release_name() {
5294 clear_has_name();
5295 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5296 return NULL;
5297 } else {
5298 ::std::string* temp = name_;
5299 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5300 return temp;
5301 }
5302}
5303inline void Argument::set_allocated_name(::std::string* name) {
5304 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5305 delete name_;
5306 }
5307 if (name) {
5308 set_has_name();
5309 name_ = name;
5310 } else {
5311 clear_has_name();
5312 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5313 }
5314 // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.name)
5315}
5316
5317// optional float f = 2;
5318inline bool Argument::has_f() const {
5319 return (_has_bits_[0] & 0x00000002u) != 0;
5320}
5321inline void Argument::set_has_f() {
5322 _has_bits_[0] |= 0x00000002u;
5323}
5324inline void Argument::clear_has_f() {
5325 _has_bits_[0] &= ~0x00000002u;
5326}
5327inline void Argument::clear_f() {
5328 f_ = 0;
5329 clear_has_f();
5330}
5331inline float Argument::f() const {
5332 // @@protoc_insertion_point(field_get:caffe2.Argument.f)
5333 return f_;
5334}
5335inline void Argument::set_f(float value) {
5336 set_has_f();
5337 f_ = value;
5338 // @@protoc_insertion_point(field_set:caffe2.Argument.f)
5339}
5340
5341// optional int64 i = 3;
5342inline bool Argument::has_i() const {
5343 return (_has_bits_[0] & 0x00000004u) != 0;
5344}
5345inline void Argument::set_has_i() {
5346 _has_bits_[0] |= 0x00000004u;
5347}
5348inline void Argument::clear_has_i() {
5349 _has_bits_[0] &= ~0x00000004u;
5350}
5351inline void Argument::clear_i() {
5352 i_ = GOOGLE_LONGLONG(0);
5353 clear_has_i();
5354}
5355inline ::google::protobuf::int64 Argument::i() const {
5356 // @@protoc_insertion_point(field_get:caffe2.Argument.i)
5357 return i_;
5358}
5359inline void Argument::set_i(::google::protobuf::int64 value) {
5360 set_has_i();
5361 i_ = value;
5362 // @@protoc_insertion_point(field_set:caffe2.Argument.i)
5363}
5364
5365// optional bytes s = 4;
5366inline bool Argument::has_s() const {
5367 return (_has_bits_[0] & 0x00000008u) != 0;
5368}
5369inline void Argument::set_has_s() {
5370 _has_bits_[0] |= 0x00000008u;
5371}
5372inline void Argument::clear_has_s() {
5373 _has_bits_[0] &= ~0x00000008u;
5374}
5375inline void Argument::clear_s() {
5376 if (s_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5377 s_->clear();
5378 }
5379 clear_has_s();
5380}
5381inline const ::std::string& Argument::s() const {
5382 // @@protoc_insertion_point(field_get:caffe2.Argument.s)
5383 return *s_;
5384}
5385inline void Argument::set_s(const ::std::string& value) {
5386 set_has_s();
5387 if (s_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5388 s_ = new ::std::string;
5389 }
5390 s_->assign(value);
5391 // @@protoc_insertion_point(field_set:caffe2.Argument.s)
5392}
5393inline void Argument::set_s(const char* value) {
5394 set_has_s();
5395 if (s_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5396 s_ = new ::std::string;
5397 }
5398 s_->assign(value);
5399 // @@protoc_insertion_point(field_set_char:caffe2.Argument.s)
5400}
5401inline void Argument::set_s(const void* value, size_t size) {
5402 set_has_s();
5403 if (s_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5404 s_ = new ::std::string;
5405 }
5406 s_->assign(reinterpret_cast<const char*>(value), size);
5407 // @@protoc_insertion_point(field_set_pointer:caffe2.Argument.s)
5408}
5409inline ::std::string* Argument::mutable_s() {
5410 set_has_s();
5411 if (s_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5412 s_ = new ::std::string;
5413 }
5414 // @@protoc_insertion_point(field_mutable:caffe2.Argument.s)
5415 return s_;
5416}
5417inline ::std::string* Argument::release_s() {
5418 clear_has_s();
5419 if (s_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5420 return NULL;
5421 } else {
5422 ::std::string* temp = s_;
5423 s_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5424 return temp;
5425 }
5426}
5427inline void Argument::set_allocated_s(::std::string* s) {
5428 if (s_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5429 delete s_;
5430 }
5431 if (s) {
5432 set_has_s();
5433 s_ = s;
5434 } else {
5435 clear_has_s();
5436 s_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5437 }
5438 // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.s)
5439}
5440
5441// optional .caffe2.TensorProto t = 10;
5442inline bool Argument::has_t() const {
5443 return (_has_bits_[0] & 0x00000010u) != 0;
5444}
5445inline void Argument::set_has_t() {
5446 _has_bits_[0] |= 0x00000010u;
5447}
5448inline void Argument::clear_has_t() {
5449 _has_bits_[0] &= ~0x00000010u;
5450}
5451inline void Argument::clear_t() {
5452 if (t_ != NULL) t_->::caffe2::TensorProto::Clear();
5453 clear_has_t();
5454}
5455inline const ::caffe2::TensorProto& Argument::t() const {
5456 // @@protoc_insertion_point(field_get:caffe2.Argument.t)
5457 return t_ != NULL ? *t_ : *default_instance_->t_;
5458}
5459inline ::caffe2::TensorProto* Argument::mutable_t() {
5460 set_has_t();
5461 if (t_ == NULL) t_ = new ::caffe2::TensorProto;
5462 // @@protoc_insertion_point(field_mutable:caffe2.Argument.t)
5463 return t_;
5464}
5465inline ::caffe2::TensorProto* Argument::release_t() {
5466 clear_has_t();
5467 ::caffe2::TensorProto* temp = t_;
5468 t_ = NULL;
5469 return temp;
5470}
5471inline void Argument::set_allocated_t(::caffe2::TensorProto* t) {
5472 delete t_;
5473 t_ = t;
5474 if (t) {
5475 set_has_t();
5476 } else {
5477 clear_has_t();
5478 }
5479 // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.t)
5480}
5481
5482// optional .caffe2.NetDef n = 8;
5483inline bool Argument::has_n() const {
5484 return (_has_bits_[0] & 0x00000020u) != 0;
5485}
5486inline void Argument::set_has_n() {
5487 _has_bits_[0] |= 0x00000020u;
5488}
5489inline void Argument::clear_has_n() {
5490 _has_bits_[0] &= ~0x00000020u;
5491}
5492inline void Argument::clear_n() {
5493 if (n_ != NULL) n_->::caffe2::NetDef::Clear();
5494 clear_has_n();
5495}
5496inline const ::caffe2::NetDef& Argument::n() const {
5497 // @@protoc_insertion_point(field_get:caffe2.Argument.n)
5498 return n_ != NULL ? *n_ : *default_instance_->n_;
5499}
5500inline ::caffe2::NetDef* Argument::mutable_n() {
5501 set_has_n();
5502 if (n_ == NULL) n_ = new ::caffe2::NetDef;
5503 // @@protoc_insertion_point(field_mutable:caffe2.Argument.n)
5504 return n_;
5505}
5506inline ::caffe2::NetDef* Argument::release_n() {
5507 clear_has_n();
5508 ::caffe2::NetDef* temp = n_;
5509 n_ = NULL;
5510 return temp;
5511}
5512inline void Argument::set_allocated_n(::caffe2::NetDef* n) {
5513 delete n_;
5514 n_ = n;
5515 if (n) {
5516 set_has_n();
5517 } else {
5518 clear_has_n();
5519 }
5520 // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.n)
5521}
5522
5523// repeated float floats = 5;
5524inline int Argument::floats_size() const {
5525 return floats_.size();
5526}
5527inline void Argument::clear_floats() {
5528 floats_.Clear();
5529}
5530inline float Argument::floats(int index) const {
5531 // @@protoc_insertion_point(field_get:caffe2.Argument.floats)
5532 return floats_.Get(index);
5533}
5534inline void Argument::set_floats(int index, float value) {
5535 floats_.Set(index, value);
5536 // @@protoc_insertion_point(field_set:caffe2.Argument.floats)
5537}
5538inline void Argument::add_floats(float value) {
5539 floats_.Add(value);
5540 // @@protoc_insertion_point(field_add:caffe2.Argument.floats)
5541}
5542inline const ::google::protobuf::RepeatedField< float >&
5543Argument::floats() const {
5544 // @@protoc_insertion_point(field_list:caffe2.Argument.floats)
5545 return floats_;
5546}
5547inline ::google::protobuf::RepeatedField< float >*
5548Argument::mutable_floats() {
5549 // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.floats)
5550 return &floats_;
5551}
5552
5553// repeated int64 ints = 6;
5554inline int Argument::ints_size() const {
5555 return ints_.size();
5556}
5557inline void Argument::clear_ints() {
5558 ints_.Clear();
5559}
5560inline ::google::protobuf::int64 Argument::ints(int index) const {
5561 // @@protoc_insertion_point(field_get:caffe2.Argument.ints)
5562 return ints_.Get(index);
5563}
5564inline void Argument::set_ints(int index, ::google::protobuf::int64 value) {
5565 ints_.Set(index, value);
5566 // @@protoc_insertion_point(field_set:caffe2.Argument.ints)
5567}
5568inline void Argument::add_ints(::google::protobuf::int64 value) {
5569 ints_.Add(value);
5570 // @@protoc_insertion_point(field_add:caffe2.Argument.ints)
5571}
5572inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
5573Argument::ints() const {
5574 // @@protoc_insertion_point(field_list:caffe2.Argument.ints)
5575 return ints_;
5576}
5577inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
5578Argument::mutable_ints() {
5579 // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.ints)
5580 return &ints_;
5581}
5582
5583// repeated bytes strings = 7;
5584inline int Argument::strings_size() const {
5585 return strings_.size();
5586}
5587inline void Argument::clear_strings() {
5588 strings_.Clear();
5589}
5590inline const ::std::string& Argument::strings(int index) const {
5591 // @@protoc_insertion_point(field_get:caffe2.Argument.strings)
5592 return strings_.Get(index);
5593}
5594inline ::std::string* Argument::mutable_strings(int index) {
5595 // @@protoc_insertion_point(field_mutable:caffe2.Argument.strings)
5596 return strings_.Mutable(index);
5597}
5598inline void Argument::set_strings(int index, const ::std::string& value) {
5599 // @@protoc_insertion_point(field_set:caffe2.Argument.strings)
5600 strings_.Mutable(index)->assign(value);
5601}
5602inline void Argument::set_strings(int index, const char* value) {
5603 strings_.Mutable(index)->assign(value);
5604 // @@protoc_insertion_point(field_set_char:caffe2.Argument.strings)
5605}
5606inline void Argument::set_strings(int index, const void* value, size_t size) {
5607 strings_.Mutable(index)->assign(
5608 reinterpret_cast<const char*>(value), size);
5609 // @@protoc_insertion_point(field_set_pointer:caffe2.Argument.strings)
5610}
5611inline ::std::string* Argument::add_strings() {
5612 return strings_.Add();
5613}
5614inline void Argument::add_strings(const ::std::string& value) {
5615 strings_.Add()->assign(value);
5616 // @@protoc_insertion_point(field_add:caffe2.Argument.strings)
5617}
5618inline void Argument::add_strings(const char* value) {
5619 strings_.Add()->assign(value);
5620 // @@protoc_insertion_point(field_add_char:caffe2.Argument.strings)
5621}
5622inline void Argument::add_strings(const void* value, size_t size) {
5623 strings_.Add()->assign(reinterpret_cast<const char*>(value), size);
5624 // @@protoc_insertion_point(field_add_pointer:caffe2.Argument.strings)
5625}
5626inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
5627Argument::strings() const {
5628 // @@protoc_insertion_point(field_list:caffe2.Argument.strings)
5629 return strings_;
5630}
5631inline ::google::protobuf::RepeatedPtrField< ::std::string>*
5632Argument::mutable_strings() {
5633 // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.strings)
5634 return &strings_;
5635}
5636
5637// repeated .caffe2.TensorProto tensors = 11;
5638inline int Argument::tensors_size() const {
5639 return tensors_.size();
5640}
5641inline void Argument::clear_tensors() {
5642 tensors_.Clear();
5643}
5644inline const ::caffe2::TensorProto& Argument::tensors(int index) const {
5645 // @@protoc_insertion_point(field_get:caffe2.Argument.tensors)
5646 return tensors_.Get(index);
5647}
5648inline ::caffe2::TensorProto* Argument::mutable_tensors(int index) {
5649 // @@protoc_insertion_point(field_mutable:caffe2.Argument.tensors)
5650 return tensors_.Mutable(index);
5651}
5652inline ::caffe2::TensorProto* Argument::add_tensors() {
5653 // @@protoc_insertion_point(field_add:caffe2.Argument.tensors)
5654 return tensors_.Add();
5655}
5656inline const ::google::protobuf::RepeatedPtrField< ::caffe2::TensorProto >&
5657Argument::tensors() const {
5658 // @@protoc_insertion_point(field_list:caffe2.Argument.tensors)
5659 return tensors_;
5660}
5661inline ::google::protobuf::RepeatedPtrField< ::caffe2::TensorProto >*
5662Argument::mutable_tensors() {
5663 // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.tensors)
5664 return &tensors_;
5665}
5666
5667// repeated .caffe2.NetDef nets = 9;
5668inline int Argument::nets_size() const {
5669 return nets_.size();
5670}
5671inline void Argument::clear_nets() {
5672 nets_.Clear();
5673}
5674inline const ::caffe2::NetDef& Argument::nets(int index) const {
5675 // @@protoc_insertion_point(field_get:caffe2.Argument.nets)
5676 return nets_.Get(index);
5677}
5678inline ::caffe2::NetDef* Argument::mutable_nets(int index) {
5679 // @@protoc_insertion_point(field_mutable:caffe2.Argument.nets)
5680 return nets_.Mutable(index);
5681}
5682inline ::caffe2::NetDef* Argument::add_nets() {
5683 // @@protoc_insertion_point(field_add:caffe2.Argument.nets)
5684 return nets_.Add();
5685}
5686inline const ::google::protobuf::RepeatedPtrField< ::caffe2::NetDef >&
5687Argument::nets() const {
5688 // @@protoc_insertion_point(field_list:caffe2.Argument.nets)
5689 return nets_;
5690}
5691inline ::google::protobuf::RepeatedPtrField< ::caffe2::NetDef >*
5692Argument::mutable_nets() {
5693 // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.nets)
5694 return &nets_;
5695}
5696
5697// repeated .caffe2.QTensorProto qtensors = 12;
5698inline int Argument::qtensors_size() const {
5699 return qtensors_.size();
5700}
5701inline void Argument::clear_qtensors() {
5702 qtensors_.Clear();
5703}
5704inline const ::caffe2::QTensorProto& Argument::qtensors(int index) const {
5705 // @@protoc_insertion_point(field_get:caffe2.Argument.qtensors)
5706 return qtensors_.Get(index);
5707}
5708inline ::caffe2::QTensorProto* Argument::mutable_qtensors(int index) {
5709 // @@protoc_insertion_point(field_mutable:caffe2.Argument.qtensors)
5710 return qtensors_.Mutable(index);
5711}
5712inline ::caffe2::QTensorProto* Argument::add_qtensors() {
5713 // @@protoc_insertion_point(field_add:caffe2.Argument.qtensors)
5714 return qtensors_.Add();
5715}
5716inline const ::google::protobuf::RepeatedPtrField< ::caffe2::QTensorProto >&
5717Argument::qtensors() const {
5718 // @@protoc_insertion_point(field_list:caffe2.Argument.qtensors)
5719 return qtensors_;
5720}
5721inline ::google::protobuf::RepeatedPtrField< ::caffe2::QTensorProto >*
5722Argument::mutable_qtensors() {
5723 // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.qtensors)
5724 return &qtensors_;
5725}
5726
5727// -------------------------------------------------------------------
5728
5729// DeviceOption
5730
5731// optional int32 device_type = 1 [default = 0];
5732inline bool DeviceOption::has_device_type() const {
5733 return (_has_bits_[0] & 0x00000001u) != 0;
5734}
5735inline void DeviceOption::set_has_device_type() {
5736 _has_bits_[0] |= 0x00000001u;
5737}
5738inline void DeviceOption::clear_has_device_type() {
5739 _has_bits_[0] &= ~0x00000001u;
5740}
5741inline void DeviceOption::clear_device_type() {
5742 device_type_ = 0;
5743 clear_has_device_type();
5744}
5745inline ::google::protobuf::int32 DeviceOption::device_type() const {
5746 // @@protoc_insertion_point(field_get:caffe2.DeviceOption.device_type)
5747 return device_type_;
5748}
5749inline void DeviceOption::set_device_type(::google::protobuf::int32 value) {
5750 set_has_device_type();
5751 device_type_ = value;
5752 // @@protoc_insertion_point(field_set:caffe2.DeviceOption.device_type)
5753}
5754
5755// optional int32 device_id = 2;
5756inline bool DeviceOption::has_device_id() const {
5757 return (_has_bits_[0] & 0x00000002u) != 0;
5758}
5759inline void DeviceOption::set_has_device_id() {
5760 _has_bits_[0] |= 0x00000002u;
5761}
5762inline void DeviceOption::clear_has_device_id() {
5763 _has_bits_[0] &= ~0x00000002u;
5764}
5765inline void DeviceOption::clear_device_id() {
5766 device_id_ = 0;
5767 clear_has_device_id();
5768}
5769inline ::google::protobuf::int32 DeviceOption::device_id() const {
5770 // @@protoc_insertion_point(field_get:caffe2.DeviceOption.device_id)
5771 return device_id_;
5772}
5773inline void DeviceOption::set_device_id(::google::protobuf::int32 value) {
5774 set_has_device_id();
5775 device_id_ = value;
5776 // @@protoc_insertion_point(field_set:caffe2.DeviceOption.device_id)
5777}
5778
5779// optional uint32 random_seed = 3;
5780inline bool DeviceOption::has_random_seed() const {
5781 return (_has_bits_[0] & 0x00000004u) != 0;
5782}
5783inline void DeviceOption::set_has_random_seed() {
5784 _has_bits_[0] |= 0x00000004u;
5785}
5786inline void DeviceOption::clear_has_random_seed() {
5787 _has_bits_[0] &= ~0x00000004u;
5788}
5789inline void DeviceOption::clear_random_seed() {
5790 random_seed_ = 0u;
5791 clear_has_random_seed();
5792}
5793inline ::google::protobuf::uint32 DeviceOption::random_seed() const {
5794 // @@protoc_insertion_point(field_get:caffe2.DeviceOption.random_seed)
5795 return random_seed_;
5796}
5797inline void DeviceOption::set_random_seed(::google::protobuf::uint32 value) {
5798 set_has_random_seed();
5799 random_seed_ = value;
5800 // @@protoc_insertion_point(field_set:caffe2.DeviceOption.random_seed)
5801}
5802
5803// optional string node_name = 4;
5804inline bool DeviceOption::has_node_name() const {
5805 return (_has_bits_[0] & 0x00000008u) != 0;
5806}
5807inline void DeviceOption::set_has_node_name() {
5808 _has_bits_[0] |= 0x00000008u;
5809}
5810inline void DeviceOption::clear_has_node_name() {
5811 _has_bits_[0] &= ~0x00000008u;
5812}
5813inline void DeviceOption::clear_node_name() {
5814 if (node_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5815 node_name_->clear();
5816 }
5817 clear_has_node_name();
5818}
5819inline const ::std::string& DeviceOption::node_name() const {
5820 // @@protoc_insertion_point(field_get:caffe2.DeviceOption.node_name)
5821 return *node_name_;
5822}
5823inline void DeviceOption::set_node_name(const ::std::string& value) {
5824 set_has_node_name();
5825 if (node_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5826 node_name_ = new ::std::string;
5827 }
5828 node_name_->assign(value);
5829 // @@protoc_insertion_point(field_set:caffe2.DeviceOption.node_name)
5830}
5831inline void DeviceOption::set_node_name(const char* value) {
5832 set_has_node_name();
5833 if (node_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5834 node_name_ = new ::std::string;
5835 }
5836 node_name_->assign(value);
5837 // @@protoc_insertion_point(field_set_char:caffe2.DeviceOption.node_name)
5838}
5839inline void DeviceOption::set_node_name(const char* value, size_t size) {
5840 set_has_node_name();
5841 if (node_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5842 node_name_ = new ::std::string;
5843 }
5844 node_name_->assign(reinterpret_cast<const char*>(value), size);
5845 // @@protoc_insertion_point(field_set_pointer:caffe2.DeviceOption.node_name)
5846}
5847inline ::std::string* DeviceOption::mutable_node_name() {
5848 set_has_node_name();
5849 if (node_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5850 node_name_ = new ::std::string;
5851 }
5852 // @@protoc_insertion_point(field_mutable:caffe2.DeviceOption.node_name)
5853 return node_name_;
5854}
5855inline ::std::string* DeviceOption::release_node_name() {
5856 clear_has_node_name();
5857 if (node_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5858 return NULL;
5859 } else {
5860 ::std::string* temp = node_name_;
5861 node_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5862 return temp;
5863 }
5864}
5865inline void DeviceOption::set_allocated_node_name(::std::string* node_name) {
5866 if (node_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
5867 delete node_name_;
5868 }
5869 if (node_name) {
5870 set_has_node_name();
5871 node_name_ = node_name;
5872 } else {
5873 clear_has_node_name();
5874 node_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
5875 }
5876 // @@protoc_insertion_point(field_set_allocated:caffe2.DeviceOption.node_name)
5877}
5878
5879// optional int32 numa_node_id = 5;
5880inline bool DeviceOption::has_numa_node_id() const {
5881 return (_has_bits_[0] & 0x00000010u) != 0;
5882}
5883inline void DeviceOption::set_has_numa_node_id() {
5884 _has_bits_[0] |= 0x00000010u;
5885}
5886inline void DeviceOption::clear_has_numa_node_id() {
5887 _has_bits_[0] &= ~0x00000010u;
5888}
5889inline void DeviceOption::clear_numa_node_id() {
5890 numa_node_id_ = 0;
5891 clear_has_numa_node_id();
5892}
5893inline ::google::protobuf::int32 DeviceOption::numa_node_id() const {
5894 // @@protoc_insertion_point(field_get:caffe2.DeviceOption.numa_node_id)
5895 return numa_node_id_;
5896}
5897inline void DeviceOption::set_numa_node_id(::google::protobuf::int32 value) {
5898 set_has_numa_node_id();
5899 numa_node_id_ = value;
5900 // @@protoc_insertion_point(field_set:caffe2.DeviceOption.numa_node_id)
5901}
5902
5903// repeated string extra_info = 6;
5904inline int DeviceOption::extra_info_size() const {
5905 return extra_info_.size();
5906}
5907inline void DeviceOption::clear_extra_info() {
5908 extra_info_.Clear();
5909}
5910inline const ::std::string& DeviceOption::extra_info(int index) const {
5911 // @@protoc_insertion_point(field_get:caffe2.DeviceOption.extra_info)
5912 return extra_info_.Get(index);
5913}
5914inline ::std::string* DeviceOption::mutable_extra_info(int index) {
5915 // @@protoc_insertion_point(field_mutable:caffe2.DeviceOption.extra_info)
5916 return extra_info_.Mutable(index);
5917}
5918inline void DeviceOption::set_extra_info(int index, const ::std::string& value) {
5919 // @@protoc_insertion_point(field_set:caffe2.DeviceOption.extra_info)
5920 extra_info_.Mutable(index)->assign(value);
5921}
5922inline void DeviceOption::set_extra_info(int index, const char* value) {
5923 extra_info_.Mutable(index)->assign(value);
5924 // @@protoc_insertion_point(field_set_char:caffe2.DeviceOption.extra_info)
5925}
5926inline void DeviceOption::set_extra_info(int index, const char* value, size_t size) {
5927 extra_info_.Mutable(index)->assign(
5928 reinterpret_cast<const char*>(value), size);
5929 // @@protoc_insertion_point(field_set_pointer:caffe2.DeviceOption.extra_info)
5930}
5931inline ::std::string* DeviceOption::add_extra_info() {
5932 return extra_info_.Add();
5933}
5934inline void DeviceOption::add_extra_info(const ::std::string& value) {
5935 extra_info_.Add()->assign(value);
5936 // @@protoc_insertion_point(field_add:caffe2.DeviceOption.extra_info)
5937}
5938inline void DeviceOption::add_extra_info(const char* value) {
5939 extra_info_.Add()->assign(value);
5940 // @@protoc_insertion_point(field_add_char:caffe2.DeviceOption.extra_info)
5941}
5942inline void DeviceOption::add_extra_info(const char* value, size_t size) {
5943 extra_info_.Add()->assign(reinterpret_cast<const char*>(value), size);
5944 // @@protoc_insertion_point(field_add_pointer:caffe2.DeviceOption.extra_info)
5945}
5946inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
5947DeviceOption::extra_info() const {
5948 // @@protoc_insertion_point(field_list:caffe2.DeviceOption.extra_info)
5949 return extra_info_;
5950}
5951inline ::google::protobuf::RepeatedPtrField< ::std::string>*
5952DeviceOption::mutable_extra_info() {
5953 // @@protoc_insertion_point(field_mutable_list:caffe2.DeviceOption.extra_info)
5954 return &extra_info_;
5955}
5956
5957// -------------------------------------------------------------------
5958
5959// OperatorDef
5960
5961// repeated string input = 1;
5962inline int OperatorDef::input_size() const {
5963 return input_.size();
5964}
5965inline void OperatorDef::clear_input() {
5966 input_.Clear();
5967}
5968inline const ::std::string& OperatorDef::input(int index) const {
5969 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.input)
5970 return input_.Get(index);
5971}
5972inline ::std::string* OperatorDef::mutable_input(int index) {
5973 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.input)
5974 return input_.Mutable(index);
5975}
5976inline void OperatorDef::set_input(int index, const ::std::string& value) {
5977 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.input)
5978 input_.Mutable(index)->assign(value);
5979}
5980inline void OperatorDef::set_input(int index, const char* value) {
5981 input_.Mutable(index)->assign(value);
5982 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.input)
5983}
5984inline void OperatorDef::set_input(int index, const char* value, size_t size) {
5985 input_.Mutable(index)->assign(
5986 reinterpret_cast<const char*>(value), size);
5987 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.input)
5988}
5989inline ::std::string* OperatorDef::add_input() {
5990 return input_.Add();
5991}
5992inline void OperatorDef::add_input(const ::std::string& value) {
5993 input_.Add()->assign(value);
5994 // @@protoc_insertion_point(field_add:caffe2.OperatorDef.input)
5995}
5996inline void OperatorDef::add_input(const char* value) {
5997 input_.Add()->assign(value);
5998 // @@protoc_insertion_point(field_add_char:caffe2.OperatorDef.input)
5999}
6000inline void OperatorDef::add_input(const char* value, size_t size) {
6001 input_.Add()->assign(reinterpret_cast<const char*>(value), size);
6002 // @@protoc_insertion_point(field_add_pointer:caffe2.OperatorDef.input)
6003}
6004inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
6005OperatorDef::input() const {
6006 // @@protoc_insertion_point(field_list:caffe2.OperatorDef.input)
6007 return input_;
6008}
6009inline ::google::protobuf::RepeatedPtrField< ::std::string>*
6010OperatorDef::mutable_input() {
6011 // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.input)
6012 return &input_;
6013}
6014
6015// repeated string output = 2;
6016inline int OperatorDef::output_size() const {
6017 return output_.size();
6018}
6019inline void OperatorDef::clear_output() {
6020 output_.Clear();
6021}
6022inline const ::std::string& OperatorDef::output(int index) const {
6023 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.output)
6024 return output_.Get(index);
6025}
6026inline ::std::string* OperatorDef::mutable_output(int index) {
6027 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.output)
6028 return output_.Mutable(index);
6029}
6030inline void OperatorDef::set_output(int index, const ::std::string& value) {
6031 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.output)
6032 output_.Mutable(index)->assign(value);
6033}
6034inline void OperatorDef::set_output(int index, const char* value) {
6035 output_.Mutable(index)->assign(value);
6036 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.output)
6037}
6038inline void OperatorDef::set_output(int index, const char* value, size_t size) {
6039 output_.Mutable(index)->assign(
6040 reinterpret_cast<const char*>(value), size);
6041 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.output)
6042}
6043inline ::std::string* OperatorDef::add_output() {
6044 return output_.Add();
6045}
6046inline void OperatorDef::add_output(const ::std::string& value) {
6047 output_.Add()->assign(value);
6048 // @@protoc_insertion_point(field_add:caffe2.OperatorDef.output)
6049}
6050inline void OperatorDef::add_output(const char* value) {
6051 output_.Add()->assign(value);
6052 // @@protoc_insertion_point(field_add_char:caffe2.OperatorDef.output)
6053}
6054inline void OperatorDef::add_output(const char* value, size_t size) {
6055 output_.Add()->assign(reinterpret_cast<const char*>(value), size);
6056 // @@protoc_insertion_point(field_add_pointer:caffe2.OperatorDef.output)
6057}
6058inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
6059OperatorDef::output() const {
6060 // @@protoc_insertion_point(field_list:caffe2.OperatorDef.output)
6061 return output_;
6062}
6063inline ::google::protobuf::RepeatedPtrField< ::std::string>*
6064OperatorDef::mutable_output() {
6065 // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.output)
6066 return &output_;
6067}
6068
6069// optional string name = 3;
6070inline bool OperatorDef::has_name() const {
6071 return (_has_bits_[0] & 0x00000004u) != 0;
6072}
6073inline void OperatorDef::set_has_name() {
6074 _has_bits_[0] |= 0x00000004u;
6075}
6076inline void OperatorDef::clear_has_name() {
6077 _has_bits_[0] &= ~0x00000004u;
6078}
6079inline void OperatorDef::clear_name() {
6080 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6081 name_->clear();
6082 }
6083 clear_has_name();
6084}
6085inline const ::std::string& OperatorDef::name() const {
6086 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.name)
6087 return *name_;
6088}
6089inline void OperatorDef::set_name(const ::std::string& value) {
6090 set_has_name();
6091 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6092 name_ = new ::std::string;
6093 }
6094 name_->assign(value);
6095 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.name)
6096}
6097inline void OperatorDef::set_name(const char* value) {
6098 set_has_name();
6099 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6100 name_ = new ::std::string;
6101 }
6102 name_->assign(value);
6103 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.name)
6104}
6105inline void OperatorDef::set_name(const char* value, size_t size) {
6106 set_has_name();
6107 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6108 name_ = new ::std::string;
6109 }
6110 name_->assign(reinterpret_cast<const char*>(value), size);
6111 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.name)
6112}
6113inline ::std::string* OperatorDef::mutable_name() {
6114 set_has_name();
6115 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6116 name_ = new ::std::string;
6117 }
6118 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.name)
6119 return name_;
6120}
6121inline ::std::string* OperatorDef::release_name() {
6122 clear_has_name();
6123 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6124 return NULL;
6125 } else {
6126 ::std::string* temp = name_;
6127 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6128 return temp;
6129 }
6130}
6131inline void OperatorDef::set_allocated_name(::std::string* name) {
6132 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6133 delete name_;
6134 }
6135 if (name) {
6136 set_has_name();
6137 name_ = name;
6138 } else {
6139 clear_has_name();
6140 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6141 }
6142 // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.name)
6143}
6144
6145// optional string type = 4;
6146inline bool OperatorDef::has_type() const {
6147 return (_has_bits_[0] & 0x00000008u) != 0;
6148}
6149inline void OperatorDef::set_has_type() {
6150 _has_bits_[0] |= 0x00000008u;
6151}
6152inline void OperatorDef::clear_has_type() {
6153 _has_bits_[0] &= ~0x00000008u;
6154}
6155inline void OperatorDef::clear_type() {
6156 if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6157 type_->clear();
6158 }
6159 clear_has_type();
6160}
6161inline const ::std::string& OperatorDef::type() const {
6162 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.type)
6163 return *type_;
6164}
6165inline void OperatorDef::set_type(const ::std::string& value) {
6166 set_has_type();
6167 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6168 type_ = new ::std::string;
6169 }
6170 type_->assign(value);
6171 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.type)
6172}
6173inline void OperatorDef::set_type(const char* value) {
6174 set_has_type();
6175 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6176 type_ = new ::std::string;
6177 }
6178 type_->assign(value);
6179 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.type)
6180}
6181inline void OperatorDef::set_type(const char* value, size_t size) {
6182 set_has_type();
6183 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6184 type_ = new ::std::string;
6185 }
6186 type_->assign(reinterpret_cast<const char*>(value), size);
6187 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.type)
6188}
6189inline ::std::string* OperatorDef::mutable_type() {
6190 set_has_type();
6191 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6192 type_ = new ::std::string;
6193 }
6194 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.type)
6195 return type_;
6196}
6197inline ::std::string* OperatorDef::release_type() {
6198 clear_has_type();
6199 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6200 return NULL;
6201 } else {
6202 ::std::string* temp = type_;
6203 type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6204 return temp;
6205 }
6206}
6207inline void OperatorDef::set_allocated_type(::std::string* type) {
6208 if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6209 delete type_;
6210 }
6211 if (type) {
6212 set_has_type();
6213 type_ = type;
6214 } else {
6215 clear_has_type();
6216 type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6217 }
6218 // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.type)
6219}
6220
6221// repeated .caffe2.Argument arg = 5;
6222inline int OperatorDef::arg_size() const {
6223 return arg_.size();
6224}
6225inline void OperatorDef::clear_arg() {
6226 arg_.Clear();
6227}
6228inline const ::caffe2::Argument& OperatorDef::arg(int index) const {
6229 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.arg)
6230 return arg_.Get(index);
6231}
6232inline ::caffe2::Argument* OperatorDef::mutable_arg(int index) {
6233 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.arg)
6234 return arg_.Mutable(index);
6235}
6236inline ::caffe2::Argument* OperatorDef::add_arg() {
6237 // @@protoc_insertion_point(field_add:caffe2.OperatorDef.arg)
6238 return arg_.Add();
6239}
6240inline const ::google::protobuf::RepeatedPtrField< ::caffe2::Argument >&
6241OperatorDef::arg() const {
6242 // @@protoc_insertion_point(field_list:caffe2.OperatorDef.arg)
6243 return arg_;
6244}
6245inline ::google::protobuf::RepeatedPtrField< ::caffe2::Argument >*
6246OperatorDef::mutable_arg() {
6247 // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.arg)
6248 return &arg_;
6249}
6250
6251// optional .caffe2.DeviceOption device_option = 6;
6252inline bool OperatorDef::has_device_option() const {
6253 return (_has_bits_[0] & 0x00000020u) != 0;
6254}
6255inline void OperatorDef::set_has_device_option() {
6256 _has_bits_[0] |= 0x00000020u;
6257}
6258inline void OperatorDef::clear_has_device_option() {
6259 _has_bits_[0] &= ~0x00000020u;
6260}
6261inline void OperatorDef::clear_device_option() {
6262 if (device_option_ != NULL) device_option_->::caffe2::DeviceOption::Clear();
6263 clear_has_device_option();
6264}
6265inline const ::caffe2::DeviceOption& OperatorDef::device_option() const {
6266 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.device_option)
6267 return device_option_ != NULL ? *device_option_ : *default_instance_->device_option_;
6268}
6269inline ::caffe2::DeviceOption* OperatorDef::mutable_device_option() {
6270 set_has_device_option();
6271 if (device_option_ == NULL) device_option_ = new ::caffe2::DeviceOption;
6272 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.device_option)
6273 return device_option_;
6274}
6275inline ::caffe2::DeviceOption* OperatorDef::release_device_option() {
6276 clear_has_device_option();
6277 ::caffe2::DeviceOption* temp = device_option_;
6278 device_option_ = NULL;
6279 return temp;
6280}
6281inline void OperatorDef::set_allocated_device_option(::caffe2::DeviceOption* device_option) {
6282 delete device_option_;
6283 device_option_ = device_option;
6284 if (device_option) {
6285 set_has_device_option();
6286 } else {
6287 clear_has_device_option();
6288 }
6289 // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.device_option)
6290}
6291
6292// optional string engine = 7;
6293inline bool OperatorDef::has_engine() const {
6294 return (_has_bits_[0] & 0x00000040u) != 0;
6295}
6296inline void OperatorDef::set_has_engine() {
6297 _has_bits_[0] |= 0x00000040u;
6298}
6299inline void OperatorDef::clear_has_engine() {
6300 _has_bits_[0] &= ~0x00000040u;
6301}
6302inline void OperatorDef::clear_engine() {
6303 if (engine_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6304 engine_->clear();
6305 }
6306 clear_has_engine();
6307}
6308inline const ::std::string& OperatorDef::engine() const {
6309 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.engine)
6310 return *engine_;
6311}
6312inline void OperatorDef::set_engine(const ::std::string& value) {
6313 set_has_engine();
6314 if (engine_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6315 engine_ = new ::std::string;
6316 }
6317 engine_->assign(value);
6318 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.engine)
6319}
6320inline void OperatorDef::set_engine(const char* value) {
6321 set_has_engine();
6322 if (engine_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6323 engine_ = new ::std::string;
6324 }
6325 engine_->assign(value);
6326 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.engine)
6327}
6328inline void OperatorDef::set_engine(const char* value, size_t size) {
6329 set_has_engine();
6330 if (engine_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6331 engine_ = new ::std::string;
6332 }
6333 engine_->assign(reinterpret_cast<const char*>(value), size);
6334 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.engine)
6335}
6336inline ::std::string* OperatorDef::mutable_engine() {
6337 set_has_engine();
6338 if (engine_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6339 engine_ = new ::std::string;
6340 }
6341 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.engine)
6342 return engine_;
6343}
6344inline ::std::string* OperatorDef::release_engine() {
6345 clear_has_engine();
6346 if (engine_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6347 return NULL;
6348 } else {
6349 ::std::string* temp = engine_;
6350 engine_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6351 return temp;
6352 }
6353}
6354inline void OperatorDef::set_allocated_engine(::std::string* engine) {
6355 if (engine_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6356 delete engine_;
6357 }
6358 if (engine) {
6359 set_has_engine();
6360 engine_ = engine;
6361 } else {
6362 clear_has_engine();
6363 engine_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6364 }
6365 // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.engine)
6366}
6367
6368// repeated string control_input = 8;
6369inline int OperatorDef::control_input_size() const {
6370 return control_input_.size();
6371}
6372inline void OperatorDef::clear_control_input() {
6373 control_input_.Clear();
6374}
6375inline const ::std::string& OperatorDef::control_input(int index) const {
6376 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.control_input)
6377 return control_input_.Get(index);
6378}
6379inline ::std::string* OperatorDef::mutable_control_input(int index) {
6380 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.control_input)
6381 return control_input_.Mutable(index);
6382}
6383inline void OperatorDef::set_control_input(int index, const ::std::string& value) {
6384 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.control_input)
6385 control_input_.Mutable(index)->assign(value);
6386}
6387inline void OperatorDef::set_control_input(int index, const char* value) {
6388 control_input_.Mutable(index)->assign(value);
6389 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.control_input)
6390}
6391inline void OperatorDef::set_control_input(int index, const char* value, size_t size) {
6392 control_input_.Mutable(index)->assign(
6393 reinterpret_cast<const char*>(value), size);
6394 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.control_input)
6395}
6396inline ::std::string* OperatorDef::add_control_input() {
6397 return control_input_.Add();
6398}
6399inline void OperatorDef::add_control_input(const ::std::string& value) {
6400 control_input_.Add()->assign(value);
6401 // @@protoc_insertion_point(field_add:caffe2.OperatorDef.control_input)
6402}
6403inline void OperatorDef::add_control_input(const char* value) {
6404 control_input_.Add()->assign(value);
6405 // @@protoc_insertion_point(field_add_char:caffe2.OperatorDef.control_input)
6406}
6407inline void OperatorDef::add_control_input(const char* value, size_t size) {
6408 control_input_.Add()->assign(reinterpret_cast<const char*>(value), size);
6409 // @@protoc_insertion_point(field_add_pointer:caffe2.OperatorDef.control_input)
6410}
6411inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
6412OperatorDef::control_input() const {
6413 // @@protoc_insertion_point(field_list:caffe2.OperatorDef.control_input)
6414 return control_input_;
6415}
6416inline ::google::protobuf::RepeatedPtrField< ::std::string>*
6417OperatorDef::mutable_control_input() {
6418 // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.control_input)
6419 return &control_input_;
6420}
6421
6422// optional bool is_gradient_op = 9 [default = false];
6423inline bool OperatorDef::has_is_gradient_op() const {
6424 return (_has_bits_[0] & 0x00000100u) != 0;
6425}
6426inline void OperatorDef::set_has_is_gradient_op() {
6427 _has_bits_[0] |= 0x00000100u;
6428}
6429inline void OperatorDef::clear_has_is_gradient_op() {
6430 _has_bits_[0] &= ~0x00000100u;
6431}
6432inline void OperatorDef::clear_is_gradient_op() {
6433 is_gradient_op_ = false;
6434 clear_has_is_gradient_op();
6435}
6436inline bool OperatorDef::is_gradient_op() const {
6437 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.is_gradient_op)
6438 return is_gradient_op_;
6439}
6440inline void OperatorDef::set_is_gradient_op(bool value) {
6441 set_has_is_gradient_op();
6442 is_gradient_op_ = value;
6443 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.is_gradient_op)
6444}
6445
6446// optional string debug_info = 10;
6447inline bool OperatorDef::has_debug_info() const {
6448 return (_has_bits_[0] & 0x00000200u) != 0;
6449}
6450inline void OperatorDef::set_has_debug_info() {
6451 _has_bits_[0] |= 0x00000200u;
6452}
6453inline void OperatorDef::clear_has_debug_info() {
6454 _has_bits_[0] &= ~0x00000200u;
6455}
6456inline void OperatorDef::clear_debug_info() {
6457 if (debug_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6458 debug_info_->clear();
6459 }
6460 clear_has_debug_info();
6461}
6462inline const ::std::string& OperatorDef::debug_info() const {
6463 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.debug_info)
6464 return *debug_info_;
6465}
6466inline void OperatorDef::set_debug_info(const ::std::string& value) {
6467 set_has_debug_info();
6468 if (debug_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6469 debug_info_ = new ::std::string;
6470 }
6471 debug_info_->assign(value);
6472 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.debug_info)
6473}
6474inline void OperatorDef::set_debug_info(const char* value) {
6475 set_has_debug_info();
6476 if (debug_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6477 debug_info_ = new ::std::string;
6478 }
6479 debug_info_->assign(value);
6480 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.debug_info)
6481}
6482inline void OperatorDef::set_debug_info(const char* value, size_t size) {
6483 set_has_debug_info();
6484 if (debug_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6485 debug_info_ = new ::std::string;
6486 }
6487 debug_info_->assign(reinterpret_cast<const char*>(value), size);
6488 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.debug_info)
6489}
6490inline ::std::string* OperatorDef::mutable_debug_info() {
6491 set_has_debug_info();
6492 if (debug_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6493 debug_info_ = new ::std::string;
6494 }
6495 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.debug_info)
6496 return debug_info_;
6497}
6498inline ::std::string* OperatorDef::release_debug_info() {
6499 clear_has_debug_info();
6500 if (debug_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6501 return NULL;
6502 } else {
6503 ::std::string* temp = debug_info_;
6504 debug_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6505 return temp;
6506 }
6507}
6508inline void OperatorDef::set_allocated_debug_info(::std::string* debug_info) {
6509 if (debug_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6510 delete debug_info_;
6511 }
6512 if (debug_info) {
6513 set_has_debug_info();
6514 debug_info_ = debug_info;
6515 } else {
6516 clear_has_debug_info();
6517 debug_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6518 }
6519 // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.debug_info)
6520}
6521
6522// optional string domain = 11;
6523inline bool OperatorDef::has_domain() const {
6524 return (_has_bits_[0] & 0x00000400u) != 0;
6525}
6526inline void OperatorDef::set_has_domain() {
6527 _has_bits_[0] |= 0x00000400u;
6528}
6529inline void OperatorDef::clear_has_domain() {
6530 _has_bits_[0] &= ~0x00000400u;
6531}
6532inline void OperatorDef::clear_domain() {
6533 if (domain_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6534 domain_->clear();
6535 }
6536 clear_has_domain();
6537}
6538inline const ::std::string& OperatorDef::domain() const {
6539 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.domain)
6540 return *domain_;
6541}
6542inline void OperatorDef::set_domain(const ::std::string& value) {
6543 set_has_domain();
6544 if (domain_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6545 domain_ = new ::std::string;
6546 }
6547 domain_->assign(value);
6548 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.domain)
6549}
6550inline void OperatorDef::set_domain(const char* value) {
6551 set_has_domain();
6552 if (domain_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6553 domain_ = new ::std::string;
6554 }
6555 domain_->assign(value);
6556 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.domain)
6557}
6558inline void OperatorDef::set_domain(const char* value, size_t size) {
6559 set_has_domain();
6560 if (domain_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6561 domain_ = new ::std::string;
6562 }
6563 domain_->assign(reinterpret_cast<const char*>(value), size);
6564 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.domain)
6565}
6566inline ::std::string* OperatorDef::mutable_domain() {
6567 set_has_domain();
6568 if (domain_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6569 domain_ = new ::std::string;
6570 }
6571 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.domain)
6572 return domain_;
6573}
6574inline ::std::string* OperatorDef::release_domain() {
6575 clear_has_domain();
6576 if (domain_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6577 return NULL;
6578 } else {
6579 ::std::string* temp = domain_;
6580 domain_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6581 return temp;
6582 }
6583}
6584inline void OperatorDef::set_allocated_domain(::std::string* domain) {
6585 if (domain_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6586 delete domain_;
6587 }
6588 if (domain) {
6589 set_has_domain();
6590 domain_ = domain;
6591 } else {
6592 clear_has_domain();
6593 domain_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6594 }
6595 // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.domain)
6596}
6597
6598// optional int64 op_version = 12;
6599inline bool OperatorDef::has_op_version() const {
6600 return (_has_bits_[0] & 0x00000800u) != 0;
6601}
6602inline void OperatorDef::set_has_op_version() {
6603 _has_bits_[0] |= 0x00000800u;
6604}
6605inline void OperatorDef::clear_has_op_version() {
6606 _has_bits_[0] &= ~0x00000800u;
6607}
6608inline void OperatorDef::clear_op_version() {
6609 op_version_ = GOOGLE_LONGLONG(0);
6610 clear_has_op_version();
6611}
6612inline ::google::protobuf::int64 OperatorDef::op_version() const {
6613 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.op_version)
6614 return op_version_;
6615}
6616inline void OperatorDef::set_op_version(::google::protobuf::int64 value) {
6617 set_has_op_version();
6618 op_version_ = value;
6619 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.op_version)
6620}
6621
6622// -------------------------------------------------------------------
6623
6624// MapFieldEntry
6625
6626// required string key = 1;
6627inline bool MapFieldEntry::has_key() const {
6628 return (_has_bits_[0] & 0x00000001u) != 0;
6629}
6630inline void MapFieldEntry::set_has_key() {
6631 _has_bits_[0] |= 0x00000001u;
6632}
6633inline void MapFieldEntry::clear_has_key() {
6634 _has_bits_[0] &= ~0x00000001u;
6635}
6636inline void MapFieldEntry::clear_key() {
6637 if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6638 key_->clear();
6639 }
6640 clear_has_key();
6641}
6642inline const ::std::string& MapFieldEntry::key() const {
6643 // @@protoc_insertion_point(field_get:caffe2.MapFieldEntry.key)
6644 return *key_;
6645}
6646inline void MapFieldEntry::set_key(const ::std::string& value) {
6647 set_has_key();
6648 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6649 key_ = new ::std::string;
6650 }
6651 key_->assign(value);
6652 // @@protoc_insertion_point(field_set:caffe2.MapFieldEntry.key)
6653}
6654inline void MapFieldEntry::set_key(const char* value) {
6655 set_has_key();
6656 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6657 key_ = new ::std::string;
6658 }
6659 key_->assign(value);
6660 // @@protoc_insertion_point(field_set_char:caffe2.MapFieldEntry.key)
6661}
6662inline void MapFieldEntry::set_key(const char* value, size_t size) {
6663 set_has_key();
6664 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6665 key_ = new ::std::string;
6666 }
6667 key_->assign(reinterpret_cast<const char*>(value), size);
6668 // @@protoc_insertion_point(field_set_pointer:caffe2.MapFieldEntry.key)
6669}
6670inline ::std::string* MapFieldEntry::mutable_key() {
6671 set_has_key();
6672 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6673 key_ = new ::std::string;
6674 }
6675 // @@protoc_insertion_point(field_mutable:caffe2.MapFieldEntry.key)
6676 return key_;
6677}
6678inline ::std::string* MapFieldEntry::release_key() {
6679 clear_has_key();
6680 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6681 return NULL;
6682 } else {
6683 ::std::string* temp = key_;
6684 key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6685 return temp;
6686 }
6687}
6688inline void MapFieldEntry::set_allocated_key(::std::string* key) {
6689 if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6690 delete key_;
6691 }
6692 if (key) {
6693 set_has_key();
6694 key_ = key;
6695 } else {
6696 clear_has_key();
6697 key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6698 }
6699 // @@protoc_insertion_point(field_set_allocated:caffe2.MapFieldEntry.key)
6700}
6701
6702// required string val = 2;
6703inline bool MapFieldEntry::has_val() const {
6704 return (_has_bits_[0] & 0x00000002u) != 0;
6705}
6706inline void MapFieldEntry::set_has_val() {
6707 _has_bits_[0] |= 0x00000002u;
6708}
6709inline void MapFieldEntry::clear_has_val() {
6710 _has_bits_[0] &= ~0x00000002u;
6711}
6712inline void MapFieldEntry::clear_val() {
6713 if (val_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6714 val_->clear();
6715 }
6716 clear_has_val();
6717}
6718inline const ::std::string& MapFieldEntry::val() const {
6719 // @@protoc_insertion_point(field_get:caffe2.MapFieldEntry.val)
6720 return *val_;
6721}
6722inline void MapFieldEntry::set_val(const ::std::string& value) {
6723 set_has_val();
6724 if (val_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6725 val_ = new ::std::string;
6726 }
6727 val_->assign(value);
6728 // @@protoc_insertion_point(field_set:caffe2.MapFieldEntry.val)
6729}
6730inline void MapFieldEntry::set_val(const char* value) {
6731 set_has_val();
6732 if (val_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6733 val_ = new ::std::string;
6734 }
6735 val_->assign(value);
6736 // @@protoc_insertion_point(field_set_char:caffe2.MapFieldEntry.val)
6737}
6738inline void MapFieldEntry::set_val(const char* value, size_t size) {
6739 set_has_val();
6740 if (val_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6741 val_ = new ::std::string;
6742 }
6743 val_->assign(reinterpret_cast<const char*>(value), size);
6744 // @@protoc_insertion_point(field_set_pointer:caffe2.MapFieldEntry.val)
6745}
6746inline ::std::string* MapFieldEntry::mutable_val() {
6747 set_has_val();
6748 if (val_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6749 val_ = new ::std::string;
6750 }
6751 // @@protoc_insertion_point(field_mutable:caffe2.MapFieldEntry.val)
6752 return val_;
6753}
6754inline ::std::string* MapFieldEntry::release_val() {
6755 clear_has_val();
6756 if (val_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6757 return NULL;
6758 } else {
6759 ::std::string* temp = val_;
6760 val_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6761 return temp;
6762 }
6763}
6764inline void MapFieldEntry::set_allocated_val(::std::string* val) {
6765 if (val_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6766 delete val_;
6767 }
6768 if (val) {
6769 set_has_val();
6770 val_ = val;
6771 } else {
6772 clear_has_val();
6773 val_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6774 }
6775 // @@protoc_insertion_point(field_set_allocated:caffe2.MapFieldEntry.val)
6776}
6777
6778// -------------------------------------------------------------------
6779
6780// BackendOptions
6781
6782// required string backend_name = 1;
6783inline bool BackendOptions::has_backend_name() const {
6784 return (_has_bits_[0] & 0x00000001u) != 0;
6785}
6786inline void BackendOptions::set_has_backend_name() {
6787 _has_bits_[0] |= 0x00000001u;
6788}
6789inline void BackendOptions::clear_has_backend_name() {
6790 _has_bits_[0] &= ~0x00000001u;
6791}
6792inline void BackendOptions::clear_backend_name() {
6793 if (backend_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6794 backend_name_->clear();
6795 }
6796 clear_has_backend_name();
6797}
6798inline const ::std::string& BackendOptions::backend_name() const {
6799 // @@protoc_insertion_point(field_get:caffe2.BackendOptions.backend_name)
6800 return *backend_name_;
6801}
6802inline void BackendOptions::set_backend_name(const ::std::string& value) {
6803 set_has_backend_name();
6804 if (backend_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6805 backend_name_ = new ::std::string;
6806 }
6807 backend_name_->assign(value);
6808 // @@protoc_insertion_point(field_set:caffe2.BackendOptions.backend_name)
6809}
6810inline void BackendOptions::set_backend_name(const char* value) {
6811 set_has_backend_name();
6812 if (backend_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6813 backend_name_ = new ::std::string;
6814 }
6815 backend_name_->assign(value);
6816 // @@protoc_insertion_point(field_set_char:caffe2.BackendOptions.backend_name)
6817}
6818inline void BackendOptions::set_backend_name(const char* value, size_t size) {
6819 set_has_backend_name();
6820 if (backend_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6821 backend_name_ = new ::std::string;
6822 }
6823 backend_name_->assign(reinterpret_cast<const char*>(value), size);
6824 // @@protoc_insertion_point(field_set_pointer:caffe2.BackendOptions.backend_name)
6825}
6826inline ::std::string* BackendOptions::mutable_backend_name() {
6827 set_has_backend_name();
6828 if (backend_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6829 backend_name_ = new ::std::string;
6830 }
6831 // @@protoc_insertion_point(field_mutable:caffe2.BackendOptions.backend_name)
6832 return backend_name_;
6833}
6834inline ::std::string* BackendOptions::release_backend_name() {
6835 clear_has_backend_name();
6836 if (backend_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6837 return NULL;
6838 } else {
6839 ::std::string* temp = backend_name_;
6840 backend_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6841 return temp;
6842 }
6843}
6844inline void BackendOptions::set_allocated_backend_name(::std::string* backend_name) {
6845 if (backend_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6846 delete backend_name_;
6847 }
6848 if (backend_name) {
6849 set_has_backend_name();
6850 backend_name_ = backend_name;
6851 } else {
6852 clear_has_backend_name();
6853 backend_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6854 }
6855 // @@protoc_insertion_point(field_set_allocated:caffe2.BackendOptions.backend_name)
6856}
6857
6858// repeated .caffe2.MapFieldEntry option = 2;
6859inline int BackendOptions::option_size() const {
6860 return option_.size();
6861}
6862inline void BackendOptions::clear_option() {
6863 option_.Clear();
6864}
6865inline const ::caffe2::MapFieldEntry& BackendOptions::option(int index) const {
6866 // @@protoc_insertion_point(field_get:caffe2.BackendOptions.option)
6867 return option_.Get(index);
6868}
6869inline ::caffe2::MapFieldEntry* BackendOptions::mutable_option(int index) {
6870 // @@protoc_insertion_point(field_mutable:caffe2.BackendOptions.option)
6871 return option_.Mutable(index);
6872}
6873inline ::caffe2::MapFieldEntry* BackendOptions::add_option() {
6874 // @@protoc_insertion_point(field_add:caffe2.BackendOptions.option)
6875 return option_.Add();
6876}
6877inline const ::google::protobuf::RepeatedPtrField< ::caffe2::MapFieldEntry >&
6878BackendOptions::option() const {
6879 // @@protoc_insertion_point(field_list:caffe2.BackendOptions.option)
6880 return option_;
6881}
6882inline ::google::protobuf::RepeatedPtrField< ::caffe2::MapFieldEntry >*
6883BackendOptions::mutable_option() {
6884 // @@protoc_insertion_point(field_mutable_list:caffe2.BackendOptions.option)
6885 return &option_;
6886}
6887
6888// -------------------------------------------------------------------
6889
6890// PartitionInfo
6891
6892// required string name = 1;
6893inline bool PartitionInfo::has_name() const {
6894 return (_has_bits_[0] & 0x00000001u) != 0;
6895}
6896inline void PartitionInfo::set_has_name() {
6897 _has_bits_[0] |= 0x00000001u;
6898}
6899inline void PartitionInfo::clear_has_name() {
6900 _has_bits_[0] &= ~0x00000001u;
6901}
6902inline void PartitionInfo::clear_name() {
6903 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6904 name_->clear();
6905 }
6906 clear_has_name();
6907}
6908inline const ::std::string& PartitionInfo::name() const {
6909 // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.name)
6910 return *name_;
6911}
6912inline void PartitionInfo::set_name(const ::std::string& value) {
6913 set_has_name();
6914 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6915 name_ = new ::std::string;
6916 }
6917 name_->assign(value);
6918 // @@protoc_insertion_point(field_set:caffe2.PartitionInfo.name)
6919}
6920inline void PartitionInfo::set_name(const char* value) {
6921 set_has_name();
6922 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6923 name_ = new ::std::string;
6924 }
6925 name_->assign(value);
6926 // @@protoc_insertion_point(field_set_char:caffe2.PartitionInfo.name)
6927}
6928inline void PartitionInfo::set_name(const char* value, size_t size) {
6929 set_has_name();
6930 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6931 name_ = new ::std::string;
6932 }
6933 name_->assign(reinterpret_cast<const char*>(value), size);
6934 // @@protoc_insertion_point(field_set_pointer:caffe2.PartitionInfo.name)
6935}
6936inline ::std::string* PartitionInfo::mutable_name() {
6937 set_has_name();
6938 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6939 name_ = new ::std::string;
6940 }
6941 // @@protoc_insertion_point(field_mutable:caffe2.PartitionInfo.name)
6942 return name_;
6943}
6944inline ::std::string* PartitionInfo::release_name() {
6945 clear_has_name();
6946 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6947 return NULL;
6948 } else {
6949 ::std::string* temp = name_;
6950 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6951 return temp;
6952 }
6953}
6954inline void PartitionInfo::set_allocated_name(::std::string* name) {
6955 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
6956 delete name_;
6957 }
6958 if (name) {
6959 set_has_name();
6960 name_ = name;
6961 } else {
6962 clear_has_name();
6963 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
6964 }
6965 // @@protoc_insertion_point(field_set_allocated:caffe2.PartitionInfo.name)
6966}
6967
6968// repeated int32 device_id = 2;
6969inline int PartitionInfo::device_id_size() const {
6970 return device_id_.size();
6971}
6972inline void PartitionInfo::clear_device_id() {
6973 device_id_.Clear();
6974}
6975inline ::google::protobuf::int32 PartitionInfo::device_id(int index) const {
6976 // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.device_id)
6977 return device_id_.Get(index);
6978}
6979inline void PartitionInfo::set_device_id(int index, ::google::protobuf::int32 value) {
6980 device_id_.Set(index, value);
6981 // @@protoc_insertion_point(field_set:caffe2.PartitionInfo.device_id)
6982}
6983inline void PartitionInfo::add_device_id(::google::protobuf::int32 value) {
6984 device_id_.Add(value);
6985 // @@protoc_insertion_point(field_add:caffe2.PartitionInfo.device_id)
6986}
6987inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
6988PartitionInfo::device_id() const {
6989 // @@protoc_insertion_point(field_list:caffe2.PartitionInfo.device_id)
6990 return device_id_;
6991}
6992inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
6993PartitionInfo::mutable_device_id() {
6994 // @@protoc_insertion_point(field_mutable_list:caffe2.PartitionInfo.device_id)
6995 return &device_id_;
6996}
6997
6998// optional string extra_info = 3;
6999inline bool PartitionInfo::has_extra_info() const {
7000 return (_has_bits_[0] & 0x00000004u) != 0;
7001}
7002inline void PartitionInfo::set_has_extra_info() {
7003 _has_bits_[0] |= 0x00000004u;
7004}
7005inline void PartitionInfo::clear_has_extra_info() {
7006 _has_bits_[0] &= ~0x00000004u;
7007}
7008inline void PartitionInfo::clear_extra_info() {
7009 if (extra_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7010 extra_info_->clear();
7011 }
7012 clear_has_extra_info();
7013}
7014inline const ::std::string& PartitionInfo::extra_info() const {
7015 // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.extra_info)
7016 return *extra_info_;
7017}
7018inline void PartitionInfo::set_extra_info(const ::std::string& value) {
7019 set_has_extra_info();
7020 if (extra_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7021 extra_info_ = new ::std::string;
7022 }
7023 extra_info_->assign(value);
7024 // @@protoc_insertion_point(field_set:caffe2.PartitionInfo.extra_info)
7025}
7026inline void PartitionInfo::set_extra_info(const char* value) {
7027 set_has_extra_info();
7028 if (extra_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7029 extra_info_ = new ::std::string;
7030 }
7031 extra_info_->assign(value);
7032 // @@protoc_insertion_point(field_set_char:caffe2.PartitionInfo.extra_info)
7033}
7034inline void PartitionInfo::set_extra_info(const char* value, size_t size) {
7035 set_has_extra_info();
7036 if (extra_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7037 extra_info_ = new ::std::string;
7038 }
7039 extra_info_->assign(reinterpret_cast<const char*>(value), size);
7040 // @@protoc_insertion_point(field_set_pointer:caffe2.PartitionInfo.extra_info)
7041}
7042inline ::std::string* PartitionInfo::mutable_extra_info() {
7043 set_has_extra_info();
7044 if (extra_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7045 extra_info_ = new ::std::string;
7046 }
7047 // @@protoc_insertion_point(field_mutable:caffe2.PartitionInfo.extra_info)
7048 return extra_info_;
7049}
7050inline ::std::string* PartitionInfo::release_extra_info() {
7051 clear_has_extra_info();
7052 if (extra_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7053 return NULL;
7054 } else {
7055 ::std::string* temp = extra_info_;
7056 extra_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7057 return temp;
7058 }
7059}
7060inline void PartitionInfo::set_allocated_extra_info(::std::string* extra_info) {
7061 if (extra_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7062 delete extra_info_;
7063 }
7064 if (extra_info) {
7065 set_has_extra_info();
7066 extra_info_ = extra_info;
7067 } else {
7068 clear_has_extra_info();
7069 extra_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7070 }
7071 // @@protoc_insertion_point(field_set_allocated:caffe2.PartitionInfo.extra_info)
7072}
7073
7074// repeated .caffe2.BackendOptions backend_options = 4;
7075inline int PartitionInfo::backend_options_size() const {
7076 return backend_options_.size();
7077}
7078inline void PartitionInfo::clear_backend_options() {
7079 backend_options_.Clear();
7080}
7081inline const ::caffe2::BackendOptions& PartitionInfo::backend_options(int index) const {
7082 // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.backend_options)
7083 return backend_options_.Get(index);
7084}
7085inline ::caffe2::BackendOptions* PartitionInfo::mutable_backend_options(int index) {
7086 // @@protoc_insertion_point(field_mutable:caffe2.PartitionInfo.backend_options)
7087 return backend_options_.Mutable(index);
7088}
7089inline ::caffe2::BackendOptions* PartitionInfo::add_backend_options() {
7090 // @@protoc_insertion_point(field_add:caffe2.PartitionInfo.backend_options)
7091 return backend_options_.Add();
7092}
7093inline const ::google::protobuf::RepeatedPtrField< ::caffe2::BackendOptions >&
7094PartitionInfo::backend_options() const {
7095 // @@protoc_insertion_point(field_list:caffe2.PartitionInfo.backend_options)
7096 return backend_options_;
7097}
7098inline ::google::protobuf::RepeatedPtrField< ::caffe2::BackendOptions >*
7099PartitionInfo::mutable_backend_options() {
7100 // @@protoc_insertion_point(field_mutable_list:caffe2.PartitionInfo.backend_options)
7101 return &backend_options_;
7102}
7103
7104// -------------------------------------------------------------------
7105
7106// NetDef
7107
7108// optional string name = 1;
7109inline bool NetDef::has_name() const {
7110 return (_has_bits_[0] & 0x00000001u) != 0;
7111}
7112inline void NetDef::set_has_name() {
7113 _has_bits_[0] |= 0x00000001u;
7114}
7115inline void NetDef::clear_has_name() {
7116 _has_bits_[0] &= ~0x00000001u;
7117}
7118inline void NetDef::clear_name() {
7119 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7120 name_->clear();
7121 }
7122 clear_has_name();
7123}
7124inline const ::std::string& NetDef::name() const {
7125 // @@protoc_insertion_point(field_get:caffe2.NetDef.name)
7126 return *name_;
7127}
7128inline void NetDef::set_name(const ::std::string& value) {
7129 set_has_name();
7130 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7131 name_ = new ::std::string;
7132 }
7133 name_->assign(value);
7134 // @@protoc_insertion_point(field_set:caffe2.NetDef.name)
7135}
7136inline void NetDef::set_name(const char* value) {
7137 set_has_name();
7138 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7139 name_ = new ::std::string;
7140 }
7141 name_->assign(value);
7142 // @@protoc_insertion_point(field_set_char:caffe2.NetDef.name)
7143}
7144inline void NetDef::set_name(const char* value, size_t size) {
7145 set_has_name();
7146 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7147 name_ = new ::std::string;
7148 }
7149 name_->assign(reinterpret_cast<const char*>(value), size);
7150 // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.name)
7151}
7152inline ::std::string* NetDef::mutable_name() {
7153 set_has_name();
7154 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7155 name_ = new ::std::string;
7156 }
7157 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.name)
7158 return name_;
7159}
7160inline ::std::string* NetDef::release_name() {
7161 clear_has_name();
7162 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7163 return NULL;
7164 } else {
7165 ::std::string* temp = name_;
7166 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7167 return temp;
7168 }
7169}
7170inline void NetDef::set_allocated_name(::std::string* name) {
7171 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7172 delete name_;
7173 }
7174 if (name) {
7175 set_has_name();
7176 name_ = name;
7177 } else {
7178 clear_has_name();
7179 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7180 }
7181 // @@protoc_insertion_point(field_set_allocated:caffe2.NetDef.name)
7182}
7183
7184// repeated .caffe2.OperatorDef op = 2;
7185inline int NetDef::op_size() const {
7186 return op_.size();
7187}
7188inline void NetDef::clear_op() {
7189 op_.Clear();
7190}
7191inline const ::caffe2::OperatorDef& NetDef::op(int index) const {
7192 // @@protoc_insertion_point(field_get:caffe2.NetDef.op)
7193 return op_.Get(index);
7194}
7195inline ::caffe2::OperatorDef* NetDef::mutable_op(int index) {
7196 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.op)
7197 return op_.Mutable(index);
7198}
7199inline ::caffe2::OperatorDef* NetDef::add_op() {
7200 // @@protoc_insertion_point(field_add:caffe2.NetDef.op)
7201 return op_.Add();
7202}
7203inline const ::google::protobuf::RepeatedPtrField< ::caffe2::OperatorDef >&
7204NetDef::op() const {
7205 // @@protoc_insertion_point(field_list:caffe2.NetDef.op)
7206 return op_;
7207}
7208inline ::google::protobuf::RepeatedPtrField< ::caffe2::OperatorDef >*
7209NetDef::mutable_op() {
7210 // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.op)
7211 return &op_;
7212}
7213
7214// optional string type = 3;
7215inline bool NetDef::has_type() const {
7216 return (_has_bits_[0] & 0x00000004u) != 0;
7217}
7218inline void NetDef::set_has_type() {
7219 _has_bits_[0] |= 0x00000004u;
7220}
7221inline void NetDef::clear_has_type() {
7222 _has_bits_[0] &= ~0x00000004u;
7223}
7224inline void NetDef::clear_type() {
7225 if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7226 type_->clear();
7227 }
7228 clear_has_type();
7229}
7230inline const ::std::string& NetDef::type() const {
7231 // @@protoc_insertion_point(field_get:caffe2.NetDef.type)
7232 return *type_;
7233}
7234inline void NetDef::set_type(const ::std::string& value) {
7235 set_has_type();
7236 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7237 type_ = new ::std::string;
7238 }
7239 type_->assign(value);
7240 // @@protoc_insertion_point(field_set:caffe2.NetDef.type)
7241}
7242inline void NetDef::set_type(const char* value) {
7243 set_has_type();
7244 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7245 type_ = new ::std::string;
7246 }
7247 type_->assign(value);
7248 // @@protoc_insertion_point(field_set_char:caffe2.NetDef.type)
7249}
7250inline void NetDef::set_type(const char* value, size_t size) {
7251 set_has_type();
7252 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7253 type_ = new ::std::string;
7254 }
7255 type_->assign(reinterpret_cast<const char*>(value), size);
7256 // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.type)
7257}
7258inline ::std::string* NetDef::mutable_type() {
7259 set_has_type();
7260 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7261 type_ = new ::std::string;
7262 }
7263 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.type)
7264 return type_;
7265}
7266inline ::std::string* NetDef::release_type() {
7267 clear_has_type();
7268 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7269 return NULL;
7270 } else {
7271 ::std::string* temp = type_;
7272 type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7273 return temp;
7274 }
7275}
7276inline void NetDef::set_allocated_type(::std::string* type) {
7277 if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7278 delete type_;
7279 }
7280 if (type) {
7281 set_has_type();
7282 type_ = type;
7283 } else {
7284 clear_has_type();
7285 type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7286 }
7287 // @@protoc_insertion_point(field_set_allocated:caffe2.NetDef.type)
7288}
7289
7290// optional int32 num_workers = 4;
7291inline bool NetDef::has_num_workers() const {
7292 return (_has_bits_[0] & 0x00000008u) != 0;
7293}
7294inline void NetDef::set_has_num_workers() {
7295 _has_bits_[0] |= 0x00000008u;
7296}
7297inline void NetDef::clear_has_num_workers() {
7298 _has_bits_[0] &= ~0x00000008u;
7299}
7300inline void NetDef::clear_num_workers() {
7301 num_workers_ = 0;
7302 clear_has_num_workers();
7303}
7304inline ::google::protobuf::int32 NetDef::num_workers() const {
7305 // @@protoc_insertion_point(field_get:caffe2.NetDef.num_workers)
7306 return num_workers_;
7307}
7308inline void NetDef::set_num_workers(::google::protobuf::int32 value) {
7309 set_has_num_workers();
7310 num_workers_ = value;
7311 // @@protoc_insertion_point(field_set:caffe2.NetDef.num_workers)
7312}
7313
7314// optional .caffe2.DeviceOption device_option = 5;
7315inline bool NetDef::has_device_option() const {
7316 return (_has_bits_[0] & 0x00000010u) != 0;
7317}
7318inline void NetDef::set_has_device_option() {
7319 _has_bits_[0] |= 0x00000010u;
7320}
7321inline void NetDef::clear_has_device_option() {
7322 _has_bits_[0] &= ~0x00000010u;
7323}
7324inline void NetDef::clear_device_option() {
7325 if (device_option_ != NULL) device_option_->::caffe2::DeviceOption::Clear();
7326 clear_has_device_option();
7327}
7328inline const ::caffe2::DeviceOption& NetDef::device_option() const {
7329 // @@protoc_insertion_point(field_get:caffe2.NetDef.device_option)
7330 return device_option_ != NULL ? *device_option_ : *default_instance_->device_option_;
7331}
7332inline ::caffe2::DeviceOption* NetDef::mutable_device_option() {
7333 set_has_device_option();
7334 if (device_option_ == NULL) device_option_ = new ::caffe2::DeviceOption;
7335 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.device_option)
7336 return device_option_;
7337}
7338inline ::caffe2::DeviceOption* NetDef::release_device_option() {
7339 clear_has_device_option();
7340 ::caffe2::DeviceOption* temp = device_option_;
7341 device_option_ = NULL;
7342 return temp;
7343}
7344inline void NetDef::set_allocated_device_option(::caffe2::DeviceOption* device_option) {
7345 delete device_option_;
7346 device_option_ = device_option;
7347 if (device_option) {
7348 set_has_device_option();
7349 } else {
7350 clear_has_device_option();
7351 }
7352 // @@protoc_insertion_point(field_set_allocated:caffe2.NetDef.device_option)
7353}
7354
7355// repeated .caffe2.Argument arg = 6;
7356inline int NetDef::arg_size() const {
7357 return arg_.size();
7358}
7359inline void NetDef::clear_arg() {
7360 arg_.Clear();
7361}
7362inline const ::caffe2::Argument& NetDef::arg(int index) const {
7363 // @@protoc_insertion_point(field_get:caffe2.NetDef.arg)
7364 return arg_.Get(index);
7365}
7366inline ::caffe2::Argument* NetDef::mutable_arg(int index) {
7367 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.arg)
7368 return arg_.Mutable(index);
7369}
7370inline ::caffe2::Argument* NetDef::add_arg() {
7371 // @@protoc_insertion_point(field_add:caffe2.NetDef.arg)
7372 return arg_.Add();
7373}
7374inline const ::google::protobuf::RepeatedPtrField< ::caffe2::Argument >&
7375NetDef::arg() const {
7376 // @@protoc_insertion_point(field_list:caffe2.NetDef.arg)
7377 return arg_;
7378}
7379inline ::google::protobuf::RepeatedPtrField< ::caffe2::Argument >*
7380NetDef::mutable_arg() {
7381 // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.arg)
7382 return &arg_;
7383}
7384
7385// repeated string external_input = 7;
7386inline int NetDef::external_input_size() const {
7387 return external_input_.size();
7388}
7389inline void NetDef::clear_external_input() {
7390 external_input_.Clear();
7391}
7392inline const ::std::string& NetDef::external_input(int index) const {
7393 // @@protoc_insertion_point(field_get:caffe2.NetDef.external_input)
7394 return external_input_.Get(index);
7395}
7396inline ::std::string* NetDef::mutable_external_input(int index) {
7397 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.external_input)
7398 return external_input_.Mutable(index);
7399}
7400inline void NetDef::set_external_input(int index, const ::std::string& value) {
7401 // @@protoc_insertion_point(field_set:caffe2.NetDef.external_input)
7402 external_input_.Mutable(index)->assign(value);
7403}
7404inline void NetDef::set_external_input(int index, const char* value) {
7405 external_input_.Mutable(index)->assign(value);
7406 // @@protoc_insertion_point(field_set_char:caffe2.NetDef.external_input)
7407}
7408inline void NetDef::set_external_input(int index, const char* value, size_t size) {
7409 external_input_.Mutable(index)->assign(
7410 reinterpret_cast<const char*>(value), size);
7411 // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.external_input)
7412}
7413inline ::std::string* NetDef::add_external_input() {
7414 return external_input_.Add();
7415}
7416inline void NetDef::add_external_input(const ::std::string& value) {
7417 external_input_.Add()->assign(value);
7418 // @@protoc_insertion_point(field_add:caffe2.NetDef.external_input)
7419}
7420inline void NetDef::add_external_input(const char* value) {
7421 external_input_.Add()->assign(value);
7422 // @@protoc_insertion_point(field_add_char:caffe2.NetDef.external_input)
7423}
7424inline void NetDef::add_external_input(const char* value, size_t size) {
7425 external_input_.Add()->assign(reinterpret_cast<const char*>(value), size);
7426 // @@protoc_insertion_point(field_add_pointer:caffe2.NetDef.external_input)
7427}
7428inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
7429NetDef::external_input() const {
7430 // @@protoc_insertion_point(field_list:caffe2.NetDef.external_input)
7431 return external_input_;
7432}
7433inline ::google::protobuf::RepeatedPtrField< ::std::string>*
7434NetDef::mutable_external_input() {
7435 // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.external_input)
7436 return &external_input_;
7437}
7438
7439// repeated string external_output = 8;
7440inline int NetDef::external_output_size() const {
7441 return external_output_.size();
7442}
7443inline void NetDef::clear_external_output() {
7444 external_output_.Clear();
7445}
7446inline const ::std::string& NetDef::external_output(int index) const {
7447 // @@protoc_insertion_point(field_get:caffe2.NetDef.external_output)
7448 return external_output_.Get(index);
7449}
7450inline ::std::string* NetDef::mutable_external_output(int index) {
7451 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.external_output)
7452 return external_output_.Mutable(index);
7453}
7454inline void NetDef::set_external_output(int index, const ::std::string& value) {
7455 // @@protoc_insertion_point(field_set:caffe2.NetDef.external_output)
7456 external_output_.Mutable(index)->assign(value);
7457}
7458inline void NetDef::set_external_output(int index, const char* value) {
7459 external_output_.Mutable(index)->assign(value);
7460 // @@protoc_insertion_point(field_set_char:caffe2.NetDef.external_output)
7461}
7462inline void NetDef::set_external_output(int index, const char* value, size_t size) {
7463 external_output_.Mutable(index)->assign(
7464 reinterpret_cast<const char*>(value), size);
7465 // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.external_output)
7466}
7467inline ::std::string* NetDef::add_external_output() {
7468 return external_output_.Add();
7469}
7470inline void NetDef::add_external_output(const ::std::string& value) {
7471 external_output_.Add()->assign(value);
7472 // @@protoc_insertion_point(field_add:caffe2.NetDef.external_output)
7473}
7474inline void NetDef::add_external_output(const char* value) {
7475 external_output_.Add()->assign(value);
7476 // @@protoc_insertion_point(field_add_char:caffe2.NetDef.external_output)
7477}
7478inline void NetDef::add_external_output(const char* value, size_t size) {
7479 external_output_.Add()->assign(reinterpret_cast<const char*>(value), size);
7480 // @@protoc_insertion_point(field_add_pointer:caffe2.NetDef.external_output)
7481}
7482inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
7483NetDef::external_output() const {
7484 // @@protoc_insertion_point(field_list:caffe2.NetDef.external_output)
7485 return external_output_;
7486}
7487inline ::google::protobuf::RepeatedPtrField< ::std::string>*
7488NetDef::mutable_external_output() {
7489 // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.external_output)
7490 return &external_output_;
7491}
7492
7493// repeated .caffe2.PartitionInfo partition_info = 9;
7494inline int NetDef::partition_info_size() const {
7495 return partition_info_.size();
7496}
7497inline void NetDef::clear_partition_info() {
7498 partition_info_.Clear();
7499}
7500inline const ::caffe2::PartitionInfo& NetDef::partition_info(int index) const {
7501 // @@protoc_insertion_point(field_get:caffe2.NetDef.partition_info)
7502 return partition_info_.Get(index);
7503}
7504inline ::caffe2::PartitionInfo* NetDef::mutable_partition_info(int index) {
7505 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.partition_info)
7506 return partition_info_.Mutable(index);
7507}
7508inline ::caffe2::PartitionInfo* NetDef::add_partition_info() {
7509 // @@protoc_insertion_point(field_add:caffe2.NetDef.partition_info)
7510 return partition_info_.Add();
7511}
7512inline const ::google::protobuf::RepeatedPtrField< ::caffe2::PartitionInfo >&
7513NetDef::partition_info() const {
7514 // @@protoc_insertion_point(field_list:caffe2.NetDef.partition_info)
7515 return partition_info_;
7516}
7517inline ::google::protobuf::RepeatedPtrField< ::caffe2::PartitionInfo >*
7518NetDef::mutable_partition_info() {
7519 // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.partition_info)
7520 return &partition_info_;
7521}
7522
7523// -------------------------------------------------------------------
7524
7525// ExecutionStep
7526
7527// optional string name = 1;
7528inline bool ExecutionStep::has_name() const {
7529 return (_has_bits_[0] & 0x00000001u) != 0;
7530}
7531inline void ExecutionStep::set_has_name() {
7532 _has_bits_[0] |= 0x00000001u;
7533}
7534inline void ExecutionStep::clear_has_name() {
7535 _has_bits_[0] &= ~0x00000001u;
7536}
7537inline void ExecutionStep::clear_name() {
7538 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7539 name_->clear();
7540 }
7541 clear_has_name();
7542}
7543inline const ::std::string& ExecutionStep::name() const {
7544 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.name)
7545 return *name_;
7546}
7547inline void ExecutionStep::set_name(const ::std::string& value) {
7548 set_has_name();
7549 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7550 name_ = new ::std::string;
7551 }
7552 name_->assign(value);
7553 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.name)
7554}
7555inline void ExecutionStep::set_name(const char* value) {
7556 set_has_name();
7557 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7558 name_ = new ::std::string;
7559 }
7560 name_->assign(value);
7561 // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.name)
7562}
7563inline void ExecutionStep::set_name(const char* value, size_t size) {
7564 set_has_name();
7565 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7566 name_ = new ::std::string;
7567 }
7568 name_->assign(reinterpret_cast<const char*>(value), size);
7569 // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.name)
7570}
7571inline ::std::string* ExecutionStep::mutable_name() {
7572 set_has_name();
7573 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7574 name_ = new ::std::string;
7575 }
7576 // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.name)
7577 return name_;
7578}
7579inline ::std::string* ExecutionStep::release_name() {
7580 clear_has_name();
7581 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7582 return NULL;
7583 } else {
7584 ::std::string* temp = name_;
7585 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7586 return temp;
7587 }
7588}
7589inline void ExecutionStep::set_allocated_name(::std::string* name) {
7590 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7591 delete name_;
7592 }
7593 if (name) {
7594 set_has_name();
7595 name_ = name;
7596 } else {
7597 clear_has_name();
7598 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7599 }
7600 // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.name)
7601}
7602
7603// repeated .caffe2.ExecutionStep substep = 2;
7604inline int ExecutionStep::substep_size() const {
7605 return substep_.size();
7606}
7607inline void ExecutionStep::clear_substep() {
7608 substep_.Clear();
7609}
7610inline const ::caffe2::ExecutionStep& ExecutionStep::substep(int index) const {
7611 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.substep)
7612 return substep_.Get(index);
7613}
7614inline ::caffe2::ExecutionStep* ExecutionStep::mutable_substep(int index) {
7615 // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.substep)
7616 return substep_.Mutable(index);
7617}
7618inline ::caffe2::ExecutionStep* ExecutionStep::add_substep() {
7619 // @@protoc_insertion_point(field_add:caffe2.ExecutionStep.substep)
7620 return substep_.Add();
7621}
7622inline const ::google::protobuf::RepeatedPtrField< ::caffe2::ExecutionStep >&
7623ExecutionStep::substep() const {
7624 // @@protoc_insertion_point(field_list:caffe2.ExecutionStep.substep)
7625 return substep_;
7626}
7627inline ::google::protobuf::RepeatedPtrField< ::caffe2::ExecutionStep >*
7628ExecutionStep::mutable_substep() {
7629 // @@protoc_insertion_point(field_mutable_list:caffe2.ExecutionStep.substep)
7630 return &substep_;
7631}
7632
7633// repeated string network = 3;
7634inline int ExecutionStep::network_size() const {
7635 return network_.size();
7636}
7637inline void ExecutionStep::clear_network() {
7638 network_.Clear();
7639}
7640inline const ::std::string& ExecutionStep::network(int index) const {
7641 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.network)
7642 return network_.Get(index);
7643}
7644inline ::std::string* ExecutionStep::mutable_network(int index) {
7645 // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.network)
7646 return network_.Mutable(index);
7647}
7648inline void ExecutionStep::set_network(int index, const ::std::string& value) {
7649 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.network)
7650 network_.Mutable(index)->assign(value);
7651}
7652inline void ExecutionStep::set_network(int index, const char* value) {
7653 network_.Mutable(index)->assign(value);
7654 // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.network)
7655}
7656inline void ExecutionStep::set_network(int index, const char* value, size_t size) {
7657 network_.Mutable(index)->assign(
7658 reinterpret_cast<const char*>(value), size);
7659 // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.network)
7660}
7661inline ::std::string* ExecutionStep::add_network() {
7662 return network_.Add();
7663}
7664inline void ExecutionStep::add_network(const ::std::string& value) {
7665 network_.Add()->assign(value);
7666 // @@protoc_insertion_point(field_add:caffe2.ExecutionStep.network)
7667}
7668inline void ExecutionStep::add_network(const char* value) {
7669 network_.Add()->assign(value);
7670 // @@protoc_insertion_point(field_add_char:caffe2.ExecutionStep.network)
7671}
7672inline void ExecutionStep::add_network(const char* value, size_t size) {
7673 network_.Add()->assign(reinterpret_cast<const char*>(value), size);
7674 // @@protoc_insertion_point(field_add_pointer:caffe2.ExecutionStep.network)
7675}
7676inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
7677ExecutionStep::network() const {
7678 // @@protoc_insertion_point(field_list:caffe2.ExecutionStep.network)
7679 return network_;
7680}
7681inline ::google::protobuf::RepeatedPtrField< ::std::string>*
7682ExecutionStep::mutable_network() {
7683 // @@protoc_insertion_point(field_mutable_list:caffe2.ExecutionStep.network)
7684 return &network_;
7685}
7686
7687// optional int64 num_iter = 4;
7688inline bool ExecutionStep::has_num_iter() const {
7689 return (_has_bits_[0] & 0x00000008u) != 0;
7690}
7691inline void ExecutionStep::set_has_num_iter() {
7692 _has_bits_[0] |= 0x00000008u;
7693}
7694inline void ExecutionStep::clear_has_num_iter() {
7695 _has_bits_[0] &= ~0x00000008u;
7696}
7697inline void ExecutionStep::clear_num_iter() {
7698 num_iter_ = GOOGLE_LONGLONG(0);
7699 clear_has_num_iter();
7700}
7701inline ::google::protobuf::int64 ExecutionStep::num_iter() const {
7702 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.num_iter)
7703 return num_iter_;
7704}
7705inline void ExecutionStep::set_num_iter(::google::protobuf::int64 value) {
7706 set_has_num_iter();
7707 num_iter_ = value;
7708 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.num_iter)
7709}
7710
7711// optional string criteria_network = 5 [deprecated = true];
7712inline bool ExecutionStep::has_criteria_network() const {
7713 return (_has_bits_[0] & 0x00000010u) != 0;
7714}
7715inline void ExecutionStep::set_has_criteria_network() {
7716 _has_bits_[0] |= 0x00000010u;
7717}
7718inline void ExecutionStep::clear_has_criteria_network() {
7719 _has_bits_[0] &= ~0x00000010u;
7720}
7721inline void ExecutionStep::clear_criteria_network() {
7722 if (criteria_network_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7723 criteria_network_->clear();
7724 }
7725 clear_has_criteria_network();
7726}
7727inline const ::std::string& ExecutionStep::criteria_network() const {
7728 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.criteria_network)
7729 return *criteria_network_;
7730}
7731inline void ExecutionStep::set_criteria_network(const ::std::string& value) {
7732 set_has_criteria_network();
7733 if (criteria_network_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7734 criteria_network_ = new ::std::string;
7735 }
7736 criteria_network_->assign(value);
7737 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.criteria_network)
7738}
7739inline void ExecutionStep::set_criteria_network(const char* value) {
7740 set_has_criteria_network();
7741 if (criteria_network_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7742 criteria_network_ = new ::std::string;
7743 }
7744 criteria_network_->assign(value);
7745 // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.criteria_network)
7746}
7747inline void ExecutionStep::set_criteria_network(const char* value, size_t size) {
7748 set_has_criteria_network();
7749 if (criteria_network_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7750 criteria_network_ = new ::std::string;
7751 }
7752 criteria_network_->assign(reinterpret_cast<const char*>(value), size);
7753 // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.criteria_network)
7754}
7755inline ::std::string* ExecutionStep::mutable_criteria_network() {
7756 set_has_criteria_network();
7757 if (criteria_network_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7758 criteria_network_ = new ::std::string;
7759 }
7760 // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.criteria_network)
7761 return criteria_network_;
7762}
7763inline ::std::string* ExecutionStep::release_criteria_network() {
7764 clear_has_criteria_network();
7765 if (criteria_network_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7766 return NULL;
7767 } else {
7768 ::std::string* temp = criteria_network_;
7769 criteria_network_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7770 return temp;
7771 }
7772}
7773inline void ExecutionStep::set_allocated_criteria_network(::std::string* criteria_network) {
7774 if (criteria_network_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7775 delete criteria_network_;
7776 }
7777 if (criteria_network) {
7778 set_has_criteria_network();
7779 criteria_network_ = criteria_network;
7780 } else {
7781 clear_has_criteria_network();
7782 criteria_network_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7783 }
7784 // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.criteria_network)
7785}
7786
7787// optional string report_net = 7;
7788inline bool ExecutionStep::has_report_net() const {
7789 return (_has_bits_[0] & 0x00000020u) != 0;
7790}
7791inline void ExecutionStep::set_has_report_net() {
7792 _has_bits_[0] |= 0x00000020u;
7793}
7794inline void ExecutionStep::clear_has_report_net() {
7795 _has_bits_[0] &= ~0x00000020u;
7796}
7797inline void ExecutionStep::clear_report_net() {
7798 if (report_net_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7799 report_net_->clear();
7800 }
7801 clear_has_report_net();
7802}
7803inline const ::std::string& ExecutionStep::report_net() const {
7804 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.report_net)
7805 return *report_net_;
7806}
7807inline void ExecutionStep::set_report_net(const ::std::string& value) {
7808 set_has_report_net();
7809 if (report_net_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7810 report_net_ = new ::std::string;
7811 }
7812 report_net_->assign(value);
7813 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.report_net)
7814}
7815inline void ExecutionStep::set_report_net(const char* value) {
7816 set_has_report_net();
7817 if (report_net_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7818 report_net_ = new ::std::string;
7819 }
7820 report_net_->assign(value);
7821 // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.report_net)
7822}
7823inline void ExecutionStep::set_report_net(const char* value, size_t size) {
7824 set_has_report_net();
7825 if (report_net_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7826 report_net_ = new ::std::string;
7827 }
7828 report_net_->assign(reinterpret_cast<const char*>(value), size);
7829 // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.report_net)
7830}
7831inline ::std::string* ExecutionStep::mutable_report_net() {
7832 set_has_report_net();
7833 if (report_net_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7834 report_net_ = new ::std::string;
7835 }
7836 // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.report_net)
7837 return report_net_;
7838}
7839inline ::std::string* ExecutionStep::release_report_net() {
7840 clear_has_report_net();
7841 if (report_net_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7842 return NULL;
7843 } else {
7844 ::std::string* temp = report_net_;
7845 report_net_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7846 return temp;
7847 }
7848}
7849inline void ExecutionStep::set_allocated_report_net(::std::string* report_net) {
7850 if (report_net_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7851 delete report_net_;
7852 }
7853 if (report_net) {
7854 set_has_report_net();
7855 report_net_ = report_net;
7856 } else {
7857 clear_has_report_net();
7858 report_net_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7859 }
7860 // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.report_net)
7861}
7862
7863// optional int32 report_interval = 8;
7864inline bool ExecutionStep::has_report_interval() const {
7865 return (_has_bits_[0] & 0x00000040u) != 0;
7866}
7867inline void ExecutionStep::set_has_report_interval() {
7868 _has_bits_[0] |= 0x00000040u;
7869}
7870inline void ExecutionStep::clear_has_report_interval() {
7871 _has_bits_[0] &= ~0x00000040u;
7872}
7873inline void ExecutionStep::clear_report_interval() {
7874 report_interval_ = 0;
7875 clear_has_report_interval();
7876}
7877inline ::google::protobuf::int32 ExecutionStep::report_interval() const {
7878 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.report_interval)
7879 return report_interval_;
7880}
7881inline void ExecutionStep::set_report_interval(::google::protobuf::int32 value) {
7882 set_has_report_interval();
7883 report_interval_ = value;
7884 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.report_interval)
7885}
7886
7887// optional int64 run_every_ms = 11;
7888inline bool ExecutionStep::has_run_every_ms() const {
7889 return (_has_bits_[0] & 0x00000080u) != 0;
7890}
7891inline void ExecutionStep::set_has_run_every_ms() {
7892 _has_bits_[0] |= 0x00000080u;
7893}
7894inline void ExecutionStep::clear_has_run_every_ms() {
7895 _has_bits_[0] &= ~0x00000080u;
7896}
7897inline void ExecutionStep::clear_run_every_ms() {
7898 run_every_ms_ = GOOGLE_LONGLONG(0);
7899 clear_has_run_every_ms();
7900}
7901inline ::google::protobuf::int64 ExecutionStep::run_every_ms() const {
7902 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.run_every_ms)
7903 return run_every_ms_;
7904}
7905inline void ExecutionStep::set_run_every_ms(::google::protobuf::int64 value) {
7906 set_has_run_every_ms();
7907 run_every_ms_ = value;
7908 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.run_every_ms)
7909}
7910
7911// optional bool concurrent_substeps = 6;
7912inline bool ExecutionStep::has_concurrent_substeps() const {
7913 return (_has_bits_[0] & 0x00000100u) != 0;
7914}
7915inline void ExecutionStep::set_has_concurrent_substeps() {
7916 _has_bits_[0] |= 0x00000100u;
7917}
7918inline void ExecutionStep::clear_has_concurrent_substeps() {
7919 _has_bits_[0] &= ~0x00000100u;
7920}
7921inline void ExecutionStep::clear_concurrent_substeps() {
7922 concurrent_substeps_ = false;
7923 clear_has_concurrent_substeps();
7924}
7925inline bool ExecutionStep::concurrent_substeps() const {
7926 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.concurrent_substeps)
7927 return concurrent_substeps_;
7928}
7929inline void ExecutionStep::set_concurrent_substeps(bool value) {
7930 set_has_concurrent_substeps();
7931 concurrent_substeps_ = value;
7932 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.concurrent_substeps)
7933}
7934
7935// optional string should_stop_blob = 9;
7936inline bool ExecutionStep::has_should_stop_blob() const {
7937 return (_has_bits_[0] & 0x00000200u) != 0;
7938}
7939inline void ExecutionStep::set_has_should_stop_blob() {
7940 _has_bits_[0] |= 0x00000200u;
7941}
7942inline void ExecutionStep::clear_has_should_stop_blob() {
7943 _has_bits_[0] &= ~0x00000200u;
7944}
7945inline void ExecutionStep::clear_should_stop_blob() {
7946 if (should_stop_blob_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7947 should_stop_blob_->clear();
7948 }
7949 clear_has_should_stop_blob();
7950}
7951inline const ::std::string& ExecutionStep::should_stop_blob() const {
7952 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.should_stop_blob)
7953 return *should_stop_blob_;
7954}
7955inline void ExecutionStep::set_should_stop_blob(const ::std::string& value) {
7956 set_has_should_stop_blob();
7957 if (should_stop_blob_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7958 should_stop_blob_ = new ::std::string;
7959 }
7960 should_stop_blob_->assign(value);
7961 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.should_stop_blob)
7962}
7963inline void ExecutionStep::set_should_stop_blob(const char* value) {
7964 set_has_should_stop_blob();
7965 if (should_stop_blob_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7966 should_stop_blob_ = new ::std::string;
7967 }
7968 should_stop_blob_->assign(value);
7969 // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.should_stop_blob)
7970}
7971inline void ExecutionStep::set_should_stop_blob(const char* value, size_t size) {
7972 set_has_should_stop_blob();
7973 if (should_stop_blob_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7974 should_stop_blob_ = new ::std::string;
7975 }
7976 should_stop_blob_->assign(reinterpret_cast<const char*>(value), size);
7977 // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.should_stop_blob)
7978}
7979inline ::std::string* ExecutionStep::mutable_should_stop_blob() {
7980 set_has_should_stop_blob();
7981 if (should_stop_blob_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7982 should_stop_blob_ = new ::std::string;
7983 }
7984 // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.should_stop_blob)
7985 return should_stop_blob_;
7986}
7987inline ::std::string* ExecutionStep::release_should_stop_blob() {
7988 clear_has_should_stop_blob();
7989 if (should_stop_blob_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7990 return NULL;
7991 } else {
7992 ::std::string* temp = should_stop_blob_;
7993 should_stop_blob_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
7994 return temp;
7995 }
7996}
7997inline void ExecutionStep::set_allocated_should_stop_blob(::std::string* should_stop_blob) {
7998 if (should_stop_blob_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
7999 delete should_stop_blob_;
8000 }
8001 if (should_stop_blob) {
8002 set_has_should_stop_blob();
8003 should_stop_blob_ = should_stop_blob;
8004 } else {
8005 clear_has_should_stop_blob();
8006 should_stop_blob_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8007 }
8008 // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.should_stop_blob)
8009}
8010
8011// optional bool only_once = 10;
8012inline bool ExecutionStep::has_only_once() const {
8013 return (_has_bits_[0] & 0x00000400u) != 0;
8014}
8015inline void ExecutionStep::set_has_only_once() {
8016 _has_bits_[0] |= 0x00000400u;
8017}
8018inline void ExecutionStep::clear_has_only_once() {
8019 _has_bits_[0] &= ~0x00000400u;
8020}
8021inline void ExecutionStep::clear_only_once() {
8022 only_once_ = false;
8023 clear_has_only_once();
8024}
8025inline bool ExecutionStep::only_once() const {
8026 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.only_once)
8027 return only_once_;
8028}
8029inline void ExecutionStep::set_only_once(bool value) {
8030 set_has_only_once();
8031 only_once_ = value;
8032 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.only_once)
8033}
8034
8035// optional bool create_workspace = 12;
8036inline bool ExecutionStep::has_create_workspace() const {
8037 return (_has_bits_[0] & 0x00000800u) != 0;
8038}
8039inline void ExecutionStep::set_has_create_workspace() {
8040 _has_bits_[0] |= 0x00000800u;
8041}
8042inline void ExecutionStep::clear_has_create_workspace() {
8043 _has_bits_[0] &= ~0x00000800u;
8044}
8045inline void ExecutionStep::clear_create_workspace() {
8046 create_workspace_ = false;
8047 clear_has_create_workspace();
8048}
8049inline bool ExecutionStep::create_workspace() const {
8050 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.create_workspace)
8051 return create_workspace_;
8052}
8053inline void ExecutionStep::set_create_workspace(bool value) {
8054 set_has_create_workspace();
8055 create_workspace_ = value;
8056 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.create_workspace)
8057}
8058
8059// optional int32 num_concurrent_instances = 13;
8060inline bool ExecutionStep::has_num_concurrent_instances() const {
8061 return (_has_bits_[0] & 0x00001000u) != 0;
8062}
8063inline void ExecutionStep::set_has_num_concurrent_instances() {
8064 _has_bits_[0] |= 0x00001000u;
8065}
8066inline void ExecutionStep::clear_has_num_concurrent_instances() {
8067 _has_bits_[0] &= ~0x00001000u;
8068}
8069inline void ExecutionStep::clear_num_concurrent_instances() {
8070 num_concurrent_instances_ = 0;
8071 clear_has_num_concurrent_instances();
8072}
8073inline ::google::protobuf::int32 ExecutionStep::num_concurrent_instances() const {
8074 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.num_concurrent_instances)
8075 return num_concurrent_instances_;
8076}
8077inline void ExecutionStep::set_num_concurrent_instances(::google::protobuf::int32 value) {
8078 set_has_num_concurrent_instances();
8079 num_concurrent_instances_ = value;
8080 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.num_concurrent_instances)
8081}
8082
8083// -------------------------------------------------------------------
8084
8085// PlanDef
8086
8087// optional string name = 1;
8088inline bool PlanDef::has_name() const {
8089 return (_has_bits_[0] & 0x00000001u) != 0;
8090}
8091inline void PlanDef::set_has_name() {
8092 _has_bits_[0] |= 0x00000001u;
8093}
8094inline void PlanDef::clear_has_name() {
8095 _has_bits_[0] &= ~0x00000001u;
8096}
8097inline void PlanDef::clear_name() {
8098 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8099 name_->clear();
8100 }
8101 clear_has_name();
8102}
8103inline const ::std::string& PlanDef::name() const {
8104 // @@protoc_insertion_point(field_get:caffe2.PlanDef.name)
8105 return *name_;
8106}
8107inline void PlanDef::set_name(const ::std::string& value) {
8108 set_has_name();
8109 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8110 name_ = new ::std::string;
8111 }
8112 name_->assign(value);
8113 // @@protoc_insertion_point(field_set:caffe2.PlanDef.name)
8114}
8115inline void PlanDef::set_name(const char* value) {
8116 set_has_name();
8117 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8118 name_ = new ::std::string;
8119 }
8120 name_->assign(value);
8121 // @@protoc_insertion_point(field_set_char:caffe2.PlanDef.name)
8122}
8123inline void PlanDef::set_name(const char* value, size_t size) {
8124 set_has_name();
8125 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8126 name_ = new ::std::string;
8127 }
8128 name_->assign(reinterpret_cast<const char*>(value), size);
8129 // @@protoc_insertion_point(field_set_pointer:caffe2.PlanDef.name)
8130}
8131inline ::std::string* PlanDef::mutable_name() {
8132 set_has_name();
8133 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8134 name_ = new ::std::string;
8135 }
8136 // @@protoc_insertion_point(field_mutable:caffe2.PlanDef.name)
8137 return name_;
8138}
8139inline ::std::string* PlanDef::release_name() {
8140 clear_has_name();
8141 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8142 return NULL;
8143 } else {
8144 ::std::string* temp = name_;
8145 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8146 return temp;
8147 }
8148}
8149inline void PlanDef::set_allocated_name(::std::string* name) {
8150 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8151 delete name_;
8152 }
8153 if (name) {
8154 set_has_name();
8155 name_ = name;
8156 } else {
8157 clear_has_name();
8158 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8159 }
8160 // @@protoc_insertion_point(field_set_allocated:caffe2.PlanDef.name)
8161}
8162
8163// repeated .caffe2.NetDef network = 2;
8164inline int PlanDef::network_size() const {
8165 return network_.size();
8166}
8167inline void PlanDef::clear_network() {
8168 network_.Clear();
8169}
8170inline const ::caffe2::NetDef& PlanDef::network(int index) const {
8171 // @@protoc_insertion_point(field_get:caffe2.PlanDef.network)
8172 return network_.Get(index);
8173}
8174inline ::caffe2::NetDef* PlanDef::mutable_network(int index) {
8175 // @@protoc_insertion_point(field_mutable:caffe2.PlanDef.network)
8176 return network_.Mutable(index);
8177}
8178inline ::caffe2::NetDef* PlanDef::add_network() {
8179 // @@protoc_insertion_point(field_add:caffe2.PlanDef.network)
8180 return network_.Add();
8181}
8182inline const ::google::protobuf::RepeatedPtrField< ::caffe2::NetDef >&
8183PlanDef::network() const {
8184 // @@protoc_insertion_point(field_list:caffe2.PlanDef.network)
8185 return network_;
8186}
8187inline ::google::protobuf::RepeatedPtrField< ::caffe2::NetDef >*
8188PlanDef::mutable_network() {
8189 // @@protoc_insertion_point(field_mutable_list:caffe2.PlanDef.network)
8190 return &network_;
8191}
8192
8193// repeated .caffe2.ExecutionStep execution_step = 3;
8194inline int PlanDef::execution_step_size() const {
8195 return execution_step_.size();
8196}
8197inline void PlanDef::clear_execution_step() {
8198 execution_step_.Clear();
8199}
8200inline const ::caffe2::ExecutionStep& PlanDef::execution_step(int index) const {
8201 // @@protoc_insertion_point(field_get:caffe2.PlanDef.execution_step)
8202 return execution_step_.Get(index);
8203}
8204inline ::caffe2::ExecutionStep* PlanDef::mutable_execution_step(int index) {
8205 // @@protoc_insertion_point(field_mutable:caffe2.PlanDef.execution_step)
8206 return execution_step_.Mutable(index);
8207}
8208inline ::caffe2::ExecutionStep* PlanDef::add_execution_step() {
8209 // @@protoc_insertion_point(field_add:caffe2.PlanDef.execution_step)
8210 return execution_step_.Add();
8211}
8212inline const ::google::protobuf::RepeatedPtrField< ::caffe2::ExecutionStep >&
8213PlanDef::execution_step() const {
8214 // @@protoc_insertion_point(field_list:caffe2.PlanDef.execution_step)
8215 return execution_step_;
8216}
8217inline ::google::protobuf::RepeatedPtrField< ::caffe2::ExecutionStep >*
8218PlanDef::mutable_execution_step() {
8219 // @@protoc_insertion_point(field_mutable_list:caffe2.PlanDef.execution_step)
8220 return &execution_step_;
8221}
8222
8223// -------------------------------------------------------------------
8224
8225// BlobProto
8226
8227// optional string name = 1;
8228inline bool BlobProto::has_name() const {
8229 return (_has_bits_[0] & 0x00000001u) != 0;
8230}
8231inline void BlobProto::set_has_name() {
8232 _has_bits_[0] |= 0x00000001u;
8233}
8234inline void BlobProto::clear_has_name() {
8235 _has_bits_[0] &= ~0x00000001u;
8236}
8237inline void BlobProto::clear_name() {
8238 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8239 name_->clear();
8240 }
8241 clear_has_name();
8242}
8243inline const ::std::string& BlobProto::name() const {
8244 // @@protoc_insertion_point(field_get:caffe2.BlobProto.name)
8245 return *name_;
8246}
8247inline void BlobProto::set_name(const ::std::string& value) {
8248 set_has_name();
8249 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8250 name_ = new ::std::string;
8251 }
8252 name_->assign(value);
8253 // @@protoc_insertion_point(field_set:caffe2.BlobProto.name)
8254}
8255inline void BlobProto::set_name(const char* value) {
8256 set_has_name();
8257 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8258 name_ = new ::std::string;
8259 }
8260 name_->assign(value);
8261 // @@protoc_insertion_point(field_set_char:caffe2.BlobProto.name)
8262}
8263inline void BlobProto::set_name(const char* value, size_t size) {
8264 set_has_name();
8265 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8266 name_ = new ::std::string;
8267 }
8268 name_->assign(reinterpret_cast<const char*>(value), size);
8269 // @@protoc_insertion_point(field_set_pointer:caffe2.BlobProto.name)
8270}
8271inline ::std::string* BlobProto::mutable_name() {
8272 set_has_name();
8273 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8274 name_ = new ::std::string;
8275 }
8276 // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.name)
8277 return name_;
8278}
8279inline ::std::string* BlobProto::release_name() {
8280 clear_has_name();
8281 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8282 return NULL;
8283 } else {
8284 ::std::string* temp = name_;
8285 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8286 return temp;
8287 }
8288}
8289inline void BlobProto::set_allocated_name(::std::string* name) {
8290 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8291 delete name_;
8292 }
8293 if (name) {
8294 set_has_name();
8295 name_ = name;
8296 } else {
8297 clear_has_name();
8298 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8299 }
8300 // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.name)
8301}
8302
8303// optional string type = 2;
8304inline bool BlobProto::has_type() const {
8305 return (_has_bits_[0] & 0x00000002u) != 0;
8306}
8307inline void BlobProto::set_has_type() {
8308 _has_bits_[0] |= 0x00000002u;
8309}
8310inline void BlobProto::clear_has_type() {
8311 _has_bits_[0] &= ~0x00000002u;
8312}
8313inline void BlobProto::clear_type() {
8314 if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8315 type_->clear();
8316 }
8317 clear_has_type();
8318}
8319inline const ::std::string& BlobProto::type() const {
8320 // @@protoc_insertion_point(field_get:caffe2.BlobProto.type)
8321 return *type_;
8322}
8323inline void BlobProto::set_type(const ::std::string& value) {
8324 set_has_type();
8325 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8326 type_ = new ::std::string;
8327 }
8328 type_->assign(value);
8329 // @@protoc_insertion_point(field_set:caffe2.BlobProto.type)
8330}
8331inline void BlobProto::set_type(const char* value) {
8332 set_has_type();
8333 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8334 type_ = new ::std::string;
8335 }
8336 type_->assign(value);
8337 // @@protoc_insertion_point(field_set_char:caffe2.BlobProto.type)
8338}
8339inline void BlobProto::set_type(const char* value, size_t size) {
8340 set_has_type();
8341 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8342 type_ = new ::std::string;
8343 }
8344 type_->assign(reinterpret_cast<const char*>(value), size);
8345 // @@protoc_insertion_point(field_set_pointer:caffe2.BlobProto.type)
8346}
8347inline ::std::string* BlobProto::mutable_type() {
8348 set_has_type();
8349 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8350 type_ = new ::std::string;
8351 }
8352 // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.type)
8353 return type_;
8354}
8355inline ::std::string* BlobProto::release_type() {
8356 clear_has_type();
8357 if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8358 return NULL;
8359 } else {
8360 ::std::string* temp = type_;
8361 type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8362 return temp;
8363 }
8364}
8365inline void BlobProto::set_allocated_type(::std::string* type) {
8366 if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8367 delete type_;
8368 }
8369 if (type) {
8370 set_has_type();
8371 type_ = type;
8372 } else {
8373 clear_has_type();
8374 type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8375 }
8376 // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.type)
8377}
8378
8379// optional .caffe2.TensorProto tensor = 3;
8380inline bool BlobProto::has_tensor() const {
8381 return (_has_bits_[0] & 0x00000004u) != 0;
8382}
8383inline void BlobProto::set_has_tensor() {
8384 _has_bits_[0] |= 0x00000004u;
8385}
8386inline void BlobProto::clear_has_tensor() {
8387 _has_bits_[0] &= ~0x00000004u;
8388}
8389inline void BlobProto::clear_tensor() {
8390 if (tensor_ != NULL) tensor_->::caffe2::TensorProto::Clear();
8391 clear_has_tensor();
8392}
8393inline const ::caffe2::TensorProto& BlobProto::tensor() const {
8394 // @@protoc_insertion_point(field_get:caffe2.BlobProto.tensor)
8395 return tensor_ != NULL ? *tensor_ : *default_instance_->tensor_;
8396}
8397inline ::caffe2::TensorProto* BlobProto::mutable_tensor() {
8398 set_has_tensor();
8399 if (tensor_ == NULL) tensor_ = new ::caffe2::TensorProto;
8400 // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.tensor)
8401 return tensor_;
8402}
8403inline ::caffe2::TensorProto* BlobProto::release_tensor() {
8404 clear_has_tensor();
8405 ::caffe2::TensorProto* temp = tensor_;
8406 tensor_ = NULL;
8407 return temp;
8408}
8409inline void BlobProto::set_allocated_tensor(::caffe2::TensorProto* tensor) {
8410 delete tensor_;
8411 tensor_ = tensor;
8412 if (tensor) {
8413 set_has_tensor();
8414 } else {
8415 clear_has_tensor();
8416 }
8417 // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.tensor)
8418}
8419
8420// optional bytes content = 4;
8421inline bool BlobProto::has_content() const {
8422 return (_has_bits_[0] & 0x00000008u) != 0;
8423}
8424inline void BlobProto::set_has_content() {
8425 _has_bits_[0] |= 0x00000008u;
8426}
8427inline void BlobProto::clear_has_content() {
8428 _has_bits_[0] &= ~0x00000008u;
8429}
8430inline void BlobProto::clear_content() {
8431 if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8432 content_->clear();
8433 }
8434 clear_has_content();
8435}
8436inline const ::std::string& BlobProto::content() const {
8437 // @@protoc_insertion_point(field_get:caffe2.BlobProto.content)
8438 return *content_;
8439}
8440inline void BlobProto::set_content(const ::std::string& value) {
8441 set_has_content();
8442 if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8443 content_ = new ::std::string;
8444 }
8445 content_->assign(value);
8446 // @@protoc_insertion_point(field_set:caffe2.BlobProto.content)
8447}
8448inline void BlobProto::set_content(const char* value) {
8449 set_has_content();
8450 if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8451 content_ = new ::std::string;
8452 }
8453 content_->assign(value);
8454 // @@protoc_insertion_point(field_set_char:caffe2.BlobProto.content)
8455}
8456inline void BlobProto::set_content(const void* value, size_t size) {
8457 set_has_content();
8458 if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8459 content_ = new ::std::string;
8460 }
8461 content_->assign(reinterpret_cast<const char*>(value), size);
8462 // @@protoc_insertion_point(field_set_pointer:caffe2.BlobProto.content)
8463}
8464inline ::std::string* BlobProto::mutable_content() {
8465 set_has_content();
8466 if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8467 content_ = new ::std::string;
8468 }
8469 // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.content)
8470 return content_;
8471}
8472inline ::std::string* BlobProto::release_content() {
8473 clear_has_content();
8474 if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8475 return NULL;
8476 } else {
8477 ::std::string* temp = content_;
8478 content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8479 return temp;
8480 }
8481}
8482inline void BlobProto::set_allocated_content(::std::string* content) {
8483 if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8484 delete content_;
8485 }
8486 if (content) {
8487 set_has_content();
8488 content_ = content;
8489 } else {
8490 clear_has_content();
8491 content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8492 }
8493 // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.content)
8494}
8495
8496// optional .caffe2.QTensorProto qtensor = 5;
8497inline bool BlobProto::has_qtensor() const {
8498 return (_has_bits_[0] & 0x00000010u) != 0;
8499}
8500inline void BlobProto::set_has_qtensor() {
8501 _has_bits_[0] |= 0x00000010u;
8502}
8503inline void BlobProto::clear_has_qtensor() {
8504 _has_bits_[0] &= ~0x00000010u;
8505}
8506inline void BlobProto::clear_qtensor() {
8507 if (qtensor_ != NULL) qtensor_->::caffe2::QTensorProto::Clear();
8508 clear_has_qtensor();
8509}
8510inline const ::caffe2::QTensorProto& BlobProto::qtensor() const {
8511 // @@protoc_insertion_point(field_get:caffe2.BlobProto.qtensor)
8512 return qtensor_ != NULL ? *qtensor_ : *default_instance_->qtensor_;
8513}
8514inline ::caffe2::QTensorProto* BlobProto::mutable_qtensor() {
8515 set_has_qtensor();
8516 if (qtensor_ == NULL) qtensor_ = new ::caffe2::QTensorProto;
8517 // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.qtensor)
8518 return qtensor_;
8519}
8520inline ::caffe2::QTensorProto* BlobProto::release_qtensor() {
8521 clear_has_qtensor();
8522 ::caffe2::QTensorProto* temp = qtensor_;
8523 qtensor_ = NULL;
8524 return temp;
8525}
8526inline void BlobProto::set_allocated_qtensor(::caffe2::QTensorProto* qtensor) {
8527 delete qtensor_;
8528 qtensor_ = qtensor;
8529 if (qtensor) {
8530 set_has_qtensor();
8531 } else {
8532 clear_has_qtensor();
8533 }
8534 // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.qtensor)
8535}
8536
8537// optional int32 content_num_chunks = 6;
8538inline bool BlobProto::has_content_num_chunks() const {
8539 return (_has_bits_[0] & 0x00000020u) != 0;
8540}
8541inline void BlobProto::set_has_content_num_chunks() {
8542 _has_bits_[0] |= 0x00000020u;
8543}
8544inline void BlobProto::clear_has_content_num_chunks() {
8545 _has_bits_[0] &= ~0x00000020u;
8546}
8547inline void BlobProto::clear_content_num_chunks() {
8548 content_num_chunks_ = 0;
8549 clear_has_content_num_chunks();
8550}
8551inline ::google::protobuf::int32 BlobProto::content_num_chunks() const {
8552 // @@protoc_insertion_point(field_get:caffe2.BlobProto.content_num_chunks)
8553 return content_num_chunks_;
8554}
8555inline void BlobProto::set_content_num_chunks(::google::protobuf::int32 value) {
8556 set_has_content_num_chunks();
8557 content_num_chunks_ = value;
8558 // @@protoc_insertion_point(field_set:caffe2.BlobProto.content_num_chunks)
8559}
8560
8561// optional int32 content_chunk_id = 7;
8562inline bool BlobProto::has_content_chunk_id() const {
8563 return (_has_bits_[0] & 0x00000040u) != 0;
8564}
8565inline void BlobProto::set_has_content_chunk_id() {
8566 _has_bits_[0] |= 0x00000040u;
8567}
8568inline void BlobProto::clear_has_content_chunk_id() {
8569 _has_bits_[0] &= ~0x00000040u;
8570}
8571inline void BlobProto::clear_content_chunk_id() {
8572 content_chunk_id_ = 0;
8573 clear_has_content_chunk_id();
8574}
8575inline ::google::protobuf::int32 BlobProto::content_chunk_id() const {
8576 // @@protoc_insertion_point(field_get:caffe2.BlobProto.content_chunk_id)
8577 return content_chunk_id_;
8578}
8579inline void BlobProto::set_content_chunk_id(::google::protobuf::int32 value) {
8580 set_has_content_chunk_id();
8581 content_chunk_id_ = value;
8582 // @@protoc_insertion_point(field_set:caffe2.BlobProto.content_chunk_id)
8583}
8584
8585// -------------------------------------------------------------------
8586
8587// DBReaderProto
8588
8589// optional string name = 1;
8590inline bool DBReaderProto::has_name() const {
8591 return (_has_bits_[0] & 0x00000001u) != 0;
8592}
8593inline void DBReaderProto::set_has_name() {
8594 _has_bits_[0] |= 0x00000001u;
8595}
8596inline void DBReaderProto::clear_has_name() {
8597 _has_bits_[0] &= ~0x00000001u;
8598}
8599inline void DBReaderProto::clear_name() {
8600 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8601 name_->clear();
8602 }
8603 clear_has_name();
8604}
8605inline const ::std::string& DBReaderProto::name() const {
8606 // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.name)
8607 return *name_;
8608}
8609inline void DBReaderProto::set_name(const ::std::string& value) {
8610 set_has_name();
8611 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8612 name_ = new ::std::string;
8613 }
8614 name_->assign(value);
8615 // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.name)
8616}
8617inline void DBReaderProto::set_name(const char* value) {
8618 set_has_name();
8619 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8620 name_ = new ::std::string;
8621 }
8622 name_->assign(value);
8623 // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.name)
8624}
8625inline void DBReaderProto::set_name(const char* value, size_t size) {
8626 set_has_name();
8627 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8628 name_ = new ::std::string;
8629 }
8630 name_->assign(reinterpret_cast<const char*>(value), size);
8631 // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.name)
8632}
8633inline ::std::string* DBReaderProto::mutable_name() {
8634 set_has_name();
8635 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8636 name_ = new ::std::string;
8637 }
8638 // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.name)
8639 return name_;
8640}
8641inline ::std::string* DBReaderProto::release_name() {
8642 clear_has_name();
8643 if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8644 return NULL;
8645 } else {
8646 ::std::string* temp = name_;
8647 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8648 return temp;
8649 }
8650}
8651inline void DBReaderProto::set_allocated_name(::std::string* name) {
8652 if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8653 delete name_;
8654 }
8655 if (name) {
8656 set_has_name();
8657 name_ = name;
8658 } else {
8659 clear_has_name();
8660 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8661 }
8662 // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.name)
8663}
8664
8665// optional string source = 2;
8666inline bool DBReaderProto::has_source() const {
8667 return (_has_bits_[0] & 0x00000002u) != 0;
8668}
8669inline void DBReaderProto::set_has_source() {
8670 _has_bits_[0] |= 0x00000002u;
8671}
8672inline void DBReaderProto::clear_has_source() {
8673 _has_bits_[0] &= ~0x00000002u;
8674}
8675inline void DBReaderProto::clear_source() {
8676 if (source_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8677 source_->clear();
8678 }
8679 clear_has_source();
8680}
8681inline const ::std::string& DBReaderProto::source() const {
8682 // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.source)
8683 return *source_;
8684}
8685inline void DBReaderProto::set_source(const ::std::string& value) {
8686 set_has_source();
8687 if (source_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8688 source_ = new ::std::string;
8689 }
8690 source_->assign(value);
8691 // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.source)
8692}
8693inline void DBReaderProto::set_source(const char* value) {
8694 set_has_source();
8695 if (source_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8696 source_ = new ::std::string;
8697 }
8698 source_->assign(value);
8699 // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.source)
8700}
8701inline void DBReaderProto::set_source(const char* value, size_t size) {
8702 set_has_source();
8703 if (source_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8704 source_ = new ::std::string;
8705 }
8706 source_->assign(reinterpret_cast<const char*>(value), size);
8707 // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.source)
8708}
8709inline ::std::string* DBReaderProto::mutable_source() {
8710 set_has_source();
8711 if (source_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8712 source_ = new ::std::string;
8713 }
8714 // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.source)
8715 return source_;
8716}
8717inline ::std::string* DBReaderProto::release_source() {
8718 clear_has_source();
8719 if (source_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8720 return NULL;
8721 } else {
8722 ::std::string* temp = source_;
8723 source_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8724 return temp;
8725 }
8726}
8727inline void DBReaderProto::set_allocated_source(::std::string* source) {
8728 if (source_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8729 delete source_;
8730 }
8731 if (source) {
8732 set_has_source();
8733 source_ = source;
8734 } else {
8735 clear_has_source();
8736 source_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8737 }
8738 // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.source)
8739}
8740
8741// optional string db_type = 3;
8742inline bool DBReaderProto::has_db_type() const {
8743 return (_has_bits_[0] & 0x00000004u) != 0;
8744}
8745inline void DBReaderProto::set_has_db_type() {
8746 _has_bits_[0] |= 0x00000004u;
8747}
8748inline void DBReaderProto::clear_has_db_type() {
8749 _has_bits_[0] &= ~0x00000004u;
8750}
8751inline void DBReaderProto::clear_db_type() {
8752 if (db_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8753 db_type_->clear();
8754 }
8755 clear_has_db_type();
8756}
8757inline const ::std::string& DBReaderProto::db_type() const {
8758 // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.db_type)
8759 return *db_type_;
8760}
8761inline void DBReaderProto::set_db_type(const ::std::string& value) {
8762 set_has_db_type();
8763 if (db_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8764 db_type_ = new ::std::string;
8765 }
8766 db_type_->assign(value);
8767 // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.db_type)
8768}
8769inline void DBReaderProto::set_db_type(const char* value) {
8770 set_has_db_type();
8771 if (db_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8772 db_type_ = new ::std::string;
8773 }
8774 db_type_->assign(value);
8775 // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.db_type)
8776}
8777inline void DBReaderProto::set_db_type(const char* value, size_t size) {
8778 set_has_db_type();
8779 if (db_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8780 db_type_ = new ::std::string;
8781 }
8782 db_type_->assign(reinterpret_cast<const char*>(value), size);
8783 // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.db_type)
8784}
8785inline ::std::string* DBReaderProto::mutable_db_type() {
8786 set_has_db_type();
8787 if (db_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8788 db_type_ = new ::std::string;
8789 }
8790 // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.db_type)
8791 return db_type_;
8792}
8793inline ::std::string* DBReaderProto::release_db_type() {
8794 clear_has_db_type();
8795 if (db_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8796 return NULL;
8797 } else {
8798 ::std::string* temp = db_type_;
8799 db_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8800 return temp;
8801 }
8802}
8803inline void DBReaderProto::set_allocated_db_type(::std::string* db_type) {
8804 if (db_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8805 delete db_type_;
8806 }
8807 if (db_type) {
8808 set_has_db_type();
8809 db_type_ = db_type;
8810 } else {
8811 clear_has_db_type();
8812 db_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8813 }
8814 // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.db_type)
8815}
8816
8817// optional string key = 4;
8818inline bool DBReaderProto::has_key() const {
8819 return (_has_bits_[0] & 0x00000008u) != 0;
8820}
8821inline void DBReaderProto::set_has_key() {
8822 _has_bits_[0] |= 0x00000008u;
8823}
8824inline void DBReaderProto::clear_has_key() {
8825 _has_bits_[0] &= ~0x00000008u;
8826}
8827inline void DBReaderProto::clear_key() {
8828 if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8829 key_->clear();
8830 }
8831 clear_has_key();
8832}
8833inline const ::std::string& DBReaderProto::key() const {
8834 // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.key)
8835 return *key_;
8836}
8837inline void DBReaderProto::set_key(const ::std::string& value) {
8838 set_has_key();
8839 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8840 key_ = new ::std::string;
8841 }
8842 key_->assign(value);
8843 // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.key)
8844}
8845inline void DBReaderProto::set_key(const char* value) {
8846 set_has_key();
8847 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8848 key_ = new ::std::string;
8849 }
8850 key_->assign(value);
8851 // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.key)
8852}
8853inline void DBReaderProto::set_key(const char* value, size_t size) {
8854 set_has_key();
8855 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8856 key_ = new ::std::string;
8857 }
8858 key_->assign(reinterpret_cast<const char*>(value), size);
8859 // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.key)
8860}
8861inline ::std::string* DBReaderProto::mutable_key() {
8862 set_has_key();
8863 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8864 key_ = new ::std::string;
8865 }
8866 // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.key)
8867 return key_;
8868}
8869inline ::std::string* DBReaderProto::release_key() {
8870 clear_has_key();
8871 if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8872 return NULL;
8873 } else {
8874 ::std::string* temp = key_;
8875 key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8876 return temp;
8877 }
8878}
8879inline void DBReaderProto::set_allocated_key(::std::string* key) {
8880 if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
8881 delete key_;
8882 }
8883 if (key) {
8884 set_has_key();
8885 key_ = key;
8886 } else {
8887 clear_has_key();
8888 key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
8889 }
8890 // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.key)
8891}
8892
8893
8894// @@protoc_insertion_point(namespace_scope)
8895
8896} // namespace caffe2
8897
8898#ifndef SWIG
8899namespace google {
8900namespace protobuf {
8901
8902template <> struct is_proto_enum< ::caffe2::ExternalDataProto_SourceType> : ::google::protobuf::internal::true_type {};
8903template <>
8904inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::ExternalDataProto_SourceType>() {
8905 return ::caffe2::ExternalDataProto_SourceType_descriptor();
8906}
8907template <> struct is_proto_enum< ::caffe2::TensorProto_DataType> : ::google::protobuf::internal::true_type {};
8908template <>
8909inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::TensorProto_DataType>() {
8910 return ::caffe2::TensorProto_DataType_descriptor();
8911}
8912template <> struct is_proto_enum< ::caffe2::TensorProto_StorageType> : ::google::protobuf::internal::true_type {};
8913template <>
8914inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::TensorProto_StorageType>() {
8915 return ::caffe2::TensorProto_StorageType_descriptor();
8916}
8917template <> struct is_proto_enum< ::caffe2::TensorBoundShape_DimType> : ::google::protobuf::internal::true_type {};
8918template <>
8919inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::TensorBoundShape_DimType>() {
8920 return ::caffe2::TensorBoundShape_DimType_descriptor();
8921}
8922template <> struct is_proto_enum< ::caffe2::DeviceTypeProto> : ::google::protobuf::internal::true_type {};
8923template <>
8924inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::DeviceTypeProto>() {
8925 return ::caffe2::DeviceTypeProto_descriptor();
8926}
8927
8928} // namespace google
8929} // namespace protobuf
8930#endif // SWIG
8931
8932// @@protoc_insertion_point(global_scope)
8933
8934#endif // PROTOBUF_caffe2_2eproto__INCLUDED
8935