1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: caffe2/proto/caffe2.proto
3
4#ifndef GOOGLE_PROTOBUF_INCLUDED_caffe2_2fproto_2fcaffe2_2eproto
5#define GOOGLE_PROTOBUF_INCLUDED_caffe2_2fproto_2fcaffe2_2eproto
6
7#include <limits>
8#include <string>
9
10#include <google/protobuf/port_def.inc>
11#if PROTOBUF_VERSION < 3013000
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 3013000 < 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/port_undef.inc>
23#include <google/protobuf/io/coded_stream.h>
24#include <google/protobuf/arena.h>
25#include <google/protobuf/arenastring.h>
26#include <google/protobuf/generated_message_table_driven.h>
27#include <google/protobuf/generated_message_util.h>
28#include <google/protobuf/inlined_string_field.h>
29#include <google/protobuf/metadata_lite.h>
30#include <google/protobuf/generated_message_reflection.h>
31#include <google/protobuf/message.h>
32#include <google/protobuf/repeated_field.h> // IWYU pragma: export
33#include <google/protobuf/extension_set.h> // IWYU pragma: export
34#include <google/protobuf/generated_enum_reflection.h>
35#include <google/protobuf/unknown_field_set.h>
36// @@protoc_insertion_point(includes)
37#include <google/protobuf/port_def.inc>
38#define PROTOBUF_INTERNAL_EXPORT_caffe2_2fproto_2fcaffe2_2eproto TORCH_API
39PROTOBUF_NAMESPACE_OPEN
40namespace internal {
41class AnyMetadata;
42} // namespace internal
43PROTOBUF_NAMESPACE_CLOSE
44
45// Internal implementation detail -- do not use these members.
46struct TORCH_API TableStruct_caffe2_2fproto_2fcaffe2_2eproto {
47 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
48 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
49 static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
50 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
51 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[22]
52 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
53 static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
54 static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
55 static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
56};
57extern TORCH_API const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_caffe2_2fproto_2fcaffe2_2eproto;
58namespace caffe2 { const ::std::string& GetEmptyStringAlreadyInited();
59class AOTConfig;
60class AOTConfigDefaultTypeInternal;
61TORCH_API extern AOTConfigDefaultTypeInternal _AOTConfig_default_instance_;
62class Argument;
63class ArgumentDefaultTypeInternal;
64TORCH_API extern ArgumentDefaultTypeInternal _Argument_default_instance_;
65class BackendOptions;
66class BackendOptionsDefaultTypeInternal;
67TORCH_API extern BackendOptionsDefaultTypeInternal _BackendOptions_default_instance_;
68class BlobProto;
69class BlobProtoDefaultTypeInternal;
70TORCH_API extern BlobProtoDefaultTypeInternal _BlobProto_default_instance_;
71class BlobSerializationOptions;
72class BlobSerializationOptionsDefaultTypeInternal;
73TORCH_API extern BlobSerializationOptionsDefaultTypeInternal _BlobSerializationOptions_default_instance_;
74class DBReaderProto;
75class DBReaderProtoDefaultTypeInternal;
76TORCH_API extern DBReaderProtoDefaultTypeInternal _DBReaderProto_default_instance_;
77class DeviceOption;
78class DeviceOptionDefaultTypeInternal;
79TORCH_API extern DeviceOptionDefaultTypeInternal _DeviceOption_default_instance_;
80class ExecutionStep;
81class ExecutionStepDefaultTypeInternal;
82TORCH_API extern ExecutionStepDefaultTypeInternal _ExecutionStep_default_instance_;
83class MapFieldEntry;
84class MapFieldEntryDefaultTypeInternal;
85TORCH_API extern MapFieldEntryDefaultTypeInternal _MapFieldEntry_default_instance_;
86class NetDef;
87class NetDefDefaultTypeInternal;
88TORCH_API extern NetDefDefaultTypeInternal _NetDef_default_instance_;
89class OperatorDef;
90class OperatorDefDefaultTypeInternal;
91TORCH_API extern OperatorDefDefaultTypeInternal _OperatorDef_default_instance_;
92class PartitionInfo;
93class PartitionInfoDefaultTypeInternal;
94TORCH_API extern PartitionInfoDefaultTypeInternal _PartitionInfo_default_instance_;
95class PlanDef;
96class PlanDefDefaultTypeInternal;
97TORCH_API extern PlanDefDefaultTypeInternal _PlanDef_default_instance_;
98class QTensorProto;
99class QTensorProtoDefaultTypeInternal;
100TORCH_API extern QTensorProtoDefaultTypeInternal _QTensorProto_default_instance_;
101class SerializationOptions;
102class SerializationOptionsDefaultTypeInternal;
103TORCH_API extern SerializationOptionsDefaultTypeInternal _SerializationOptions_default_instance_;
104class TensorBoundShape;
105class TensorBoundShapeDefaultTypeInternal;
106TORCH_API extern TensorBoundShapeDefaultTypeInternal _TensorBoundShape_default_instance_;
107class TensorBoundShapes;
108class TensorBoundShapesDefaultTypeInternal;
109TORCH_API extern TensorBoundShapesDefaultTypeInternal _TensorBoundShapes_default_instance_;
110class TensorProto;
111class TensorProtoDefaultTypeInternal;
112TORCH_API extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
113class TensorProto_Segment;
114class TensorProto_SegmentDefaultTypeInternal;
115TORCH_API extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_;
116class TensorProtos;
117class TensorProtosDefaultTypeInternal;
118TORCH_API extern TensorProtosDefaultTypeInternal _TensorProtos_default_instance_;
119class TensorShape;
120class TensorShapeDefaultTypeInternal;
121TORCH_API extern TensorShapeDefaultTypeInternal _TensorShape_default_instance_;
122class TensorShapes;
123class TensorShapesDefaultTypeInternal;
124TORCH_API extern TensorShapesDefaultTypeInternal _TensorShapes_default_instance_;
125} // namespace caffe2
126PROTOBUF_NAMESPACE_OPEN
127template<> TORCH_API ::caffe2::AOTConfig* Arena::CreateMaybeMessage<::caffe2::AOTConfig>(Arena*);
128template<> TORCH_API ::caffe2::Argument* Arena::CreateMaybeMessage<::caffe2::Argument>(Arena*);
129template<> TORCH_API ::caffe2::BackendOptions* Arena::CreateMaybeMessage<::caffe2::BackendOptions>(Arena*);
130template<> TORCH_API ::caffe2::BlobProto* Arena::CreateMaybeMessage<::caffe2::BlobProto>(Arena*);
131template<> TORCH_API ::caffe2::BlobSerializationOptions* Arena::CreateMaybeMessage<::caffe2::BlobSerializationOptions>(Arena*);
132template<> TORCH_API ::caffe2::DBReaderProto* Arena::CreateMaybeMessage<::caffe2::DBReaderProto>(Arena*);
133template<> TORCH_API ::caffe2::DeviceOption* Arena::CreateMaybeMessage<::caffe2::DeviceOption>(Arena*);
134template<> TORCH_API ::caffe2::ExecutionStep* Arena::CreateMaybeMessage<::caffe2::ExecutionStep>(Arena*);
135template<> TORCH_API ::caffe2::MapFieldEntry* Arena::CreateMaybeMessage<::caffe2::MapFieldEntry>(Arena*);
136template<> TORCH_API ::caffe2::NetDef* Arena::CreateMaybeMessage<::caffe2::NetDef>(Arena*);
137template<> TORCH_API ::caffe2::OperatorDef* Arena::CreateMaybeMessage<::caffe2::OperatorDef>(Arena*);
138template<> TORCH_API ::caffe2::PartitionInfo* Arena::CreateMaybeMessage<::caffe2::PartitionInfo>(Arena*);
139template<> TORCH_API ::caffe2::PlanDef* Arena::CreateMaybeMessage<::caffe2::PlanDef>(Arena*);
140template<> TORCH_API ::caffe2::QTensorProto* Arena::CreateMaybeMessage<::caffe2::QTensorProto>(Arena*);
141template<> TORCH_API ::caffe2::SerializationOptions* Arena::CreateMaybeMessage<::caffe2::SerializationOptions>(Arena*);
142template<> TORCH_API ::caffe2::TensorBoundShape* Arena::CreateMaybeMessage<::caffe2::TensorBoundShape>(Arena*);
143template<> TORCH_API ::caffe2::TensorBoundShapes* Arena::CreateMaybeMessage<::caffe2::TensorBoundShapes>(Arena*);
144template<> TORCH_API ::caffe2::TensorProto* Arena::CreateMaybeMessage<::caffe2::TensorProto>(Arena*);
145template<> TORCH_API ::caffe2::TensorProto_Segment* Arena::CreateMaybeMessage<::caffe2::TensorProto_Segment>(Arena*);
146template<> TORCH_API ::caffe2::TensorProtos* Arena::CreateMaybeMessage<::caffe2::TensorProtos>(Arena*);
147template<> TORCH_API ::caffe2::TensorShape* Arena::CreateMaybeMessage<::caffe2::TensorShape>(Arena*);
148template<> TORCH_API ::caffe2::TensorShapes* Arena::CreateMaybeMessage<::caffe2::TensorShapes>(Arena*);
149PROTOBUF_NAMESPACE_CLOSE
150namespace caffe2 {
151
152enum TensorProto_DataType : int {
153 TensorProto_DataType_UNDEFINED = 0,
154 TensorProto_DataType_FLOAT = 1,
155 TensorProto_DataType_INT32 = 2,
156 TensorProto_DataType_BYTE = 3,
157 TensorProto_DataType_STRING = 4,
158 TensorProto_DataType_BOOL = 5,
159 TensorProto_DataType_UINT8 = 6,
160 TensorProto_DataType_INT8 = 7,
161 TensorProto_DataType_UINT16 = 8,
162 TensorProto_DataType_INT16 = 9,
163 TensorProto_DataType_INT64 = 10,
164 TensorProto_DataType_FLOAT16 = 12,
165 TensorProto_DataType_DOUBLE = 13,
166 TensorProto_DataType_ZERO_COLLISION_HASH = 14,
167 TensorProto_DataType_REBATCHING_BUFFER = 15
168};
169TORCH_API bool TensorProto_DataType_IsValid(int value);
170constexpr TensorProto_DataType TensorProto_DataType_DataType_MIN = TensorProto_DataType_UNDEFINED;
171constexpr TensorProto_DataType TensorProto_DataType_DataType_MAX = TensorProto_DataType_REBATCHING_BUFFER;
172constexpr int TensorProto_DataType_DataType_ARRAYSIZE = static_cast<int>(TensorProto_DataType_DataType_MAX) + 1;
173
174TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TensorProto_DataType_descriptor();
175template<typename T>
176inline const std::string& TensorProto_DataType_Name(T enum_t_value) {
177 static_assert(::std::is_same<T, TensorProto_DataType>::value ||
178 ::std::is_integral<T>::value,
179 "Incorrect type passed to function TensorProto_DataType_Name.");
180 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
181 TensorProto_DataType_descriptor(), enum_t_value);
182}
183inline bool TensorProto_DataType_Parse(
184 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TensorProto_DataType* value) {
185 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TensorProto_DataType>(
186 TensorProto_DataType_descriptor(), name, value);
187}
188enum TensorProto_SerializationFormat : int {
189 TensorProto_SerializationFormat_FMT_PROTOBUF = 0,
190 TensorProto_SerializationFormat_FMT_BFLOAT16 = 1
191};
192TORCH_API bool TensorProto_SerializationFormat_IsValid(int value);
193constexpr TensorProto_SerializationFormat TensorProto_SerializationFormat_SerializationFormat_MIN = TensorProto_SerializationFormat_FMT_PROTOBUF;
194constexpr TensorProto_SerializationFormat TensorProto_SerializationFormat_SerializationFormat_MAX = TensorProto_SerializationFormat_FMT_BFLOAT16;
195constexpr int TensorProto_SerializationFormat_SerializationFormat_ARRAYSIZE = static_cast<int>(TensorProto_SerializationFormat_SerializationFormat_MAX) + 1;
196
197TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TensorProto_SerializationFormat_descriptor();
198template<typename T>
199inline const std::string& TensorProto_SerializationFormat_Name(T enum_t_value) {
200 static_assert(::std::is_same<T, TensorProto_SerializationFormat>::value ||
201 ::std::is_integral<T>::value,
202 "Incorrect type passed to function TensorProto_SerializationFormat_Name.");
203 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
204 TensorProto_SerializationFormat_descriptor(), enum_t_value);
205}
206inline bool TensorProto_SerializationFormat_Parse(
207 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TensorProto_SerializationFormat* value) {
208 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TensorProto_SerializationFormat>(
209 TensorProto_SerializationFormat_descriptor(), name, value);
210}
211enum TensorBoundShape_DimType : int {
212 TensorBoundShape_DimType_UNKNOWN = 0,
213 TensorBoundShape_DimType_CONSTANT = 1,
214 TensorBoundShape_DimType_BATCH = 2,
215 TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX = 3,
216 TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX_DEFAULT = 4,
217 TensorBoundShape_DimType_FEATURE_MAX = 5,
218 TensorBoundShape_DimType_FEATURE_MAX_DEFAULT = 6
219};
220TORCH_API bool TensorBoundShape_DimType_IsValid(int value);
221constexpr TensorBoundShape_DimType TensorBoundShape_DimType_DimType_MIN = TensorBoundShape_DimType_UNKNOWN;
222constexpr TensorBoundShape_DimType TensorBoundShape_DimType_DimType_MAX = TensorBoundShape_DimType_FEATURE_MAX_DEFAULT;
223constexpr int TensorBoundShape_DimType_DimType_ARRAYSIZE = static_cast<int>(TensorBoundShape_DimType_DimType_MAX) + 1;
224
225TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TensorBoundShape_DimType_descriptor();
226template<typename T>
227inline const std::string& TensorBoundShape_DimType_Name(T enum_t_value) {
228 static_assert(::std::is_same<T, TensorBoundShape_DimType>::value ||
229 ::std::is_integral<T>::value,
230 "Incorrect type passed to function TensorBoundShape_DimType_Name.");
231 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
232 TensorBoundShape_DimType_descriptor(), enum_t_value);
233}
234inline bool TensorBoundShape_DimType_Parse(
235 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TensorBoundShape_DimType* value) {
236 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TensorBoundShape_DimType>(
237 TensorBoundShape_DimType_descriptor(), name, value);
238}
239enum BlobSerializationOptions_FloatFormat : int {
240 BlobSerializationOptions_FloatFormat_FLOAT_DEFAULT = 0,
241 BlobSerializationOptions_FloatFormat_FLOAT_PROTOBUF = 1,
242 BlobSerializationOptions_FloatFormat_FLOAT_BFLOAT16 = 2
243};
244TORCH_API bool BlobSerializationOptions_FloatFormat_IsValid(int value);
245constexpr BlobSerializationOptions_FloatFormat BlobSerializationOptions_FloatFormat_FloatFormat_MIN = BlobSerializationOptions_FloatFormat_FLOAT_DEFAULT;
246constexpr BlobSerializationOptions_FloatFormat BlobSerializationOptions_FloatFormat_FloatFormat_MAX = BlobSerializationOptions_FloatFormat_FLOAT_BFLOAT16;
247constexpr int BlobSerializationOptions_FloatFormat_FloatFormat_ARRAYSIZE = static_cast<int>(BlobSerializationOptions_FloatFormat_FloatFormat_MAX) + 1;
248
249TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BlobSerializationOptions_FloatFormat_descriptor();
250template<typename T>
251inline const std::string& BlobSerializationOptions_FloatFormat_Name(T enum_t_value) {
252 static_assert(::std::is_same<T, BlobSerializationOptions_FloatFormat>::value ||
253 ::std::is_integral<T>::value,
254 "Incorrect type passed to function BlobSerializationOptions_FloatFormat_Name.");
255 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
256 BlobSerializationOptions_FloatFormat_descriptor(), enum_t_value);
257}
258inline bool BlobSerializationOptions_FloatFormat_Parse(
259 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BlobSerializationOptions_FloatFormat* value) {
260 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BlobSerializationOptions_FloatFormat>(
261 BlobSerializationOptions_FloatFormat_descriptor(), name, value);
262}
263enum DeviceTypeProto : int {
264 PROTO_CPU = 0,
265 PROTO_CUDA = 1,
266 PROTO_MKLDNN = 2,
267 PROTO_OPENGL = 3,
268 PROTO_OPENCL = 4,
269 PROTO_IDEEP = 5,
270 PROTO_HIP = 6,
271 PROTO_FPGA = 7,
272 PROTO_ORT = 8,
273 PROTO_XLA = 9,
274 PROTO_MPS = 10,
275 PROTO_COMPILE_TIME_MAX_DEVICE_TYPES = 11
276};
277TORCH_API bool DeviceTypeProto_IsValid(int value);
278constexpr DeviceTypeProto DeviceTypeProto_MIN = PROTO_CPU;
279constexpr DeviceTypeProto DeviceTypeProto_MAX = PROTO_COMPILE_TIME_MAX_DEVICE_TYPES;
280constexpr int DeviceTypeProto_ARRAYSIZE = static_cast<int>(DeviceTypeProto_MAX) + 1;
281
282TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceTypeProto_descriptor();
283template<typename T>
284inline const std::string& DeviceTypeProto_Name(T enum_t_value) {
285 static_assert(::std::is_same<T, DeviceTypeProto>::value ||
286 ::std::is_integral<T>::value,
287 "Incorrect type passed to function DeviceTypeProto_Name.");
288 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
289 DeviceTypeProto_descriptor(), enum_t_value);
290}
291inline bool DeviceTypeProto_Parse(
292 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceTypeProto* value) {
293 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceTypeProto>(
294 DeviceTypeProto_descriptor(), name, value);
295}
296// ===================================================================
297
298class TORCH_API TensorProto_Segment PROTOBUF_FINAL :
299 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorProto.Segment) */ {
300 public:
301 inline TensorProto_Segment() : TensorProto_Segment(nullptr) {}
302 virtual ~TensorProto_Segment();
303
304 TensorProto_Segment(const TensorProto_Segment& from);
305 TensorProto_Segment(TensorProto_Segment&& from) noexcept
306 : TensorProto_Segment() {
307 *this = ::std::move(from);
308 }
309
310 inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
311 CopyFrom(from);
312 return *this;
313 }
314 inline TensorProto_Segment& operator=(TensorProto_Segment&& from) noexcept {
315 if (GetArena() == from.GetArena()) {
316 if (this != &from) InternalSwap(&from);
317 } else {
318 CopyFrom(from);
319 }
320 return *this;
321 }
322
323 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
324 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
325 }
326 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
327 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
328 }
329
330 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
331 return GetDescriptor();
332 }
333 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
334 return GetMetadataStatic().descriptor;
335 }
336 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
337 return GetMetadataStatic().reflection;
338 }
339 static const TensorProto_Segment& default_instance();
340
341 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
342 static inline const TensorProto_Segment* internal_default_instance() {
343 return reinterpret_cast<const TensorProto_Segment*>(
344 &_TensorProto_Segment_default_instance_);
345 }
346 static constexpr int kIndexInFileMessages =
347 0;
348
349 friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) {
350 a.Swap(&b);
351 }
352 inline void Swap(TensorProto_Segment* other) {
353 if (other == this) return;
354 if (GetArena() == other->GetArena()) {
355 InternalSwap(other);
356 } else {
357 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
358 }
359 }
360 void UnsafeArenaSwap(TensorProto_Segment* other) {
361 if (other == this) return;
362 GOOGLE_DCHECK(GetArena() == other->GetArena());
363 InternalSwap(other);
364 }
365
366 // implements Message ----------------------------------------------
367
368 inline TensorProto_Segment* New() const final {
369 return CreateMaybeMessage<TensorProto_Segment>(nullptr);
370 }
371
372 TensorProto_Segment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
373 return CreateMaybeMessage<TensorProto_Segment>(arena);
374 }
375 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
376 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
377 void CopyFrom(const TensorProto_Segment& from);
378 void MergeFrom(const TensorProto_Segment& from);
379 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
380 bool IsInitialized() const final;
381
382 size_t ByteSizeLong() const final;
383 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
384 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
385 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
386 int GetCachedSize() const final { return _cached_size_.Get(); }
387
388 private:
389 inline void SharedCtor();
390 inline void SharedDtor();
391 void SetCachedSize(int size) const final;
392 void InternalSwap(TensorProto_Segment* other);
393 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
394 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
395 return "caffe2.TensorProto.Segment";
396 }
397 protected:
398 explicit TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::Arena* arena);
399 private:
400 static void ArenaDtor(void* object);
401 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
402 public:
403
404 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
405 private:
406 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
407 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
408 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
409 }
410
411 public:
412
413 // nested types ----------------------------------------------------
414
415 // accessors -------------------------------------------------------
416
417 enum : int {
418 kBeginFieldNumber = 1,
419 kEndFieldNumber = 2,
420 };
421 // required int64 begin = 1;
422 bool has_begin() const;
423 private:
424 bool _internal_has_begin() const;
425 public:
426 void clear_begin();
427 ::PROTOBUF_NAMESPACE_ID::int64 begin() const;
428 void set_begin(::PROTOBUF_NAMESPACE_ID::int64 value);
429 private:
430 ::PROTOBUF_NAMESPACE_ID::int64 _internal_begin() const;
431 void _internal_set_begin(::PROTOBUF_NAMESPACE_ID::int64 value);
432 public:
433
434 // required int64 end = 2;
435 bool has_end() const;
436 private:
437 bool _internal_has_end() const;
438 public:
439 void clear_end();
440 ::PROTOBUF_NAMESPACE_ID::int64 end() const;
441 void set_end(::PROTOBUF_NAMESPACE_ID::int64 value);
442 private:
443 ::PROTOBUF_NAMESPACE_ID::int64 _internal_end() const;
444 void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int64 value);
445 public:
446
447 // @@protoc_insertion_point(class_scope:caffe2.TensorProto.Segment)
448 private:
449 class _Internal;
450
451 // helper for ByteSizeLong()
452 size_t RequiredFieldsByteSizeFallback() const;
453
454 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
455 typedef void InternalArenaConstructable_;
456 typedef void DestructorSkippable_;
457 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
458 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
459 ::PROTOBUF_NAMESPACE_ID::int64 begin_;
460 ::PROTOBUF_NAMESPACE_ID::int64 end_;
461 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
462};
463// -------------------------------------------------------------------
464
465class TORCH_API TensorProto PROTOBUF_FINAL :
466 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorProto) */ {
467 public:
468 inline TensorProto() : TensorProto(nullptr) {}
469 virtual ~TensorProto();
470
471 TensorProto(const TensorProto& from);
472 TensorProto(TensorProto&& from) noexcept
473 : TensorProto() {
474 *this = ::std::move(from);
475 }
476
477 inline TensorProto& operator=(const TensorProto& from) {
478 CopyFrom(from);
479 return *this;
480 }
481 inline TensorProto& operator=(TensorProto&& from) noexcept {
482 if (GetArena() == from.GetArena()) {
483 if (this != &from) InternalSwap(&from);
484 } else {
485 CopyFrom(from);
486 }
487 return *this;
488 }
489
490 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
491 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
492 }
493 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
494 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
495 }
496
497 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
498 return GetDescriptor();
499 }
500 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
501 return GetMetadataStatic().descriptor;
502 }
503 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
504 return GetMetadataStatic().reflection;
505 }
506 static const TensorProto& default_instance();
507
508 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
509 static inline const TensorProto* internal_default_instance() {
510 return reinterpret_cast<const TensorProto*>(
511 &_TensorProto_default_instance_);
512 }
513 static constexpr int kIndexInFileMessages =
514 1;
515
516 friend void swap(TensorProto& a, TensorProto& b) {
517 a.Swap(&b);
518 }
519 inline void Swap(TensorProto* other) {
520 if (other == this) return;
521 if (GetArena() == other->GetArena()) {
522 InternalSwap(other);
523 } else {
524 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
525 }
526 }
527 void UnsafeArenaSwap(TensorProto* other) {
528 if (other == this) return;
529 GOOGLE_DCHECK(GetArena() == other->GetArena());
530 InternalSwap(other);
531 }
532
533 // implements Message ----------------------------------------------
534
535 inline TensorProto* New() const final {
536 return CreateMaybeMessage<TensorProto>(nullptr);
537 }
538
539 TensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
540 return CreateMaybeMessage<TensorProto>(arena);
541 }
542 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
543 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
544 void CopyFrom(const TensorProto& from);
545 void MergeFrom(const TensorProto& from);
546 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
547 bool IsInitialized() const final;
548
549 size_t ByteSizeLong() const final;
550 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
551 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
552 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
553 int GetCachedSize() const final { return _cached_size_.Get(); }
554
555 private:
556 inline void SharedCtor();
557 inline void SharedDtor();
558 void SetCachedSize(int size) const final;
559 void InternalSwap(TensorProto* other);
560 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
561 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
562 return "caffe2.TensorProto";
563 }
564 protected:
565 explicit TensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
566 private:
567 static void ArenaDtor(void* object);
568 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
569 public:
570
571 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
572 private:
573 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
574 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
575 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
576 }
577
578 public:
579
580 // nested types ----------------------------------------------------
581
582 typedef TensorProto_Segment Segment;
583
584 typedef TensorProto_DataType DataType;
585 static constexpr DataType UNDEFINED =
586 TensorProto_DataType_UNDEFINED;
587 static constexpr DataType FLOAT =
588 TensorProto_DataType_FLOAT;
589 static constexpr DataType INT32 =
590 TensorProto_DataType_INT32;
591 static constexpr DataType BYTE =
592 TensorProto_DataType_BYTE;
593 static constexpr DataType STRING =
594 TensorProto_DataType_STRING;
595 static constexpr DataType BOOL =
596 TensorProto_DataType_BOOL;
597 static constexpr DataType UINT8 =
598 TensorProto_DataType_UINT8;
599 static constexpr DataType INT8 =
600 TensorProto_DataType_INT8;
601 static constexpr DataType UINT16 =
602 TensorProto_DataType_UINT16;
603 static constexpr DataType INT16 =
604 TensorProto_DataType_INT16;
605 static constexpr DataType INT64 =
606 TensorProto_DataType_INT64;
607 static constexpr DataType FLOAT16 =
608 TensorProto_DataType_FLOAT16;
609 static constexpr DataType DOUBLE =
610 TensorProto_DataType_DOUBLE;
611 static constexpr DataType ZERO_COLLISION_HASH =
612 TensorProto_DataType_ZERO_COLLISION_HASH;
613 static constexpr DataType REBATCHING_BUFFER =
614 TensorProto_DataType_REBATCHING_BUFFER;
615 static inline bool DataType_IsValid(int value) {
616 return TensorProto_DataType_IsValid(value);
617 }
618 static constexpr DataType DataType_MIN =
619 TensorProto_DataType_DataType_MIN;
620 static constexpr DataType DataType_MAX =
621 TensorProto_DataType_DataType_MAX;
622 static constexpr int DataType_ARRAYSIZE =
623 TensorProto_DataType_DataType_ARRAYSIZE;
624 static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
625 DataType_descriptor() {
626 return TensorProto_DataType_descriptor();
627 }
628 template<typename T>
629 static inline const std::string& DataType_Name(T enum_t_value) {
630 static_assert(::std::is_same<T, DataType>::value ||
631 ::std::is_integral<T>::value,
632 "Incorrect type passed to function DataType_Name.");
633 return TensorProto_DataType_Name(enum_t_value);
634 }
635 static inline bool DataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
636 DataType* value) {
637 return TensorProto_DataType_Parse(name, value);
638 }
639
640 typedef TensorProto_SerializationFormat SerializationFormat;
641 static constexpr SerializationFormat FMT_PROTOBUF =
642 TensorProto_SerializationFormat_FMT_PROTOBUF;
643 static constexpr SerializationFormat FMT_BFLOAT16 =
644 TensorProto_SerializationFormat_FMT_BFLOAT16;
645 static inline bool SerializationFormat_IsValid(int value) {
646 return TensorProto_SerializationFormat_IsValid(value);
647 }
648 static constexpr SerializationFormat SerializationFormat_MIN =
649 TensorProto_SerializationFormat_SerializationFormat_MIN;
650 static constexpr SerializationFormat SerializationFormat_MAX =
651 TensorProto_SerializationFormat_SerializationFormat_MAX;
652 static constexpr int SerializationFormat_ARRAYSIZE =
653 TensorProto_SerializationFormat_SerializationFormat_ARRAYSIZE;
654 static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
655 SerializationFormat_descriptor() {
656 return TensorProto_SerializationFormat_descriptor();
657 }
658 template<typename T>
659 static inline const std::string& SerializationFormat_Name(T enum_t_value) {
660 static_assert(::std::is_same<T, SerializationFormat>::value ||
661 ::std::is_integral<T>::value,
662 "Incorrect type passed to function SerializationFormat_Name.");
663 return TensorProto_SerializationFormat_Name(enum_t_value);
664 }
665 static inline bool SerializationFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
666 SerializationFormat* value) {
667 return TensorProto_SerializationFormat_Parse(name, value);
668 }
669
670 // accessors -------------------------------------------------------
671
672 enum : int {
673 kDimsFieldNumber = 1,
674 kFloatDataFieldNumber = 3,
675 kInt32DataFieldNumber = 4,
676 kStringDataFieldNumber = 6,
677 kDoubleDataFieldNumber = 9,
678 kInt64DataFieldNumber = 10,
679 kByteDataFieldNumber = 5,
680 kNameFieldNumber = 7,
681 kRawDataFieldNumber = 13,
682 kDeviceDetailFieldNumber = 8,
683 kSegmentFieldNumber = 11,
684 kDataFormatFieldNumber = 15,
685 kDataTypeFieldNumber = 2,
686 };
687 // repeated int64 dims = 1;
688 int dims_size() const;
689 private:
690 int _internal_dims_size() const;
691 public:
692 void clear_dims();
693 private:
694 ::PROTOBUF_NAMESPACE_ID::int64 _internal_dims(int index) const;
695 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
696 _internal_dims() const;
697 void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
698 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
699 _internal_mutable_dims();
700 public:
701 ::PROTOBUF_NAMESPACE_ID::int64 dims(int index) const;
702 void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
703 void add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
704 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
705 dims() const;
706 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
707 mutable_dims();
708
709 // repeated float float_data = 3 [packed = true];
710 int float_data_size() const;
711 private:
712 int _internal_float_data_size() const;
713 public:
714 void clear_float_data();
715 private:
716 float _internal_float_data(int index) const;
717 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
718 _internal_float_data() const;
719 void _internal_add_float_data(float value);
720 ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
721 _internal_mutable_float_data();
722 public:
723 float float_data(int index) const;
724 void set_float_data(int index, float value);
725 void add_float_data(float value);
726 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
727 float_data() const;
728 ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
729 mutable_float_data();
730
731 // repeated int32 int32_data = 4 [packed = true];
732 int int32_data_size() const;
733 private:
734 int _internal_int32_data_size() const;
735 public:
736 void clear_int32_data();
737 private:
738 ::PROTOBUF_NAMESPACE_ID::int32 _internal_int32_data(int index) const;
739 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
740 _internal_int32_data() const;
741 void _internal_add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value);
742 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
743 _internal_mutable_int32_data();
744 public:
745 ::PROTOBUF_NAMESPACE_ID::int32 int32_data(int index) const;
746 void set_int32_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
747 void add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value);
748 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
749 int32_data() const;
750 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
751 mutable_int32_data();
752
753 // repeated bytes string_data = 6;
754 int string_data_size() const;
755 private:
756 int _internal_string_data_size() const;
757 public:
758 void clear_string_data();
759 const std::string& string_data(int index) const;
760 std::string* mutable_string_data(int index);
761 void set_string_data(int index, const std::string& value);
762 void set_string_data(int index, std::string&& value);
763 void set_string_data(int index, const char* value);
764 void set_string_data(int index, const void* value, size_t size);
765 std::string* add_string_data();
766 void add_string_data(const std::string& value);
767 void add_string_data(std::string&& value);
768 void add_string_data(const char* value);
769 void add_string_data(const void* value, size_t size);
770 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_data() const;
771 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_data();
772 private:
773 const std::string& _internal_string_data(int index) const;
774 std::string* _internal_add_string_data();
775 public:
776
777 // repeated double double_data = 9 [packed = true];
778 int double_data_size() const;
779 private:
780 int _internal_double_data_size() const;
781 public:
782 void clear_double_data();
783 private:
784 double _internal_double_data(int index) const;
785 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
786 _internal_double_data() const;
787 void _internal_add_double_data(double value);
788 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
789 _internal_mutable_double_data();
790 public:
791 double double_data(int index) const;
792 void set_double_data(int index, double value);
793 void add_double_data(double value);
794 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
795 double_data() const;
796 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
797 mutable_double_data();
798
799 // repeated int64 int64_data = 10 [packed = true];
800 int int64_data_size() const;
801 private:
802 int _internal_int64_data_size() const;
803 public:
804 void clear_int64_data();
805 private:
806 ::PROTOBUF_NAMESPACE_ID::int64 _internal_int64_data(int index) const;
807 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
808 _internal_int64_data() const;
809 void _internal_add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value);
810 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
811 _internal_mutable_int64_data();
812 public:
813 ::PROTOBUF_NAMESPACE_ID::int64 int64_data(int index) const;
814 void set_int64_data(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
815 void add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value);
816 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
817 int64_data() const;
818 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
819 mutable_int64_data();
820
821 // optional bytes byte_data = 5;
822 bool has_byte_data() const;
823 private:
824 bool _internal_has_byte_data() const;
825 public:
826 void clear_byte_data();
827 const std::string& byte_data() const;
828 void set_byte_data(const std::string& value);
829 void set_byte_data(std::string&& value);
830 void set_byte_data(const char* value);
831 void set_byte_data(const void* value, size_t size);
832 std::string* mutable_byte_data();
833 std::string* release_byte_data();
834 void set_allocated_byte_data(std::string* byte_data);
835 private:
836 const std::string& _internal_byte_data() const;
837 void _internal_set_byte_data(const std::string& value);
838 std::string* _internal_mutable_byte_data();
839 public:
840
841 // optional string name = 7;
842 bool has_name() const;
843 private:
844 bool _internal_has_name() const;
845 public:
846 void clear_name();
847 const std::string& name() const;
848 void set_name(const std::string& value);
849 void set_name(std::string&& value);
850 void set_name(const char* value);
851 void set_name(const char* value, size_t size);
852 std::string* mutable_name();
853 std::string* release_name();
854 void set_allocated_name(std::string* name);
855 private:
856 const std::string& _internal_name() const;
857 void _internal_set_name(const std::string& value);
858 std::string* _internal_mutable_name();
859 public:
860
861 // optional bytes raw_data = 13;
862 bool has_raw_data() const;
863 private:
864 bool _internal_has_raw_data() const;
865 public:
866 void clear_raw_data();
867 const std::string& raw_data() const;
868 void set_raw_data(const std::string& value);
869 void set_raw_data(std::string&& value);
870 void set_raw_data(const char* value);
871 void set_raw_data(const void* value, size_t size);
872 std::string* mutable_raw_data();
873 std::string* release_raw_data();
874 void set_allocated_raw_data(std::string* raw_data);
875 private:
876 const std::string& _internal_raw_data() const;
877 void _internal_set_raw_data(const std::string& value);
878 std::string* _internal_mutable_raw_data();
879 public:
880
881 // optional .caffe2.DeviceOption device_detail = 8;
882 bool has_device_detail() const;
883 private:
884 bool _internal_has_device_detail() const;
885 public:
886 void clear_device_detail();
887 const ::caffe2::DeviceOption& device_detail() const;
888 ::caffe2::DeviceOption* release_device_detail();
889 ::caffe2::DeviceOption* mutable_device_detail();
890 void set_allocated_device_detail(::caffe2::DeviceOption* device_detail);
891 private:
892 const ::caffe2::DeviceOption& _internal_device_detail() const;
893 ::caffe2::DeviceOption* _internal_mutable_device_detail();
894 public:
895 void unsafe_arena_set_allocated_device_detail(
896 ::caffe2::DeviceOption* device_detail);
897 ::caffe2::DeviceOption* unsafe_arena_release_device_detail();
898
899 // optional .caffe2.TensorProto.Segment segment = 11;
900 bool has_segment() const;
901 private:
902 bool _internal_has_segment() const;
903 public:
904 void clear_segment();
905 const ::caffe2::TensorProto_Segment& segment() const;
906 ::caffe2::TensorProto_Segment* release_segment();
907 ::caffe2::TensorProto_Segment* mutable_segment();
908 void set_allocated_segment(::caffe2::TensorProto_Segment* segment);
909 private:
910 const ::caffe2::TensorProto_Segment& _internal_segment() const;
911 ::caffe2::TensorProto_Segment* _internal_mutable_segment();
912 public:
913 void unsafe_arena_set_allocated_segment(
914 ::caffe2::TensorProto_Segment* segment);
915 ::caffe2::TensorProto_Segment* unsafe_arena_release_segment();
916
917 // optional uint32 data_format = 15 [default = 0];
918 bool has_data_format() const;
919 private:
920 bool _internal_has_data_format() const;
921 public:
922 void clear_data_format();
923 ::PROTOBUF_NAMESPACE_ID::uint32 data_format() const;
924 void set_data_format(::PROTOBUF_NAMESPACE_ID::uint32 value);
925 private:
926 ::PROTOBUF_NAMESPACE_ID::uint32 _internal_data_format() const;
927 void _internal_set_data_format(::PROTOBUF_NAMESPACE_ID::uint32 value);
928 public:
929
930 // optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT];
931 bool has_data_type() const;
932 private:
933 bool _internal_has_data_type() const;
934 public:
935 void clear_data_type();
936 ::caffe2::TensorProto_DataType data_type() const;
937 void set_data_type(::caffe2::TensorProto_DataType value);
938 private:
939 ::caffe2::TensorProto_DataType _internal_data_type() const;
940 void _internal_set_data_type(::caffe2::TensorProto_DataType value);
941 public:
942
943 // @@protoc_insertion_point(class_scope:caffe2.TensorProto)
944 private:
945 class _Internal;
946
947 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
948 typedef void InternalArenaConstructable_;
949 typedef void DestructorSkippable_;
950 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
951 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
952 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > dims_;
953 ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_data_;
954 mutable std::atomic<int> _float_data_cached_byte_size_;
955 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > int32_data_;
956 mutable std::atomic<int> _int32_data_cached_byte_size_;
957 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_data_;
958 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_data_;
959 mutable std::atomic<int> _double_data_cached_byte_size_;
960 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > int64_data_;
961 mutable std::atomic<int> _int64_data_cached_byte_size_;
962 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr byte_data_;
963 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
964 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_data_;
965 ::caffe2::DeviceOption* device_detail_;
966 ::caffe2::TensorProto_Segment* segment_;
967 ::PROTOBUF_NAMESPACE_ID::uint32 data_format_;
968 int data_type_;
969 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
970};
971// -------------------------------------------------------------------
972
973class TORCH_API QTensorProto PROTOBUF_FINAL :
974 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.QTensorProto) */ {
975 public:
976 inline QTensorProto() : QTensorProto(nullptr) {}
977 virtual ~QTensorProto();
978
979 QTensorProto(const QTensorProto& from);
980 QTensorProto(QTensorProto&& from) noexcept
981 : QTensorProto() {
982 *this = ::std::move(from);
983 }
984
985 inline QTensorProto& operator=(const QTensorProto& from) {
986 CopyFrom(from);
987 return *this;
988 }
989 inline QTensorProto& operator=(QTensorProto&& from) noexcept {
990 if (GetArena() == from.GetArena()) {
991 if (this != &from) InternalSwap(&from);
992 } else {
993 CopyFrom(from);
994 }
995 return *this;
996 }
997
998 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
999 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1000 }
1001 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1002 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1003 }
1004
1005 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1006 return GetDescriptor();
1007 }
1008 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1009 return GetMetadataStatic().descriptor;
1010 }
1011 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1012 return GetMetadataStatic().reflection;
1013 }
1014 static const QTensorProto& default_instance();
1015
1016 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1017 static inline const QTensorProto* internal_default_instance() {
1018 return reinterpret_cast<const QTensorProto*>(
1019 &_QTensorProto_default_instance_);
1020 }
1021 static constexpr int kIndexInFileMessages =
1022 2;
1023
1024 friend void swap(QTensorProto& a, QTensorProto& b) {
1025 a.Swap(&b);
1026 }
1027 inline void Swap(QTensorProto* other) {
1028 if (other == this) return;
1029 if (GetArena() == other->GetArena()) {
1030 InternalSwap(other);
1031 } else {
1032 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1033 }
1034 }
1035 void UnsafeArenaSwap(QTensorProto* other) {
1036 if (other == this) return;
1037 GOOGLE_DCHECK(GetArena() == other->GetArena());
1038 InternalSwap(other);
1039 }
1040
1041 // implements Message ----------------------------------------------
1042
1043 inline QTensorProto* New() const final {
1044 return CreateMaybeMessage<QTensorProto>(nullptr);
1045 }
1046
1047 QTensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1048 return CreateMaybeMessage<QTensorProto>(arena);
1049 }
1050 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1051 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1052 void CopyFrom(const QTensorProto& from);
1053 void MergeFrom(const QTensorProto& from);
1054 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1055 bool IsInitialized() const final;
1056
1057 size_t ByteSizeLong() const final;
1058 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1059 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
1060 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1061 int GetCachedSize() const final { return _cached_size_.Get(); }
1062
1063 private:
1064 inline void SharedCtor();
1065 inline void SharedDtor();
1066 void SetCachedSize(int size) const final;
1067 void InternalSwap(QTensorProto* other);
1068 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1069 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1070 return "caffe2.QTensorProto";
1071 }
1072 protected:
1073 explicit QTensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1074 private:
1075 static void ArenaDtor(void* object);
1076 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1077 public:
1078
1079 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1080 private:
1081 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1082 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
1083 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
1084 }
1085
1086 public:
1087
1088 // nested types ----------------------------------------------------
1089
1090 // accessors -------------------------------------------------------
1091
1092 enum : int {
1093 kDimsFieldNumber = 1,
1094 kDataFieldNumber = 6,
1095 kScalesFieldNumber = 9,
1096 kBiasesFieldNumber = 10,
1097 kNameFieldNumber = 7,
1098 kScaleFieldNumber = 3,
1099 kBiasFieldNumber = 4,
1100 kPrecisionFieldNumber = 2,
1101 kIsSignedFieldNumber = 5,
1102 kIsMultiparamFieldNumber = 12,
1103 kAxisFieldNumber = 11,
1104 kDataTypeFieldNumber = 8,
1105 };
1106 // repeated int64 dims = 1;
1107 int dims_size() const;
1108 private:
1109 int _internal_dims_size() const;
1110 public:
1111 void clear_dims();
1112 private:
1113 ::PROTOBUF_NAMESPACE_ID::int64 _internal_dims(int index) const;
1114 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
1115 _internal_dims() const;
1116 void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
1117 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
1118 _internal_mutable_dims();
1119 public:
1120 ::PROTOBUF_NAMESPACE_ID::int64 dims(int index) const;
1121 void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
1122 void add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
1123 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
1124 dims() const;
1125 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
1126 mutable_dims();
1127
1128 // repeated int32 data = 6 [packed = true];
1129 int data_size() const;
1130 private:
1131 int _internal_data_size() const;
1132 public:
1133 void clear_data();
1134 private:
1135 ::PROTOBUF_NAMESPACE_ID::int32 _internal_data(int index) const;
1136 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
1137 _internal_data() const;
1138 void _internal_add_data(::PROTOBUF_NAMESPACE_ID::int32 value);
1139 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
1140 _internal_mutable_data();
1141 public:
1142 ::PROTOBUF_NAMESPACE_ID::int32 data(int index) const;
1143 void set_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
1144 void add_data(::PROTOBUF_NAMESPACE_ID::int32 value);
1145 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
1146 data() const;
1147 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
1148 mutable_data();
1149
1150 // repeated double scales = 9;
1151 int scales_size() const;
1152 private:
1153 int _internal_scales_size() const;
1154 public:
1155 void clear_scales();
1156 private:
1157 double _internal_scales(int index) const;
1158 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
1159 _internal_scales() const;
1160 void _internal_add_scales(double value);
1161 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
1162 _internal_mutable_scales();
1163 public:
1164 double scales(int index) const;
1165 void set_scales(int index, double value);
1166 void add_scales(double value);
1167 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
1168 scales() const;
1169 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
1170 mutable_scales();
1171
1172 // repeated double biases = 10;
1173 int biases_size() const;
1174 private:
1175 int _internal_biases_size() const;
1176 public:
1177 void clear_biases();
1178 private:
1179 double _internal_biases(int index) const;
1180 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
1181 _internal_biases() const;
1182 void _internal_add_biases(double value);
1183 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
1184 _internal_mutable_biases();
1185 public:
1186 double biases(int index) const;
1187 void set_biases(int index, double value);
1188 void add_biases(double value);
1189 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
1190 biases() const;
1191 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
1192 mutable_biases();
1193
1194 // optional string name = 7;
1195 bool has_name() const;
1196 private:
1197 bool _internal_has_name() const;
1198 public:
1199 void clear_name();
1200 const std::string& name() const;
1201 void set_name(const std::string& value);
1202 void set_name(std::string&& value);
1203 void set_name(const char* value);
1204 void set_name(const char* value, size_t size);
1205 std::string* mutable_name();
1206 std::string* release_name();
1207 void set_allocated_name(std::string* name);
1208 private:
1209 const std::string& _internal_name() const;
1210 void _internal_set_name(const std::string& value);
1211 std::string* _internal_mutable_name();
1212 public:
1213
1214 // required double scale = 3;
1215 bool has_scale() const;
1216 private:
1217 bool _internal_has_scale() const;
1218 public:
1219 void clear_scale();
1220 double scale() const;
1221 void set_scale(double value);
1222 private:
1223 double _internal_scale() const;
1224 void _internal_set_scale(double value);
1225 public:
1226
1227 // required double bias = 4;
1228 bool has_bias() const;
1229 private:
1230 bool _internal_has_bias() const;
1231 public:
1232 void clear_bias();
1233 double bias() const;
1234 void set_bias(double value);
1235 private:
1236 double _internal_bias() const;
1237 void _internal_set_bias(double value);
1238 public:
1239
1240 // required int32 precision = 2;
1241 bool has_precision() const;
1242 private:
1243 bool _internal_has_precision() const;
1244 public:
1245 void clear_precision();
1246 ::PROTOBUF_NAMESPACE_ID::int32 precision() const;
1247 void set_precision(::PROTOBUF_NAMESPACE_ID::int32 value);
1248 private:
1249 ::PROTOBUF_NAMESPACE_ID::int32 _internal_precision() const;
1250 void _internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value);
1251 public:
1252
1253 // required bool is_signed = 5;
1254 bool has_is_signed() const;
1255 private:
1256 bool _internal_has_is_signed() const;
1257 public:
1258 void clear_is_signed();
1259 bool is_signed() const;
1260 void set_is_signed(bool value);
1261 private:
1262 bool _internal_is_signed() const;
1263 void _internal_set_is_signed(bool value);
1264 public:
1265
1266 // optional bool is_multiparam = 12 [default = false];
1267 bool has_is_multiparam() const;
1268 private:
1269 bool _internal_has_is_multiparam() const;
1270 public:
1271 void clear_is_multiparam();
1272 bool is_multiparam() const;
1273 void set_is_multiparam(bool value);
1274 private:
1275 bool _internal_is_multiparam() const;
1276 void _internal_set_is_multiparam(bool value);
1277 public:
1278
1279 // optional int32 axis = 11;
1280 bool has_axis() const;
1281 private:
1282 bool _internal_has_axis() const;
1283 public:
1284 void clear_axis();
1285 ::PROTOBUF_NAMESPACE_ID::int32 axis() const;
1286 void set_axis(::PROTOBUF_NAMESPACE_ID::int32 value);
1287 private:
1288 ::PROTOBUF_NAMESPACE_ID::int32 _internal_axis() const;
1289 void _internal_set_axis(::PROTOBUF_NAMESPACE_ID::int32 value);
1290 public:
1291
1292 // optional .caffe2.TensorProto.DataType data_type = 8 [default = INT32];
1293 bool has_data_type() const;
1294 private:
1295 bool _internal_has_data_type() const;
1296 public:
1297 void clear_data_type();
1298 ::caffe2::TensorProto_DataType data_type() const;
1299 void set_data_type(::caffe2::TensorProto_DataType value);
1300 private:
1301 ::caffe2::TensorProto_DataType _internal_data_type() const;
1302 void _internal_set_data_type(::caffe2::TensorProto_DataType value);
1303 public:
1304
1305 // @@protoc_insertion_point(class_scope:caffe2.QTensorProto)
1306 private:
1307 class _Internal;
1308
1309 // helper for ByteSizeLong()
1310 size_t RequiredFieldsByteSizeFallback() const;
1311
1312 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1313 typedef void InternalArenaConstructable_;
1314 typedef void DestructorSkippable_;
1315 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1316 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1317 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > dims_;
1318 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > data_;
1319 mutable std::atomic<int> _data_cached_byte_size_;
1320 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > scales_;
1321 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > biases_;
1322 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1323 double scale_;
1324 double bias_;
1325 ::PROTOBUF_NAMESPACE_ID::int32 precision_;
1326 bool is_signed_;
1327 bool is_multiparam_;
1328 ::PROTOBUF_NAMESPACE_ID::int32 axis_;
1329 int data_type_;
1330 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
1331};
1332// -------------------------------------------------------------------
1333
1334class TORCH_API TensorProtos PROTOBUF_FINAL :
1335 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorProtos) */ {
1336 public:
1337 inline TensorProtos() : TensorProtos(nullptr) {}
1338 virtual ~TensorProtos();
1339
1340 TensorProtos(const TensorProtos& from);
1341 TensorProtos(TensorProtos&& from) noexcept
1342 : TensorProtos() {
1343 *this = ::std::move(from);
1344 }
1345
1346 inline TensorProtos& operator=(const TensorProtos& from) {
1347 CopyFrom(from);
1348 return *this;
1349 }
1350 inline TensorProtos& operator=(TensorProtos&& from) noexcept {
1351 if (GetArena() == from.GetArena()) {
1352 if (this != &from) InternalSwap(&from);
1353 } else {
1354 CopyFrom(from);
1355 }
1356 return *this;
1357 }
1358
1359 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1360 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1361 }
1362 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1363 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1364 }
1365
1366 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1367 return GetDescriptor();
1368 }
1369 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1370 return GetMetadataStatic().descriptor;
1371 }
1372 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1373 return GetMetadataStatic().reflection;
1374 }
1375 static const TensorProtos& default_instance();
1376
1377 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1378 static inline const TensorProtos* internal_default_instance() {
1379 return reinterpret_cast<const TensorProtos*>(
1380 &_TensorProtos_default_instance_);
1381 }
1382 static constexpr int kIndexInFileMessages =
1383 3;
1384
1385 friend void swap(TensorProtos& a, TensorProtos& b) {
1386 a.Swap(&b);
1387 }
1388 inline void Swap(TensorProtos* other) {
1389 if (other == this) return;
1390 if (GetArena() == other->GetArena()) {
1391 InternalSwap(other);
1392 } else {
1393 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1394 }
1395 }
1396 void UnsafeArenaSwap(TensorProtos* other) {
1397 if (other == this) return;
1398 GOOGLE_DCHECK(GetArena() == other->GetArena());
1399 InternalSwap(other);
1400 }
1401
1402 // implements Message ----------------------------------------------
1403
1404 inline TensorProtos* New() const final {
1405 return CreateMaybeMessage<TensorProtos>(nullptr);
1406 }
1407
1408 TensorProtos* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1409 return CreateMaybeMessage<TensorProtos>(arena);
1410 }
1411 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1412 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1413 void CopyFrom(const TensorProtos& from);
1414 void MergeFrom(const TensorProtos& from);
1415 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1416 bool IsInitialized() const final;
1417
1418 size_t ByteSizeLong() const final;
1419 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1420 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
1421 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1422 int GetCachedSize() const final { return _cached_size_.Get(); }
1423
1424 private:
1425 inline void SharedCtor();
1426 inline void SharedDtor();
1427 void SetCachedSize(int size) const final;
1428 void InternalSwap(TensorProtos* other);
1429 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1430 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1431 return "caffe2.TensorProtos";
1432 }
1433 protected:
1434 explicit TensorProtos(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1435 private:
1436 static void ArenaDtor(void* object);
1437 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1438 public:
1439
1440 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1441 private:
1442 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1443 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
1444 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
1445 }
1446
1447 public:
1448
1449 // nested types ----------------------------------------------------
1450
1451 // accessors -------------------------------------------------------
1452
1453 enum : int {
1454 kProtosFieldNumber = 1,
1455 };
1456 // repeated .caffe2.TensorProto protos = 1;
1457 int protos_size() const;
1458 private:
1459 int _internal_protos_size() const;
1460 public:
1461 void clear_protos();
1462 ::caffe2::TensorProto* mutable_protos(int index);
1463 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >*
1464 mutable_protos();
1465 private:
1466 const ::caffe2::TensorProto& _internal_protos(int index) const;
1467 ::caffe2::TensorProto* _internal_add_protos();
1468 public:
1469 const ::caffe2::TensorProto& protos(int index) const;
1470 ::caffe2::TensorProto* add_protos();
1471 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >&
1472 protos() const;
1473
1474 // @@protoc_insertion_point(class_scope:caffe2.TensorProtos)
1475 private:
1476 class _Internal;
1477
1478 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1479 typedef void InternalArenaConstructable_;
1480 typedef void DestructorSkippable_;
1481 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto > protos_;
1482 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1483 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
1484};
1485// -------------------------------------------------------------------
1486
1487class TORCH_API TensorShape PROTOBUF_FINAL :
1488 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorShape) */ {
1489 public:
1490 inline TensorShape() : TensorShape(nullptr) {}
1491 virtual ~TensorShape();
1492
1493 TensorShape(const TensorShape& from);
1494 TensorShape(TensorShape&& from) noexcept
1495 : TensorShape() {
1496 *this = ::std::move(from);
1497 }
1498
1499 inline TensorShape& operator=(const TensorShape& from) {
1500 CopyFrom(from);
1501 return *this;
1502 }
1503 inline TensorShape& operator=(TensorShape&& from) noexcept {
1504 if (GetArena() == from.GetArena()) {
1505 if (this != &from) InternalSwap(&from);
1506 } else {
1507 CopyFrom(from);
1508 }
1509 return *this;
1510 }
1511
1512 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1513 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1514 }
1515 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1516 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1517 }
1518
1519 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1520 return GetDescriptor();
1521 }
1522 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1523 return GetMetadataStatic().descriptor;
1524 }
1525 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1526 return GetMetadataStatic().reflection;
1527 }
1528 static const TensorShape& default_instance();
1529
1530 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1531 static inline const TensorShape* internal_default_instance() {
1532 return reinterpret_cast<const TensorShape*>(
1533 &_TensorShape_default_instance_);
1534 }
1535 static constexpr int kIndexInFileMessages =
1536 4;
1537
1538 friend void swap(TensorShape& a, TensorShape& b) {
1539 a.Swap(&b);
1540 }
1541 inline void Swap(TensorShape* other) {
1542 if (other == this) return;
1543 if (GetArena() == other->GetArena()) {
1544 InternalSwap(other);
1545 } else {
1546 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1547 }
1548 }
1549 void UnsafeArenaSwap(TensorShape* other) {
1550 if (other == this) return;
1551 GOOGLE_DCHECK(GetArena() == other->GetArena());
1552 InternalSwap(other);
1553 }
1554
1555 // implements Message ----------------------------------------------
1556
1557 inline TensorShape* New() const final {
1558 return CreateMaybeMessage<TensorShape>(nullptr);
1559 }
1560
1561 TensorShape* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1562 return CreateMaybeMessage<TensorShape>(arena);
1563 }
1564 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1565 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1566 void CopyFrom(const TensorShape& from);
1567 void MergeFrom(const TensorShape& from);
1568 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1569 bool IsInitialized() const final;
1570
1571 size_t ByteSizeLong() const final;
1572 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1573 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
1574 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1575 int GetCachedSize() const final { return _cached_size_.Get(); }
1576
1577 private:
1578 inline void SharedCtor();
1579 inline void SharedDtor();
1580 void SetCachedSize(int size) const final;
1581 void InternalSwap(TensorShape* other);
1582 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1583 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1584 return "caffe2.TensorShape";
1585 }
1586 protected:
1587 explicit TensorShape(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1588 private:
1589 static void ArenaDtor(void* object);
1590 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1591 public:
1592
1593 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1594 private:
1595 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1596 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
1597 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
1598 }
1599
1600 public:
1601
1602 // nested types ----------------------------------------------------
1603
1604 // accessors -------------------------------------------------------
1605
1606 enum : int {
1607 kDimsFieldNumber = 1,
1608 kUnknownDimsFieldNumber = 3,
1609 kNameFieldNumber = 5,
1610 kUnknownShapeFieldNumber = 4,
1611 kDataTypeFieldNumber = 2,
1612 };
1613 // repeated int64 dims = 1;
1614 int dims_size() const;
1615 private:
1616 int _internal_dims_size() const;
1617 public:
1618 void clear_dims();
1619 private:
1620 ::PROTOBUF_NAMESPACE_ID::int64 _internal_dims(int index) const;
1621 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
1622 _internal_dims() const;
1623 void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
1624 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
1625 _internal_mutable_dims();
1626 public:
1627 ::PROTOBUF_NAMESPACE_ID::int64 dims(int index) const;
1628 void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
1629 void add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
1630 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
1631 dims() const;
1632 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
1633 mutable_dims();
1634
1635 // repeated int32 unknown_dims = 3;
1636 int unknown_dims_size() const;
1637 private:
1638 int _internal_unknown_dims_size() const;
1639 public:
1640 void clear_unknown_dims();
1641 private:
1642 ::PROTOBUF_NAMESPACE_ID::int32 _internal_unknown_dims(int index) const;
1643 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
1644 _internal_unknown_dims() const;
1645 void _internal_add_unknown_dims(::PROTOBUF_NAMESPACE_ID::int32 value);
1646 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
1647 _internal_mutable_unknown_dims();
1648 public:
1649 ::PROTOBUF_NAMESPACE_ID::int32 unknown_dims(int index) const;
1650 void set_unknown_dims(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
1651 void add_unknown_dims(::PROTOBUF_NAMESPACE_ID::int32 value);
1652 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
1653 unknown_dims() const;
1654 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
1655 mutable_unknown_dims();
1656
1657 // optional string name = 5;
1658 bool has_name() const;
1659 private:
1660 bool _internal_has_name() const;
1661 public:
1662 void clear_name();
1663 const std::string& name() const;
1664 void set_name(const std::string& value);
1665 void set_name(std::string&& value);
1666 void set_name(const char* value);
1667 void set_name(const char* value, size_t size);
1668 std::string* mutable_name();
1669 std::string* release_name();
1670 void set_allocated_name(std::string* name);
1671 private:
1672 const std::string& _internal_name() const;
1673 void _internal_set_name(const std::string& value);
1674 std::string* _internal_mutable_name();
1675 public:
1676
1677 // optional bool unknown_shape = 4 [default = false];
1678 bool has_unknown_shape() const;
1679 private:
1680 bool _internal_has_unknown_shape() const;
1681 public:
1682 void clear_unknown_shape();
1683 bool unknown_shape() const;
1684 void set_unknown_shape(bool value);
1685 private:
1686 bool _internal_unknown_shape() const;
1687 void _internal_set_unknown_shape(bool value);
1688 public:
1689
1690 // optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT];
1691 bool has_data_type() const;
1692 private:
1693 bool _internal_has_data_type() const;
1694 public:
1695 void clear_data_type();
1696 ::caffe2::TensorProto_DataType data_type() const;
1697 void set_data_type(::caffe2::TensorProto_DataType value);
1698 private:
1699 ::caffe2::TensorProto_DataType _internal_data_type() const;
1700 void _internal_set_data_type(::caffe2::TensorProto_DataType value);
1701 public:
1702
1703 // @@protoc_insertion_point(class_scope:caffe2.TensorShape)
1704 private:
1705 class _Internal;
1706
1707 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1708 typedef void InternalArenaConstructable_;
1709 typedef void DestructorSkippable_;
1710 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1711 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1712 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > dims_;
1713 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > unknown_dims_;
1714 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1715 bool unknown_shape_;
1716 int data_type_;
1717 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
1718};
1719// -------------------------------------------------------------------
1720
1721class TORCH_API TensorShapes PROTOBUF_FINAL :
1722 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorShapes) */ {
1723 public:
1724 inline TensorShapes() : TensorShapes(nullptr) {}
1725 virtual ~TensorShapes();
1726
1727 TensorShapes(const TensorShapes& from);
1728 TensorShapes(TensorShapes&& from) noexcept
1729 : TensorShapes() {
1730 *this = ::std::move(from);
1731 }
1732
1733 inline TensorShapes& operator=(const TensorShapes& from) {
1734 CopyFrom(from);
1735 return *this;
1736 }
1737 inline TensorShapes& operator=(TensorShapes&& from) noexcept {
1738 if (GetArena() == from.GetArena()) {
1739 if (this != &from) InternalSwap(&from);
1740 } else {
1741 CopyFrom(from);
1742 }
1743 return *this;
1744 }
1745
1746 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1747 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1748 }
1749 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1750 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1751 }
1752
1753 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1754 return GetDescriptor();
1755 }
1756 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1757 return GetMetadataStatic().descriptor;
1758 }
1759 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1760 return GetMetadataStatic().reflection;
1761 }
1762 static const TensorShapes& default_instance();
1763
1764 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1765 static inline const TensorShapes* internal_default_instance() {
1766 return reinterpret_cast<const TensorShapes*>(
1767 &_TensorShapes_default_instance_);
1768 }
1769 static constexpr int kIndexInFileMessages =
1770 5;
1771
1772 friend void swap(TensorShapes& a, TensorShapes& b) {
1773 a.Swap(&b);
1774 }
1775 inline void Swap(TensorShapes* other) {
1776 if (other == this) return;
1777 if (GetArena() == other->GetArena()) {
1778 InternalSwap(other);
1779 } else {
1780 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1781 }
1782 }
1783 void UnsafeArenaSwap(TensorShapes* other) {
1784 if (other == this) return;
1785 GOOGLE_DCHECK(GetArena() == other->GetArena());
1786 InternalSwap(other);
1787 }
1788
1789 // implements Message ----------------------------------------------
1790
1791 inline TensorShapes* New() const final {
1792 return CreateMaybeMessage<TensorShapes>(nullptr);
1793 }
1794
1795 TensorShapes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1796 return CreateMaybeMessage<TensorShapes>(arena);
1797 }
1798 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1799 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1800 void CopyFrom(const TensorShapes& from);
1801 void MergeFrom(const TensorShapes& from);
1802 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1803 bool IsInitialized() const final;
1804
1805 size_t ByteSizeLong() const final;
1806 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1807 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
1808 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1809 int GetCachedSize() const final { return _cached_size_.Get(); }
1810
1811 private:
1812 inline void SharedCtor();
1813 inline void SharedDtor();
1814 void SetCachedSize(int size) const final;
1815 void InternalSwap(TensorShapes* other);
1816 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1817 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1818 return "caffe2.TensorShapes";
1819 }
1820 protected:
1821 explicit TensorShapes(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1822 private:
1823 static void ArenaDtor(void* object);
1824 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1825 public:
1826
1827 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1828 private:
1829 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1830 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
1831 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
1832 }
1833
1834 public:
1835
1836 // nested types ----------------------------------------------------
1837
1838 // accessors -------------------------------------------------------
1839
1840 enum : int {
1841 kShapesFieldNumber = 1,
1842 };
1843 // repeated .caffe2.TensorShape shapes = 1;
1844 int shapes_size() const;
1845 private:
1846 int _internal_shapes_size() const;
1847 public:
1848 void clear_shapes();
1849 ::caffe2::TensorShape* mutable_shapes(int index);
1850 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape >*
1851 mutable_shapes();
1852 private:
1853 const ::caffe2::TensorShape& _internal_shapes(int index) const;
1854 ::caffe2::TensorShape* _internal_add_shapes();
1855 public:
1856 const ::caffe2::TensorShape& shapes(int index) const;
1857 ::caffe2::TensorShape* add_shapes();
1858 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape >&
1859 shapes() const;
1860
1861 // @@protoc_insertion_point(class_scope:caffe2.TensorShapes)
1862 private:
1863 class _Internal;
1864
1865 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1866 typedef void InternalArenaConstructable_;
1867 typedef void DestructorSkippable_;
1868 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape > shapes_;
1869 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1870 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
1871};
1872// -------------------------------------------------------------------
1873
1874class TORCH_API TensorBoundShape PROTOBUF_FINAL :
1875 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorBoundShape) */ {
1876 public:
1877 inline TensorBoundShape() : TensorBoundShape(nullptr) {}
1878 virtual ~TensorBoundShape();
1879
1880 TensorBoundShape(const TensorBoundShape& from);
1881 TensorBoundShape(TensorBoundShape&& from) noexcept
1882 : TensorBoundShape() {
1883 *this = ::std::move(from);
1884 }
1885
1886 inline TensorBoundShape& operator=(const TensorBoundShape& from) {
1887 CopyFrom(from);
1888 return *this;
1889 }
1890 inline TensorBoundShape& operator=(TensorBoundShape&& from) noexcept {
1891 if (GetArena() == from.GetArena()) {
1892 if (this != &from) InternalSwap(&from);
1893 } else {
1894 CopyFrom(from);
1895 }
1896 return *this;
1897 }
1898
1899 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1900 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1901 }
1902 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1903 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1904 }
1905
1906 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1907 return GetDescriptor();
1908 }
1909 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1910 return GetMetadataStatic().descriptor;
1911 }
1912 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1913 return GetMetadataStatic().reflection;
1914 }
1915 static const TensorBoundShape& default_instance();
1916
1917 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1918 static inline const TensorBoundShape* internal_default_instance() {
1919 return reinterpret_cast<const TensorBoundShape*>(
1920 &_TensorBoundShape_default_instance_);
1921 }
1922 static constexpr int kIndexInFileMessages =
1923 6;
1924
1925 friend void swap(TensorBoundShape& a, TensorBoundShape& b) {
1926 a.Swap(&b);
1927 }
1928 inline void Swap(TensorBoundShape* other) {
1929 if (other == this) return;
1930 if (GetArena() == other->GetArena()) {
1931 InternalSwap(other);
1932 } else {
1933 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1934 }
1935 }
1936 void UnsafeArenaSwap(TensorBoundShape* other) {
1937 if (other == this) return;
1938 GOOGLE_DCHECK(GetArena() == other->GetArena());
1939 InternalSwap(other);
1940 }
1941
1942 // implements Message ----------------------------------------------
1943
1944 inline TensorBoundShape* New() const final {
1945 return CreateMaybeMessage<TensorBoundShape>(nullptr);
1946 }
1947
1948 TensorBoundShape* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1949 return CreateMaybeMessage<TensorBoundShape>(arena);
1950 }
1951 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1952 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1953 void CopyFrom(const TensorBoundShape& from);
1954 void MergeFrom(const TensorBoundShape& from);
1955 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1956 bool IsInitialized() const final;
1957
1958 size_t ByteSizeLong() const final;
1959 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1960 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
1961 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1962 int GetCachedSize() const final { return _cached_size_.Get(); }
1963
1964 private:
1965 inline void SharedCtor();
1966 inline void SharedDtor();
1967 void SetCachedSize(int size) const final;
1968 void InternalSwap(TensorBoundShape* other);
1969 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1970 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1971 return "caffe2.TensorBoundShape";
1972 }
1973 protected:
1974 explicit TensorBoundShape(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1975 private:
1976 static void ArenaDtor(void* object);
1977 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1978 public:
1979
1980 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1981 private:
1982 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1983 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
1984 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
1985 }
1986
1987 public:
1988
1989 // nested types ----------------------------------------------------
1990
1991 typedef TensorBoundShape_DimType DimType;
1992 static constexpr DimType UNKNOWN =
1993 TensorBoundShape_DimType_UNKNOWN;
1994 static constexpr DimType CONSTANT =
1995 TensorBoundShape_DimType_CONSTANT;
1996 static constexpr DimType BATCH =
1997 TensorBoundShape_DimType_BATCH;
1998 static constexpr DimType BATCH_OF_FEATURE_MAX =
1999 TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX;
2000 static constexpr DimType BATCH_OF_FEATURE_MAX_DEFAULT =
2001 TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX_DEFAULT;
2002 static constexpr DimType FEATURE_MAX =
2003 TensorBoundShape_DimType_FEATURE_MAX;
2004 static constexpr DimType FEATURE_MAX_DEFAULT =
2005 TensorBoundShape_DimType_FEATURE_MAX_DEFAULT;
2006 static inline bool DimType_IsValid(int value) {
2007 return TensorBoundShape_DimType_IsValid(value);
2008 }
2009 static constexpr DimType DimType_MIN =
2010 TensorBoundShape_DimType_DimType_MIN;
2011 static constexpr DimType DimType_MAX =
2012 TensorBoundShape_DimType_DimType_MAX;
2013 static constexpr int DimType_ARRAYSIZE =
2014 TensorBoundShape_DimType_DimType_ARRAYSIZE;
2015 static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
2016 DimType_descriptor() {
2017 return TensorBoundShape_DimType_descriptor();
2018 }
2019 template<typename T>
2020 static inline const std::string& DimType_Name(T enum_t_value) {
2021 static_assert(::std::is_same<T, DimType>::value ||
2022 ::std::is_integral<T>::value,
2023 "Incorrect type passed to function DimType_Name.");
2024 return TensorBoundShape_DimType_Name(enum_t_value);
2025 }
2026 static inline bool DimType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
2027 DimType* value) {
2028 return TensorBoundShape_DimType_Parse(name, value);
2029 }
2030
2031 // accessors -------------------------------------------------------
2032
2033 enum : int {
2034 kDimTypeFieldNumber = 2,
2035 kNameFieldNumber = 3,
2036 kShapeFieldNumber = 1,
2037 kShapeIsFinalFieldNumber = 4,
2038 };
2039 // repeated .caffe2.TensorBoundShape.DimType dim_type = 2;
2040 int dim_type_size() const;
2041 private:
2042 int _internal_dim_type_size() const;
2043 public:
2044 void clear_dim_type();
2045 private:
2046 ::caffe2::TensorBoundShape_DimType _internal_dim_type(int index) const;
2047 void _internal_add_dim_type(::caffe2::TensorBoundShape_DimType value);
2048 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_dim_type();
2049 public:
2050 ::caffe2::TensorBoundShape_DimType dim_type(int index) const;
2051 void set_dim_type(int index, ::caffe2::TensorBoundShape_DimType value);
2052 void add_dim_type(::caffe2::TensorBoundShape_DimType value);
2053 const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& dim_type() const;
2054 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_dim_type();
2055
2056 // optional string name = 3;
2057 bool has_name() const;
2058 private:
2059 bool _internal_has_name() const;
2060 public:
2061 void clear_name();
2062 const std::string& name() const;
2063 void set_name(const std::string& value);
2064 void set_name(std::string&& value);
2065 void set_name(const char* value);
2066 void set_name(const char* value, size_t size);
2067 std::string* mutable_name();
2068 std::string* release_name();
2069 void set_allocated_name(std::string* name);
2070 private:
2071 const std::string& _internal_name() const;
2072 void _internal_set_name(const std::string& value);
2073 std::string* _internal_mutable_name();
2074 public:
2075
2076 // optional .caffe2.TensorShape shape = 1;
2077 bool has_shape() const;
2078 private:
2079 bool _internal_has_shape() const;
2080 public:
2081 void clear_shape();
2082 const ::caffe2::TensorShape& shape() const;
2083 ::caffe2::TensorShape* release_shape();
2084 ::caffe2::TensorShape* mutable_shape();
2085 void set_allocated_shape(::caffe2::TensorShape* shape);
2086 private:
2087 const ::caffe2::TensorShape& _internal_shape() const;
2088 ::caffe2::TensorShape* _internal_mutable_shape();
2089 public:
2090 void unsafe_arena_set_allocated_shape(
2091 ::caffe2::TensorShape* shape);
2092 ::caffe2::TensorShape* unsafe_arena_release_shape();
2093
2094 // optional bool shape_is_final = 4;
2095 bool has_shape_is_final() const;
2096 private:
2097 bool _internal_has_shape_is_final() const;
2098 public:
2099 void clear_shape_is_final();
2100 bool shape_is_final() const;
2101 void set_shape_is_final(bool value);
2102 private:
2103 bool _internal_shape_is_final() const;
2104 void _internal_set_shape_is_final(bool value);
2105 public:
2106
2107 // @@protoc_insertion_point(class_scope:caffe2.TensorBoundShape)
2108 private:
2109 class _Internal;
2110
2111 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2112 typedef void InternalArenaConstructable_;
2113 typedef void DestructorSkippable_;
2114 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2115 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2116 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> dim_type_;
2117 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
2118 ::caffe2::TensorShape* shape_;
2119 bool shape_is_final_;
2120 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
2121};
2122// -------------------------------------------------------------------
2123
2124class TORCH_API TensorBoundShapes PROTOBUF_FINAL :
2125 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorBoundShapes) */ {
2126 public:
2127 inline TensorBoundShapes() : TensorBoundShapes(nullptr) {}
2128 virtual ~TensorBoundShapes();
2129
2130 TensorBoundShapes(const TensorBoundShapes& from);
2131 TensorBoundShapes(TensorBoundShapes&& from) noexcept
2132 : TensorBoundShapes() {
2133 *this = ::std::move(from);
2134 }
2135
2136 inline TensorBoundShapes& operator=(const TensorBoundShapes& from) {
2137 CopyFrom(from);
2138 return *this;
2139 }
2140 inline TensorBoundShapes& operator=(TensorBoundShapes&& from) noexcept {
2141 if (GetArena() == from.GetArena()) {
2142 if (this != &from) InternalSwap(&from);
2143 } else {
2144 CopyFrom(from);
2145 }
2146 return *this;
2147 }
2148
2149 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
2150 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
2151 }
2152 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
2153 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
2154 }
2155
2156 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2157 return GetDescriptor();
2158 }
2159 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2160 return GetMetadataStatic().descriptor;
2161 }
2162 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2163 return GetMetadataStatic().reflection;
2164 }
2165 static const TensorBoundShapes& default_instance();
2166
2167 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2168 static inline const TensorBoundShapes* internal_default_instance() {
2169 return reinterpret_cast<const TensorBoundShapes*>(
2170 &_TensorBoundShapes_default_instance_);
2171 }
2172 static constexpr int kIndexInFileMessages =
2173 7;
2174
2175 friend void swap(TensorBoundShapes& a, TensorBoundShapes& b) {
2176 a.Swap(&b);
2177 }
2178 inline void Swap(TensorBoundShapes* other) {
2179 if (other == this) return;
2180 if (GetArena() == other->GetArena()) {
2181 InternalSwap(other);
2182 } else {
2183 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2184 }
2185 }
2186 void UnsafeArenaSwap(TensorBoundShapes* other) {
2187 if (other == this) return;
2188 GOOGLE_DCHECK(GetArena() == other->GetArena());
2189 InternalSwap(other);
2190 }
2191
2192 // implements Message ----------------------------------------------
2193
2194 inline TensorBoundShapes* New() const final {
2195 return CreateMaybeMessage<TensorBoundShapes>(nullptr);
2196 }
2197
2198 TensorBoundShapes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2199 return CreateMaybeMessage<TensorBoundShapes>(arena);
2200 }
2201 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2202 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2203 void CopyFrom(const TensorBoundShapes& from);
2204 void MergeFrom(const TensorBoundShapes& from);
2205 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2206 bool IsInitialized() const final;
2207
2208 size_t ByteSizeLong() const final;
2209 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2210 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
2211 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2212 int GetCachedSize() const final { return _cached_size_.Get(); }
2213
2214 private:
2215 inline void SharedCtor();
2216 inline void SharedDtor();
2217 void SetCachedSize(int size) const final;
2218 void InternalSwap(TensorBoundShapes* other);
2219 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2220 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2221 return "caffe2.TensorBoundShapes";
2222 }
2223 protected:
2224 explicit TensorBoundShapes(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2225 private:
2226 static void ArenaDtor(void* object);
2227 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2228 public:
2229
2230 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2231 private:
2232 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2233 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
2234 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
2235 }
2236
2237 public:
2238
2239 // nested types ----------------------------------------------------
2240
2241 // accessors -------------------------------------------------------
2242
2243 enum : int {
2244 kShapesFieldNumber = 1,
2245 kMaxBatchSizeFieldNumber = 2,
2246 kMaxFeatureLenFieldNumber = 3,
2247 };
2248 // repeated .caffe2.TensorBoundShape shapes = 1;
2249 int shapes_size() const;
2250 private:
2251 int _internal_shapes_size() const;
2252 public:
2253 void clear_shapes();
2254 ::caffe2::TensorBoundShape* mutable_shapes(int index);
2255 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape >*
2256 mutable_shapes();
2257 private:
2258 const ::caffe2::TensorBoundShape& _internal_shapes(int index) const;
2259 ::caffe2::TensorBoundShape* _internal_add_shapes();
2260 public:
2261 const ::caffe2::TensorBoundShape& shapes(int index) const;
2262 ::caffe2::TensorBoundShape* add_shapes();
2263 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape >&
2264 shapes() const;
2265
2266 // optional int64 max_batch_size = 2;
2267 bool has_max_batch_size() const;
2268 private:
2269 bool _internal_has_max_batch_size() const;
2270 public:
2271 void clear_max_batch_size();
2272 ::PROTOBUF_NAMESPACE_ID::int64 max_batch_size() const;
2273 void set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value);
2274 private:
2275 ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_batch_size() const;
2276 void _internal_set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value);
2277 public:
2278
2279 // optional int64 max_feature_len = 3;
2280 bool has_max_feature_len() const;
2281 private:
2282 bool _internal_has_max_feature_len() const;
2283 public:
2284 void clear_max_feature_len();
2285 ::PROTOBUF_NAMESPACE_ID::int64 max_feature_len() const;
2286 void set_max_feature_len(::PROTOBUF_NAMESPACE_ID::int64 value);
2287 private:
2288 ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_feature_len() const;
2289 void _internal_set_max_feature_len(::PROTOBUF_NAMESPACE_ID::int64 value);
2290 public:
2291
2292 // @@protoc_insertion_point(class_scope:caffe2.TensorBoundShapes)
2293 private:
2294 class _Internal;
2295
2296 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2297 typedef void InternalArenaConstructable_;
2298 typedef void DestructorSkippable_;
2299 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2300 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2301 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape > shapes_;
2302 ::PROTOBUF_NAMESPACE_ID::int64 max_batch_size_;
2303 ::PROTOBUF_NAMESPACE_ID::int64 max_feature_len_;
2304 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
2305};
2306// -------------------------------------------------------------------
2307
2308class TORCH_API AOTConfig PROTOBUF_FINAL :
2309 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.AOTConfig) */ {
2310 public:
2311 inline AOTConfig() : AOTConfig(nullptr) {}
2312 virtual ~AOTConfig();
2313
2314 AOTConfig(const AOTConfig& from);
2315 AOTConfig(AOTConfig&& from) noexcept
2316 : AOTConfig() {
2317 *this = ::std::move(from);
2318 }
2319
2320 inline AOTConfig& operator=(const AOTConfig& from) {
2321 CopyFrom(from);
2322 return *this;
2323 }
2324 inline AOTConfig& operator=(AOTConfig&& from) noexcept {
2325 if (GetArena() == from.GetArena()) {
2326 if (this != &from) InternalSwap(&from);
2327 } else {
2328 CopyFrom(from);
2329 }
2330 return *this;
2331 }
2332
2333 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
2334 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
2335 }
2336 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
2337 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
2338 }
2339
2340 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2341 return GetDescriptor();
2342 }
2343 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2344 return GetMetadataStatic().descriptor;
2345 }
2346 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2347 return GetMetadataStatic().reflection;
2348 }
2349 static const AOTConfig& default_instance();
2350
2351 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2352 static inline const AOTConfig* internal_default_instance() {
2353 return reinterpret_cast<const AOTConfig*>(
2354 &_AOTConfig_default_instance_);
2355 }
2356 static constexpr int kIndexInFileMessages =
2357 8;
2358
2359 friend void swap(AOTConfig& a, AOTConfig& b) {
2360 a.Swap(&b);
2361 }
2362 inline void Swap(AOTConfig* other) {
2363 if (other == this) return;
2364 if (GetArena() == other->GetArena()) {
2365 InternalSwap(other);
2366 } else {
2367 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2368 }
2369 }
2370 void UnsafeArenaSwap(AOTConfig* other) {
2371 if (other == this) return;
2372 GOOGLE_DCHECK(GetArena() == other->GetArena());
2373 InternalSwap(other);
2374 }
2375
2376 // implements Message ----------------------------------------------
2377
2378 inline AOTConfig* New() const final {
2379 return CreateMaybeMessage<AOTConfig>(nullptr);
2380 }
2381
2382 AOTConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2383 return CreateMaybeMessage<AOTConfig>(arena);
2384 }
2385 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2386 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2387 void CopyFrom(const AOTConfig& from);
2388 void MergeFrom(const AOTConfig& from);
2389 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2390 bool IsInitialized() const final;
2391
2392 size_t ByteSizeLong() const final;
2393 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2394 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
2395 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2396 int GetCachedSize() const final { return _cached_size_.Get(); }
2397
2398 private:
2399 inline void SharedCtor();
2400 inline void SharedDtor();
2401 void SetCachedSize(int size) const final;
2402 void InternalSwap(AOTConfig* other);
2403 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2404 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2405 return "caffe2.AOTConfig";
2406 }
2407 protected:
2408 explicit AOTConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2409 private:
2410 static void ArenaDtor(void* object);
2411 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2412 public:
2413
2414 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2415 private:
2416 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2417 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
2418 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
2419 }
2420
2421 public:
2422
2423 // nested types ----------------------------------------------------
2424
2425 // accessors -------------------------------------------------------
2426
2427 enum : int {
2428 kOnnxifiBlacklistOpsFieldNumber = 4,
2429 kMaxBatchSizeFieldNumber = 1,
2430 kMaxSeqSizeFieldNumber = 2,
2431 kInBatchBroadcastFieldNumber = 3,
2432 kOnnxifiMinOpsFieldNumber = 5,
2433 };
2434 // optional string onnxifi_blacklist_ops = 4;
2435 bool has_onnxifi_blacklist_ops() const;
2436 private:
2437 bool _internal_has_onnxifi_blacklist_ops() const;
2438 public:
2439 void clear_onnxifi_blacklist_ops();
2440 const std::string& onnxifi_blacklist_ops() const;
2441 void set_onnxifi_blacklist_ops(const std::string& value);
2442 void set_onnxifi_blacklist_ops(std::string&& value);
2443 void set_onnxifi_blacklist_ops(const char* value);
2444 void set_onnxifi_blacklist_ops(const char* value, size_t size);
2445 std::string* mutable_onnxifi_blacklist_ops();
2446 std::string* release_onnxifi_blacklist_ops();
2447 void set_allocated_onnxifi_blacklist_ops(std::string* onnxifi_blacklist_ops);
2448 private:
2449 const std::string& _internal_onnxifi_blacklist_ops() const;
2450 void _internal_set_onnxifi_blacklist_ops(const std::string& value);
2451 std::string* _internal_mutable_onnxifi_blacklist_ops();
2452 public:
2453
2454 // required int64 max_batch_size = 1;
2455 bool has_max_batch_size() const;
2456 private:
2457 bool _internal_has_max_batch_size() const;
2458 public:
2459 void clear_max_batch_size();
2460 ::PROTOBUF_NAMESPACE_ID::int64 max_batch_size() const;
2461 void set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value);
2462 private:
2463 ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_batch_size() const;
2464 void _internal_set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value);
2465 public:
2466
2467 // required int64 max_seq_size = 2;
2468 bool has_max_seq_size() const;
2469 private:
2470 bool _internal_has_max_seq_size() const;
2471 public:
2472 void clear_max_seq_size();
2473 ::PROTOBUF_NAMESPACE_ID::int64 max_seq_size() const;
2474 void set_max_seq_size(::PROTOBUF_NAMESPACE_ID::int64 value);
2475 private:
2476 ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_seq_size() const;
2477 void _internal_set_max_seq_size(::PROTOBUF_NAMESPACE_ID::int64 value);
2478 public:
2479
2480 // required bool in_batch_broadcast = 3;
2481 bool has_in_batch_broadcast() const;
2482 private:
2483 bool _internal_has_in_batch_broadcast() const;
2484 public:
2485 void clear_in_batch_broadcast();
2486 bool in_batch_broadcast() const;
2487 void set_in_batch_broadcast(bool value);
2488 private:
2489 bool _internal_in_batch_broadcast() const;
2490 void _internal_set_in_batch_broadcast(bool value);
2491 public:
2492
2493 // optional int32 onnxifi_min_ops = 5;
2494 bool has_onnxifi_min_ops() const;
2495 private:
2496 bool _internal_has_onnxifi_min_ops() const;
2497 public:
2498 void clear_onnxifi_min_ops();
2499 ::PROTOBUF_NAMESPACE_ID::int32 onnxifi_min_ops() const;
2500 void set_onnxifi_min_ops(::PROTOBUF_NAMESPACE_ID::int32 value);
2501 private:
2502 ::PROTOBUF_NAMESPACE_ID::int32 _internal_onnxifi_min_ops() const;
2503 void _internal_set_onnxifi_min_ops(::PROTOBUF_NAMESPACE_ID::int32 value);
2504 public:
2505
2506 // @@protoc_insertion_point(class_scope:caffe2.AOTConfig)
2507 private:
2508 class _Internal;
2509
2510 // helper for ByteSizeLong()
2511 size_t RequiredFieldsByteSizeFallback() const;
2512
2513 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2514 typedef void InternalArenaConstructable_;
2515 typedef void DestructorSkippable_;
2516 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2517 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2518 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr onnxifi_blacklist_ops_;
2519 ::PROTOBUF_NAMESPACE_ID::int64 max_batch_size_;
2520 ::PROTOBUF_NAMESPACE_ID::int64 max_seq_size_;
2521 bool in_batch_broadcast_;
2522 ::PROTOBUF_NAMESPACE_ID::int32 onnxifi_min_ops_;
2523 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
2524};
2525// -------------------------------------------------------------------
2526
2527class TORCH_API Argument PROTOBUF_FINAL :
2528 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.Argument) */ {
2529 public:
2530 inline Argument() : Argument(nullptr) {}
2531 virtual ~Argument();
2532
2533 Argument(const Argument& from);
2534 Argument(Argument&& from) noexcept
2535 : Argument() {
2536 *this = ::std::move(from);
2537 }
2538
2539 inline Argument& operator=(const Argument& from) {
2540 CopyFrom(from);
2541 return *this;
2542 }
2543 inline Argument& operator=(Argument&& from) noexcept {
2544 if (GetArena() == from.GetArena()) {
2545 if (this != &from) InternalSwap(&from);
2546 } else {
2547 CopyFrom(from);
2548 }
2549 return *this;
2550 }
2551
2552 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
2553 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
2554 }
2555 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
2556 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
2557 }
2558
2559 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2560 return GetDescriptor();
2561 }
2562 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2563 return GetMetadataStatic().descriptor;
2564 }
2565 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2566 return GetMetadataStatic().reflection;
2567 }
2568 static const Argument& default_instance();
2569
2570 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2571 static inline const Argument* internal_default_instance() {
2572 return reinterpret_cast<const Argument*>(
2573 &_Argument_default_instance_);
2574 }
2575 static constexpr int kIndexInFileMessages =
2576 9;
2577
2578 friend void swap(Argument& a, Argument& b) {
2579 a.Swap(&b);
2580 }
2581 inline void Swap(Argument* other) {
2582 if (other == this) return;
2583 if (GetArena() == other->GetArena()) {
2584 InternalSwap(other);
2585 } else {
2586 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2587 }
2588 }
2589 void UnsafeArenaSwap(Argument* other) {
2590 if (other == this) return;
2591 GOOGLE_DCHECK(GetArena() == other->GetArena());
2592 InternalSwap(other);
2593 }
2594
2595 // implements Message ----------------------------------------------
2596
2597 inline Argument* New() const final {
2598 return CreateMaybeMessage<Argument>(nullptr);
2599 }
2600
2601 Argument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2602 return CreateMaybeMessage<Argument>(arena);
2603 }
2604 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2605 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2606 void CopyFrom(const Argument& from);
2607 void MergeFrom(const Argument& from);
2608 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2609 bool IsInitialized() const final;
2610
2611 size_t ByteSizeLong() const final;
2612 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2613 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
2614 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2615 int GetCachedSize() const final { return _cached_size_.Get(); }
2616
2617 private:
2618 inline void SharedCtor();
2619 inline void SharedDtor();
2620 void SetCachedSize(int size) const final;
2621 void InternalSwap(Argument* other);
2622 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2623 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2624 return "caffe2.Argument";
2625 }
2626 protected:
2627 explicit Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2628 private:
2629 static void ArenaDtor(void* object);
2630 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2631 public:
2632
2633 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2634 private:
2635 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2636 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
2637 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
2638 }
2639
2640 public:
2641
2642 // nested types ----------------------------------------------------
2643
2644 // accessors -------------------------------------------------------
2645
2646 enum : int {
2647 kFloatsFieldNumber = 5,
2648 kIntsFieldNumber = 6,
2649 kStringsFieldNumber = 7,
2650 kNetsFieldNumber = 9,
2651 kTensorsFieldNumber = 11,
2652 kQtensorsFieldNumber = 12,
2653 kNameFieldNumber = 1,
2654 kSFieldNumber = 4,
2655 kNFieldNumber = 8,
2656 kTFieldNumber = 10,
2657 kIFieldNumber = 3,
2658 kFFieldNumber = 2,
2659 };
2660 // repeated float floats = 5;
2661 int floats_size() const;
2662 private:
2663 int _internal_floats_size() const;
2664 public:
2665 void clear_floats();
2666 private:
2667 float _internal_floats(int index) const;
2668 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
2669 _internal_floats() const;
2670 void _internal_add_floats(float value);
2671 ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
2672 _internal_mutable_floats();
2673 public:
2674 float floats(int index) const;
2675 void set_floats(int index, float value);
2676 void add_floats(float value);
2677 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
2678 floats() const;
2679 ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
2680 mutable_floats();
2681
2682 // repeated int64 ints = 6;
2683 int ints_size() const;
2684 private:
2685 int _internal_ints_size() const;
2686 public:
2687 void clear_ints();
2688 private:
2689 ::PROTOBUF_NAMESPACE_ID::int64 _internal_ints(int index) const;
2690 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
2691 _internal_ints() const;
2692 void _internal_add_ints(::PROTOBUF_NAMESPACE_ID::int64 value);
2693 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
2694 _internal_mutable_ints();
2695 public:
2696 ::PROTOBUF_NAMESPACE_ID::int64 ints(int index) const;
2697 void set_ints(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
2698 void add_ints(::PROTOBUF_NAMESPACE_ID::int64 value);
2699 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
2700 ints() const;
2701 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
2702 mutable_ints();
2703
2704 // repeated bytes strings = 7;
2705 int strings_size() const;
2706 private:
2707 int _internal_strings_size() const;
2708 public:
2709 void clear_strings();
2710 const std::string& strings(int index) const;
2711 std::string* mutable_strings(int index);
2712 void set_strings(int index, const std::string& value);
2713 void set_strings(int index, std::string&& value);
2714 void set_strings(int index, const char* value);
2715 void set_strings(int index, const void* value, size_t size);
2716 std::string* add_strings();
2717 void add_strings(const std::string& value);
2718 void add_strings(std::string&& value);
2719 void add_strings(const char* value);
2720 void add_strings(const void* value, size_t size);
2721 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& strings() const;
2722 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_strings();
2723 private:
2724 const std::string& _internal_strings(int index) const;
2725 std::string* _internal_add_strings();
2726 public:
2727
2728 // repeated .caffe2.NetDef nets = 9;
2729 int nets_size() const;
2730 private:
2731 int _internal_nets_size() const;
2732 public:
2733 void clear_nets();
2734 ::caffe2::NetDef* mutable_nets(int index);
2735 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >*
2736 mutable_nets();
2737 private:
2738 const ::caffe2::NetDef& _internal_nets(int index) const;
2739 ::caffe2::NetDef* _internal_add_nets();
2740 public:
2741 const ::caffe2::NetDef& nets(int index) const;
2742 ::caffe2::NetDef* add_nets();
2743 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >&
2744 nets() const;
2745
2746 // repeated .caffe2.TensorProto tensors = 11;
2747 int tensors_size() const;
2748 private:
2749 int _internal_tensors_size() const;
2750 public:
2751 void clear_tensors();
2752 ::caffe2::TensorProto* mutable_tensors(int index);
2753 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >*
2754 mutable_tensors();
2755 private:
2756 const ::caffe2::TensorProto& _internal_tensors(int index) const;
2757 ::caffe2::TensorProto* _internal_add_tensors();
2758 public:
2759 const ::caffe2::TensorProto& tensors(int index) const;
2760 ::caffe2::TensorProto* add_tensors();
2761 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >&
2762 tensors() const;
2763
2764 // repeated .caffe2.QTensorProto qtensors = 12;
2765 int qtensors_size() const;
2766 private:
2767 int _internal_qtensors_size() const;
2768 public:
2769 void clear_qtensors();
2770 ::caffe2::QTensorProto* mutable_qtensors(int index);
2771 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto >*
2772 mutable_qtensors();
2773 private:
2774 const ::caffe2::QTensorProto& _internal_qtensors(int index) const;
2775 ::caffe2::QTensorProto* _internal_add_qtensors();
2776 public:
2777 const ::caffe2::QTensorProto& qtensors(int index) const;
2778 ::caffe2::QTensorProto* add_qtensors();
2779 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto >&
2780 qtensors() const;
2781
2782 // optional string name = 1;
2783 bool has_name() const;
2784 private:
2785 bool _internal_has_name() const;
2786 public:
2787 void clear_name();
2788 const std::string& name() const;
2789 void set_name(const std::string& value);
2790 void set_name(std::string&& value);
2791 void set_name(const char* value);
2792 void set_name(const char* value, size_t size);
2793 std::string* mutable_name();
2794 std::string* release_name();
2795 void set_allocated_name(std::string* name);
2796 private:
2797 const std::string& _internal_name() const;
2798 void _internal_set_name(const std::string& value);
2799 std::string* _internal_mutable_name();
2800 public:
2801
2802 // optional bytes s = 4;
2803 bool has_s() const;
2804 private:
2805 bool _internal_has_s() const;
2806 public:
2807 void clear_s();
2808 const std::string& s() const;
2809 void set_s(const std::string& value);
2810 void set_s(std::string&& value);
2811 void set_s(const char* value);
2812 void set_s(const void* value, size_t size);
2813 std::string* mutable_s();
2814 std::string* release_s();
2815 void set_allocated_s(std::string* s);
2816 private:
2817 const std::string& _internal_s() const;
2818 void _internal_set_s(const std::string& value);
2819 std::string* _internal_mutable_s();
2820 public:
2821
2822 // optional .caffe2.NetDef n = 8;
2823 bool has_n() const;
2824 private:
2825 bool _internal_has_n() const;
2826 public:
2827 void clear_n();
2828 const ::caffe2::NetDef& n() const;
2829 ::caffe2::NetDef* release_n();
2830 ::caffe2::NetDef* mutable_n();
2831 void set_allocated_n(::caffe2::NetDef* n);
2832 private:
2833 const ::caffe2::NetDef& _internal_n() const;
2834 ::caffe2::NetDef* _internal_mutable_n();
2835 public:
2836 void unsafe_arena_set_allocated_n(
2837 ::caffe2::NetDef* n);
2838 ::caffe2::NetDef* unsafe_arena_release_n();
2839
2840 // optional .caffe2.TensorProto t = 10;
2841 bool has_t() const;
2842 private:
2843 bool _internal_has_t() const;
2844 public:
2845 void clear_t();
2846 const ::caffe2::TensorProto& t() const;
2847 ::caffe2::TensorProto* release_t();
2848 ::caffe2::TensorProto* mutable_t();
2849 void set_allocated_t(::caffe2::TensorProto* t);
2850 private:
2851 const ::caffe2::TensorProto& _internal_t() const;
2852 ::caffe2::TensorProto* _internal_mutable_t();
2853 public:
2854 void unsafe_arena_set_allocated_t(
2855 ::caffe2::TensorProto* t);
2856 ::caffe2::TensorProto* unsafe_arena_release_t();
2857
2858 // optional int64 i = 3;
2859 bool has_i() const;
2860 private:
2861 bool _internal_has_i() const;
2862 public:
2863 void clear_i();
2864 ::PROTOBUF_NAMESPACE_ID::int64 i() const;
2865 void set_i(::PROTOBUF_NAMESPACE_ID::int64 value);
2866 private:
2867 ::PROTOBUF_NAMESPACE_ID::int64 _internal_i() const;
2868 void _internal_set_i(::PROTOBUF_NAMESPACE_ID::int64 value);
2869 public:
2870
2871 // optional float f = 2;
2872 bool has_f() const;
2873 private:
2874 bool _internal_has_f() const;
2875 public:
2876 void clear_f();
2877 float f() const;
2878 void set_f(float value);
2879 private:
2880 float _internal_f() const;
2881 void _internal_set_f(float value);
2882 public:
2883
2884 // @@protoc_insertion_point(class_scope:caffe2.Argument)
2885 private:
2886 class _Internal;
2887
2888 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2889 typedef void InternalArenaConstructable_;
2890 typedef void DestructorSkippable_;
2891 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2892 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2893 ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > floats_;
2894 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > ints_;
2895 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> strings_;
2896 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef > nets_;
2897 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto > tensors_;
2898 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto > qtensors_;
2899 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
2900 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr s_;
2901 ::caffe2::NetDef* n_;
2902 ::caffe2::TensorProto* t_;
2903 ::PROTOBUF_NAMESPACE_ID::int64 i_;
2904 float f_;
2905 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
2906};
2907// -------------------------------------------------------------------
2908
2909class TORCH_API DeviceOption PROTOBUF_FINAL :
2910 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.DeviceOption) */ {
2911 public:
2912 inline DeviceOption() : DeviceOption(nullptr) {}
2913 virtual ~DeviceOption();
2914
2915 DeviceOption(const DeviceOption& from);
2916 DeviceOption(DeviceOption&& from) noexcept
2917 : DeviceOption() {
2918 *this = ::std::move(from);
2919 }
2920
2921 inline DeviceOption& operator=(const DeviceOption& from) {
2922 CopyFrom(from);
2923 return *this;
2924 }
2925 inline DeviceOption& operator=(DeviceOption&& from) noexcept {
2926 if (GetArena() == from.GetArena()) {
2927 if (this != &from) InternalSwap(&from);
2928 } else {
2929 CopyFrom(from);
2930 }
2931 return *this;
2932 }
2933
2934 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
2935 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
2936 }
2937 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
2938 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
2939 }
2940
2941 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2942 return GetDescriptor();
2943 }
2944 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2945 return GetMetadataStatic().descriptor;
2946 }
2947 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2948 return GetMetadataStatic().reflection;
2949 }
2950 static const DeviceOption& default_instance();
2951
2952 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2953 static inline const DeviceOption* internal_default_instance() {
2954 return reinterpret_cast<const DeviceOption*>(
2955 &_DeviceOption_default_instance_);
2956 }
2957 static constexpr int kIndexInFileMessages =
2958 10;
2959
2960 friend void swap(DeviceOption& a, DeviceOption& b) {
2961 a.Swap(&b);
2962 }
2963 inline void Swap(DeviceOption* other) {
2964 if (other == this) return;
2965 if (GetArena() == other->GetArena()) {
2966 InternalSwap(other);
2967 } else {
2968 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2969 }
2970 }
2971 void UnsafeArenaSwap(DeviceOption* other) {
2972 if (other == this) return;
2973 GOOGLE_DCHECK(GetArena() == other->GetArena());
2974 InternalSwap(other);
2975 }
2976
2977 // implements Message ----------------------------------------------
2978
2979 inline DeviceOption* New() const final {
2980 return CreateMaybeMessage<DeviceOption>(nullptr);
2981 }
2982
2983 DeviceOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2984 return CreateMaybeMessage<DeviceOption>(arena);
2985 }
2986 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2987 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2988 void CopyFrom(const DeviceOption& from);
2989 void MergeFrom(const DeviceOption& from);
2990 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2991 bool IsInitialized() const final;
2992
2993 size_t ByteSizeLong() const final;
2994 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2995 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
2996 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2997 int GetCachedSize() const final { return _cached_size_.Get(); }
2998
2999 private:
3000 inline void SharedCtor();
3001 inline void SharedDtor();
3002 void SetCachedSize(int size) const final;
3003 void InternalSwap(DeviceOption* other);
3004 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3005 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3006 return "caffe2.DeviceOption";
3007 }
3008 protected:
3009 explicit DeviceOption(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3010 private:
3011 static void ArenaDtor(void* object);
3012 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3013 public:
3014
3015 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3016 private:
3017 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
3018 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
3019 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
3020 }
3021
3022 public:
3023
3024 // nested types ----------------------------------------------------
3025
3026 // accessors -------------------------------------------------------
3027
3028 enum : int {
3029 kExtraInfoFieldNumber = 6,
3030 kNodeNameFieldNumber = 4,
3031 kDeviceTypeFieldNumber = 1,
3032 kDeviceIdFieldNumber = 2,
3033 kRandomSeedFieldNumber = 3,
3034 kNumaNodeIdFieldNumber = 5,
3035 };
3036 // repeated string extra_info = 6;
3037 int extra_info_size() const;
3038 private:
3039 int _internal_extra_info_size() const;
3040 public:
3041 void clear_extra_info();
3042 const std::string& extra_info(int index) const;
3043 std::string* mutable_extra_info(int index);
3044 void set_extra_info(int index, const std::string& value);
3045 void set_extra_info(int index, std::string&& value);
3046 void set_extra_info(int index, const char* value);
3047 void set_extra_info(int index, const char* value, size_t size);
3048 std::string* add_extra_info();
3049 void add_extra_info(const std::string& value);
3050 void add_extra_info(std::string&& value);
3051 void add_extra_info(const char* value);
3052 void add_extra_info(const char* value, size_t size);
3053 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& extra_info() const;
3054 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_extra_info();
3055 private:
3056 const std::string& _internal_extra_info(int index) const;
3057 std::string* _internal_add_extra_info();
3058 public:
3059
3060 // optional string node_name = 4;
3061 bool has_node_name() const;
3062 private:
3063 bool _internal_has_node_name() const;
3064 public:
3065 void clear_node_name();
3066 const std::string& node_name() const;
3067 void set_node_name(const std::string& value);
3068 void set_node_name(std::string&& value);
3069 void set_node_name(const char* value);
3070 void set_node_name(const char* value, size_t size);
3071 std::string* mutable_node_name();
3072 std::string* release_node_name();
3073 void set_allocated_node_name(std::string* node_name);
3074 private:
3075 const std::string& _internal_node_name() const;
3076 void _internal_set_node_name(const std::string& value);
3077 std::string* _internal_mutable_node_name();
3078 public:
3079
3080 // optional int32 device_type = 1 [default = 0];
3081 bool has_device_type() const;
3082 private:
3083 bool _internal_has_device_type() const;
3084 public:
3085 void clear_device_type();
3086 ::PROTOBUF_NAMESPACE_ID::int32 device_type() const;
3087 void set_device_type(::PROTOBUF_NAMESPACE_ID::int32 value);
3088 private:
3089 ::PROTOBUF_NAMESPACE_ID::int32 _internal_device_type() const;
3090 void _internal_set_device_type(::PROTOBUF_NAMESPACE_ID::int32 value);
3091 public:
3092
3093 // optional int32 device_id = 2;
3094 bool has_device_id() const;
3095 private:
3096 bool _internal_has_device_id() const;
3097 public:
3098 void clear_device_id();
3099 ::PROTOBUF_NAMESPACE_ID::int32 device_id() const;
3100 void set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value);
3101 private:
3102 ::PROTOBUF_NAMESPACE_ID::int32 _internal_device_id() const;
3103 void _internal_set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value);
3104 public:
3105
3106 // optional uint32 random_seed = 3;
3107 bool has_random_seed() const;
3108 private:
3109 bool _internal_has_random_seed() const;
3110 public:
3111 void clear_random_seed();
3112 ::PROTOBUF_NAMESPACE_ID::uint32 random_seed() const;
3113 void set_random_seed(::PROTOBUF_NAMESPACE_ID::uint32 value);
3114 private:
3115 ::PROTOBUF_NAMESPACE_ID::uint32 _internal_random_seed() const;
3116 void _internal_set_random_seed(::PROTOBUF_NAMESPACE_ID::uint32 value);
3117 public:
3118
3119 // optional int32 numa_node_id = 5;
3120 bool has_numa_node_id() const;
3121 private:
3122 bool _internal_has_numa_node_id() const;
3123 public:
3124 void clear_numa_node_id();
3125 ::PROTOBUF_NAMESPACE_ID::int32 numa_node_id() const;
3126 void set_numa_node_id(::PROTOBUF_NAMESPACE_ID::int32 value);
3127 private:
3128 ::PROTOBUF_NAMESPACE_ID::int32 _internal_numa_node_id() const;
3129 void _internal_set_numa_node_id(::PROTOBUF_NAMESPACE_ID::int32 value);
3130 public:
3131
3132 // @@protoc_insertion_point(class_scope:caffe2.DeviceOption)
3133 private:
3134 class _Internal;
3135
3136 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3137 typedef void InternalArenaConstructable_;
3138 typedef void DestructorSkippable_;
3139 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3140 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3141 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> extra_info_;
3142 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr node_name_;
3143 ::PROTOBUF_NAMESPACE_ID::int32 device_type_;
3144 ::PROTOBUF_NAMESPACE_ID::int32 device_id_;
3145 ::PROTOBUF_NAMESPACE_ID::uint32 random_seed_;
3146 ::PROTOBUF_NAMESPACE_ID::int32 numa_node_id_;
3147 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
3148};
3149// -------------------------------------------------------------------
3150
3151class TORCH_API OperatorDef PROTOBUF_FINAL :
3152 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.OperatorDef) */ {
3153 public:
3154 inline OperatorDef() : OperatorDef(nullptr) {}
3155 virtual ~OperatorDef();
3156
3157 OperatorDef(const OperatorDef& from);
3158 OperatorDef(OperatorDef&& from) noexcept
3159 : OperatorDef() {
3160 *this = ::std::move(from);
3161 }
3162
3163 inline OperatorDef& operator=(const OperatorDef& from) {
3164 CopyFrom(from);
3165 return *this;
3166 }
3167 inline OperatorDef& operator=(OperatorDef&& from) noexcept {
3168 if (GetArena() == from.GetArena()) {
3169 if (this != &from) InternalSwap(&from);
3170 } else {
3171 CopyFrom(from);
3172 }
3173 return *this;
3174 }
3175
3176 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
3177 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
3178 }
3179 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
3180 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
3181 }
3182
3183 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3184 return GetDescriptor();
3185 }
3186 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3187 return GetMetadataStatic().descriptor;
3188 }
3189 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3190 return GetMetadataStatic().reflection;
3191 }
3192 static const OperatorDef& default_instance();
3193
3194 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3195 static inline const OperatorDef* internal_default_instance() {
3196 return reinterpret_cast<const OperatorDef*>(
3197 &_OperatorDef_default_instance_);
3198 }
3199 static constexpr int kIndexInFileMessages =
3200 11;
3201
3202 friend void swap(OperatorDef& a, OperatorDef& b) {
3203 a.Swap(&b);
3204 }
3205 inline void Swap(OperatorDef* other) {
3206 if (other == this) return;
3207 if (GetArena() == other->GetArena()) {
3208 InternalSwap(other);
3209 } else {
3210 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3211 }
3212 }
3213 void UnsafeArenaSwap(OperatorDef* other) {
3214 if (other == this) return;
3215 GOOGLE_DCHECK(GetArena() == other->GetArena());
3216 InternalSwap(other);
3217 }
3218
3219 // implements Message ----------------------------------------------
3220
3221 inline OperatorDef* New() const final {
3222 return CreateMaybeMessage<OperatorDef>(nullptr);
3223 }
3224
3225 OperatorDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3226 return CreateMaybeMessage<OperatorDef>(arena);
3227 }
3228 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3229 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3230 void CopyFrom(const OperatorDef& from);
3231 void MergeFrom(const OperatorDef& from);
3232 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3233 bool IsInitialized() const final;
3234
3235 size_t ByteSizeLong() const final;
3236 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3237 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
3238 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3239 int GetCachedSize() const final { return _cached_size_.Get(); }
3240
3241 private:
3242 inline void SharedCtor();
3243 inline void SharedDtor();
3244 void SetCachedSize(int size) const final;
3245 void InternalSwap(OperatorDef* other);
3246 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3247 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3248 return "caffe2.OperatorDef";
3249 }
3250 protected:
3251 explicit OperatorDef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3252 private:
3253 static void ArenaDtor(void* object);
3254 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3255 public:
3256
3257 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3258 private:
3259 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
3260 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
3261 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
3262 }
3263
3264 public:
3265
3266 // nested types ----------------------------------------------------
3267
3268 // accessors -------------------------------------------------------
3269
3270 enum : int {
3271 kInputFieldNumber = 1,
3272 kOutputFieldNumber = 2,
3273 kArgFieldNumber = 5,
3274 kControlInputFieldNumber = 8,
3275 kNameFieldNumber = 3,
3276 kTypeFieldNumber = 4,
3277 kEngineFieldNumber = 7,
3278 kDebugInfoFieldNumber = 10,
3279 kDomainFieldNumber = 11,
3280 kDeviceOptionFieldNumber = 6,
3281 kOpVersionFieldNumber = 12,
3282 kIsGradientOpFieldNumber = 9,
3283 };
3284 // repeated string input = 1;
3285 int input_size() const;
3286 private:
3287 int _internal_input_size() const;
3288 public:
3289 void clear_input();
3290 const std::string& input(int index) const;
3291 std::string* mutable_input(int index);
3292 void set_input(int index, const std::string& value);
3293 void set_input(int index, std::string&& value);
3294 void set_input(int index, const char* value);
3295 void set_input(int index, const char* value, size_t size);
3296 std::string* add_input();
3297 void add_input(const std::string& value);
3298 void add_input(std::string&& value);
3299 void add_input(const char* value);
3300 void add_input(const char* value, size_t size);
3301 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input() const;
3302 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input();
3303 private:
3304 const std::string& _internal_input(int index) const;
3305 std::string* _internal_add_input();
3306 public:
3307
3308 // repeated string output = 2;
3309 int output_size() const;
3310 private:
3311 int _internal_output_size() const;
3312 public:
3313 void clear_output();
3314 const std::string& output(int index) const;
3315 std::string* mutable_output(int index);
3316 void set_output(int index, const std::string& value);
3317 void set_output(int index, std::string&& value);
3318 void set_output(int index, const char* value);
3319 void set_output(int index, const char* value, size_t size);
3320 std::string* add_output();
3321 void add_output(const std::string& value);
3322 void add_output(std::string&& value);
3323 void add_output(const char* value);
3324 void add_output(const char* value, size_t size);
3325 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& output() const;
3326 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_output();
3327 private:
3328 const std::string& _internal_output(int index) const;
3329 std::string* _internal_add_output();
3330 public:
3331
3332 // repeated .caffe2.Argument arg = 5;
3333 int arg_size() const;
3334 private:
3335 int _internal_arg_size() const;
3336 public:
3337 void clear_arg();
3338 ::caffe2::Argument* mutable_arg(int index);
3339 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >*
3340 mutable_arg();
3341 private:
3342 const ::caffe2::Argument& _internal_arg(int index) const;
3343 ::caffe2::Argument* _internal_add_arg();
3344 public:
3345 const ::caffe2::Argument& arg(int index) const;
3346 ::caffe2::Argument* add_arg();
3347 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >&
3348 arg() const;
3349
3350 // repeated string control_input = 8;
3351 int control_input_size() const;
3352 private:
3353 int _internal_control_input_size() const;
3354 public:
3355 void clear_control_input();
3356 const std::string& control_input(int index) const;
3357 std::string* mutable_control_input(int index);
3358 void set_control_input(int index, const std::string& value);
3359 void set_control_input(int index, std::string&& value);
3360 void set_control_input(int index, const char* value);
3361 void set_control_input(int index, const char* value, size_t size);
3362 std::string* add_control_input();
3363 void add_control_input(const std::string& value);
3364 void add_control_input(std::string&& value);
3365 void add_control_input(const char* value);
3366 void add_control_input(const char* value, size_t size);
3367 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& control_input() const;
3368 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_control_input();
3369 private:
3370 const std::string& _internal_control_input(int index) const;
3371 std::string* _internal_add_control_input();
3372 public:
3373
3374 // optional string name = 3;
3375 bool has_name() const;
3376 private:
3377 bool _internal_has_name() const;
3378 public:
3379 void clear_name();
3380 const std::string& name() const;
3381 void set_name(const std::string& value);
3382 void set_name(std::string&& value);
3383 void set_name(const char* value);
3384 void set_name(const char* value, size_t size);
3385 std::string* mutable_name();
3386 std::string* release_name();
3387 void set_allocated_name(std::string* name);
3388 private:
3389 const std::string& _internal_name() const;
3390 void _internal_set_name(const std::string& value);
3391 std::string* _internal_mutable_name();
3392 public:
3393
3394 // optional string type = 4;
3395 bool has_type() const;
3396 private:
3397 bool _internal_has_type() const;
3398 public:
3399 void clear_type();
3400 const std::string& type() const;
3401 void set_type(const std::string& value);
3402 void set_type(std::string&& value);
3403 void set_type(const char* value);
3404 void set_type(const char* value, size_t size);
3405 std::string* mutable_type();
3406 std::string* release_type();
3407 void set_allocated_type(std::string* type);
3408 private:
3409 const std::string& _internal_type() const;
3410 void _internal_set_type(const std::string& value);
3411 std::string* _internal_mutable_type();
3412 public:
3413
3414 // optional string engine = 7;
3415 bool has_engine() const;
3416 private:
3417 bool _internal_has_engine() const;
3418 public:
3419 void clear_engine();
3420 const std::string& engine() const;
3421 void set_engine(const std::string& value);
3422 void set_engine(std::string&& value);
3423 void set_engine(const char* value);
3424 void set_engine(const char* value, size_t size);
3425 std::string* mutable_engine();
3426 std::string* release_engine();
3427 void set_allocated_engine(std::string* engine);
3428 private:
3429 const std::string& _internal_engine() const;
3430 void _internal_set_engine(const std::string& value);
3431 std::string* _internal_mutable_engine();
3432 public:
3433
3434 // optional string debug_info = 10;
3435 bool has_debug_info() const;
3436 private:
3437 bool _internal_has_debug_info() const;
3438 public:
3439 void clear_debug_info();
3440 const std::string& debug_info() const;
3441 void set_debug_info(const std::string& value);
3442 void set_debug_info(std::string&& value);
3443 void set_debug_info(const char* value);
3444 void set_debug_info(const char* value, size_t size);
3445 std::string* mutable_debug_info();
3446 std::string* release_debug_info();
3447 void set_allocated_debug_info(std::string* debug_info);
3448 private:
3449 const std::string& _internal_debug_info() const;
3450 void _internal_set_debug_info(const std::string& value);
3451 std::string* _internal_mutable_debug_info();
3452 public:
3453
3454 // optional string domain = 11;
3455 bool has_domain() const;
3456 private:
3457 bool _internal_has_domain() const;
3458 public:
3459 void clear_domain();
3460 const std::string& domain() const;
3461 void set_domain(const std::string& value);
3462 void set_domain(std::string&& value);
3463 void set_domain(const char* value);
3464 void set_domain(const char* value, size_t size);
3465 std::string* mutable_domain();
3466 std::string* release_domain();
3467 void set_allocated_domain(std::string* domain);
3468 private:
3469 const std::string& _internal_domain() const;
3470 void _internal_set_domain(const std::string& value);
3471 std::string* _internal_mutable_domain();
3472 public:
3473
3474 // optional .caffe2.DeviceOption device_option = 6;
3475 bool has_device_option() const;
3476 private:
3477 bool _internal_has_device_option() const;
3478 public:
3479 void clear_device_option();
3480 const ::caffe2::DeviceOption& device_option() const;
3481 ::caffe2::DeviceOption* release_device_option();
3482 ::caffe2::DeviceOption* mutable_device_option();
3483 void set_allocated_device_option(::caffe2::DeviceOption* device_option);
3484 private:
3485 const ::caffe2::DeviceOption& _internal_device_option() const;
3486 ::caffe2::DeviceOption* _internal_mutable_device_option();
3487 public:
3488 void unsafe_arena_set_allocated_device_option(
3489 ::caffe2::DeviceOption* device_option);
3490 ::caffe2::DeviceOption* unsafe_arena_release_device_option();
3491
3492 // optional int64 op_version = 12;
3493 bool has_op_version() const;
3494 private:
3495 bool _internal_has_op_version() const;
3496 public:
3497 void clear_op_version();
3498 ::PROTOBUF_NAMESPACE_ID::int64 op_version() const;
3499 void set_op_version(::PROTOBUF_NAMESPACE_ID::int64 value);
3500 private:
3501 ::PROTOBUF_NAMESPACE_ID::int64 _internal_op_version() const;
3502 void _internal_set_op_version(::PROTOBUF_NAMESPACE_ID::int64 value);
3503 public:
3504
3505 // optional bool is_gradient_op = 9 [default = false];
3506 bool has_is_gradient_op() const;
3507 private:
3508 bool _internal_has_is_gradient_op() const;
3509 public:
3510 void clear_is_gradient_op();
3511 bool is_gradient_op() const;
3512 void set_is_gradient_op(bool value);
3513 private:
3514 bool _internal_is_gradient_op() const;
3515 void _internal_set_is_gradient_op(bool value);
3516 public:
3517
3518 // @@protoc_insertion_point(class_scope:caffe2.OperatorDef)
3519 private:
3520 class _Internal;
3521
3522 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3523 typedef void InternalArenaConstructable_;
3524 typedef void DestructorSkippable_;
3525 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3526 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3527 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_;
3528 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> output_;
3529 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument > arg_;
3530 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> control_input_;
3531 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
3532 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
3533 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr engine_;
3534 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr debug_info_;
3535 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
3536 ::caffe2::DeviceOption* device_option_;
3537 ::PROTOBUF_NAMESPACE_ID::int64 op_version_;
3538 bool is_gradient_op_;
3539 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
3540};
3541// -------------------------------------------------------------------
3542
3543class TORCH_API MapFieldEntry PROTOBUF_FINAL :
3544 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.MapFieldEntry) */ {
3545 public:
3546 inline MapFieldEntry() : MapFieldEntry(nullptr) {}
3547 virtual ~MapFieldEntry();
3548
3549 MapFieldEntry(const MapFieldEntry& from);
3550 MapFieldEntry(MapFieldEntry&& from) noexcept
3551 : MapFieldEntry() {
3552 *this = ::std::move(from);
3553 }
3554
3555 inline MapFieldEntry& operator=(const MapFieldEntry& from) {
3556 CopyFrom(from);
3557 return *this;
3558 }
3559 inline MapFieldEntry& operator=(MapFieldEntry&& from) noexcept {
3560 if (GetArena() == from.GetArena()) {
3561 if (this != &from) InternalSwap(&from);
3562 } else {
3563 CopyFrom(from);
3564 }
3565 return *this;
3566 }
3567
3568 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
3569 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
3570 }
3571 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
3572 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
3573 }
3574
3575 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3576 return GetDescriptor();
3577 }
3578 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3579 return GetMetadataStatic().descriptor;
3580 }
3581 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3582 return GetMetadataStatic().reflection;
3583 }
3584 static const MapFieldEntry& default_instance();
3585
3586 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3587 static inline const MapFieldEntry* internal_default_instance() {
3588 return reinterpret_cast<const MapFieldEntry*>(
3589 &_MapFieldEntry_default_instance_);
3590 }
3591 static constexpr int kIndexInFileMessages =
3592 12;
3593
3594 friend void swap(MapFieldEntry& a, MapFieldEntry& b) {
3595 a.Swap(&b);
3596 }
3597 inline void Swap(MapFieldEntry* other) {
3598 if (other == this) return;
3599 if (GetArena() == other->GetArena()) {
3600 InternalSwap(other);
3601 } else {
3602 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3603 }
3604 }
3605 void UnsafeArenaSwap(MapFieldEntry* other) {
3606 if (other == this) return;
3607 GOOGLE_DCHECK(GetArena() == other->GetArena());
3608 InternalSwap(other);
3609 }
3610
3611 // implements Message ----------------------------------------------
3612
3613 inline MapFieldEntry* New() const final {
3614 return CreateMaybeMessage<MapFieldEntry>(nullptr);
3615 }
3616
3617 MapFieldEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3618 return CreateMaybeMessage<MapFieldEntry>(arena);
3619 }
3620 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3621 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3622 void CopyFrom(const MapFieldEntry& from);
3623 void MergeFrom(const MapFieldEntry& from);
3624 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3625 bool IsInitialized() const final;
3626
3627 size_t ByteSizeLong() const final;
3628 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3629 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
3630 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3631 int GetCachedSize() const final { return _cached_size_.Get(); }
3632
3633 private:
3634 inline void SharedCtor();
3635 inline void SharedDtor();
3636 void SetCachedSize(int size) const final;
3637 void InternalSwap(MapFieldEntry* other);
3638 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3639 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3640 return "caffe2.MapFieldEntry";
3641 }
3642 protected:
3643 explicit MapFieldEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3644 private:
3645 static void ArenaDtor(void* object);
3646 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3647 public:
3648
3649 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3650 private:
3651 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
3652 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
3653 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
3654 }
3655
3656 public:
3657
3658 // nested types ----------------------------------------------------
3659
3660 // accessors -------------------------------------------------------
3661
3662 enum : int {
3663 kKeyFieldNumber = 1,
3664 kValFieldNumber = 2,
3665 };
3666 // required string key = 1;
3667 bool has_key() const;
3668 private:
3669 bool _internal_has_key() const;
3670 public:
3671 void clear_key();
3672 const std::string& key() const;
3673 void set_key(const std::string& value);
3674 void set_key(std::string&& value);
3675 void set_key(const char* value);
3676 void set_key(const char* value, size_t size);
3677 std::string* mutable_key();
3678 std::string* release_key();
3679 void set_allocated_key(std::string* key);
3680 private:
3681 const std::string& _internal_key() const;
3682 void _internal_set_key(const std::string& value);
3683 std::string* _internal_mutable_key();
3684 public:
3685
3686 // required string val = 2;
3687 bool has_val() const;
3688 private:
3689 bool _internal_has_val() const;
3690 public:
3691 void clear_val();
3692 const std::string& val() const;
3693 void set_val(const std::string& value);
3694 void set_val(std::string&& value);
3695 void set_val(const char* value);
3696 void set_val(const char* value, size_t size);
3697 std::string* mutable_val();
3698 std::string* release_val();
3699 void set_allocated_val(std::string* val);
3700 private:
3701 const std::string& _internal_val() const;
3702 void _internal_set_val(const std::string& value);
3703 std::string* _internal_mutable_val();
3704 public:
3705
3706 // @@protoc_insertion_point(class_scope:caffe2.MapFieldEntry)
3707 private:
3708 class _Internal;
3709
3710 // helper for ByteSizeLong()
3711 size_t RequiredFieldsByteSizeFallback() const;
3712
3713 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3714 typedef void InternalArenaConstructable_;
3715 typedef void DestructorSkippable_;
3716 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3717 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3718 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
3719 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr val_;
3720 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
3721};
3722// -------------------------------------------------------------------
3723
3724class TORCH_API BackendOptions PROTOBUF_FINAL :
3725 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.BackendOptions) */ {
3726 public:
3727 inline BackendOptions() : BackendOptions(nullptr) {}
3728 virtual ~BackendOptions();
3729
3730 BackendOptions(const BackendOptions& from);
3731 BackendOptions(BackendOptions&& from) noexcept
3732 : BackendOptions() {
3733 *this = ::std::move(from);
3734 }
3735
3736 inline BackendOptions& operator=(const BackendOptions& from) {
3737 CopyFrom(from);
3738 return *this;
3739 }
3740 inline BackendOptions& operator=(BackendOptions&& from) noexcept {
3741 if (GetArena() == from.GetArena()) {
3742 if (this != &from) InternalSwap(&from);
3743 } else {
3744 CopyFrom(from);
3745 }
3746 return *this;
3747 }
3748
3749 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
3750 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
3751 }
3752 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
3753 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
3754 }
3755
3756 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3757 return GetDescriptor();
3758 }
3759 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3760 return GetMetadataStatic().descriptor;
3761 }
3762 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3763 return GetMetadataStatic().reflection;
3764 }
3765 static const BackendOptions& default_instance();
3766
3767 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3768 static inline const BackendOptions* internal_default_instance() {
3769 return reinterpret_cast<const BackendOptions*>(
3770 &_BackendOptions_default_instance_);
3771 }
3772 static constexpr int kIndexInFileMessages =
3773 13;
3774
3775 friend void swap(BackendOptions& a, BackendOptions& b) {
3776 a.Swap(&b);
3777 }
3778 inline void Swap(BackendOptions* other) {
3779 if (other == this) return;
3780 if (GetArena() == other->GetArena()) {
3781 InternalSwap(other);
3782 } else {
3783 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3784 }
3785 }
3786 void UnsafeArenaSwap(BackendOptions* other) {
3787 if (other == this) return;
3788 GOOGLE_DCHECK(GetArena() == other->GetArena());
3789 InternalSwap(other);
3790 }
3791
3792 // implements Message ----------------------------------------------
3793
3794 inline BackendOptions* New() const final {
3795 return CreateMaybeMessage<BackendOptions>(nullptr);
3796 }
3797
3798 BackendOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3799 return CreateMaybeMessage<BackendOptions>(arena);
3800 }
3801 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3802 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3803 void CopyFrom(const BackendOptions& from);
3804 void MergeFrom(const BackendOptions& from);
3805 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3806 bool IsInitialized() const final;
3807
3808 size_t ByteSizeLong() const final;
3809 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3810 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
3811 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3812 int GetCachedSize() const final { return _cached_size_.Get(); }
3813
3814 private:
3815 inline void SharedCtor();
3816 inline void SharedDtor();
3817 void SetCachedSize(int size) const final;
3818 void InternalSwap(BackendOptions* other);
3819 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3820 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3821 return "caffe2.BackendOptions";
3822 }
3823 protected:
3824 explicit BackendOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3825 private:
3826 static void ArenaDtor(void* object);
3827 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3828 public:
3829
3830 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3831 private:
3832 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
3833 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
3834 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
3835 }
3836
3837 public:
3838
3839 // nested types ----------------------------------------------------
3840
3841 // accessors -------------------------------------------------------
3842
3843 enum : int {
3844 kOptionFieldNumber = 2,
3845 kBackendNameFieldNumber = 1,
3846 };
3847 // repeated .caffe2.MapFieldEntry option = 2;
3848 int option_size() const;
3849 private:
3850 int _internal_option_size() const;
3851 public:
3852 void clear_option();
3853 ::caffe2::MapFieldEntry* mutable_option(int index);
3854 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry >*
3855 mutable_option();
3856 private:
3857 const ::caffe2::MapFieldEntry& _internal_option(int index) const;
3858 ::caffe2::MapFieldEntry* _internal_add_option();
3859 public:
3860 const ::caffe2::MapFieldEntry& option(int index) const;
3861 ::caffe2::MapFieldEntry* add_option();
3862 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry >&
3863 option() const;
3864
3865 // required string backend_name = 1;
3866 bool has_backend_name() const;
3867 private:
3868 bool _internal_has_backend_name() const;
3869 public:
3870 void clear_backend_name();
3871 const std::string& backend_name() const;
3872 void set_backend_name(const std::string& value);
3873 void set_backend_name(std::string&& value);
3874 void set_backend_name(const char* value);
3875 void set_backend_name(const char* value, size_t size);
3876 std::string* mutable_backend_name();
3877 std::string* release_backend_name();
3878 void set_allocated_backend_name(std::string* backend_name);
3879 private:
3880 const std::string& _internal_backend_name() const;
3881 void _internal_set_backend_name(const std::string& value);
3882 std::string* _internal_mutable_backend_name();
3883 public:
3884
3885 // @@protoc_insertion_point(class_scope:caffe2.BackendOptions)
3886 private:
3887 class _Internal;
3888
3889 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3890 typedef void InternalArenaConstructable_;
3891 typedef void DestructorSkippable_;
3892 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3893 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3894 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry > option_;
3895 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backend_name_;
3896 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
3897};
3898// -------------------------------------------------------------------
3899
3900class TORCH_API PartitionInfo PROTOBUF_FINAL :
3901 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.PartitionInfo) */ {
3902 public:
3903 inline PartitionInfo() : PartitionInfo(nullptr) {}
3904 virtual ~PartitionInfo();
3905
3906 PartitionInfo(const PartitionInfo& from);
3907 PartitionInfo(PartitionInfo&& from) noexcept
3908 : PartitionInfo() {
3909 *this = ::std::move(from);
3910 }
3911
3912 inline PartitionInfo& operator=(const PartitionInfo& from) {
3913 CopyFrom(from);
3914 return *this;
3915 }
3916 inline PartitionInfo& operator=(PartitionInfo&& from) noexcept {
3917 if (GetArena() == from.GetArena()) {
3918 if (this != &from) InternalSwap(&from);
3919 } else {
3920 CopyFrom(from);
3921 }
3922 return *this;
3923 }
3924
3925 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
3926 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
3927 }
3928 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
3929 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
3930 }
3931
3932 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3933 return GetDescriptor();
3934 }
3935 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3936 return GetMetadataStatic().descriptor;
3937 }
3938 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3939 return GetMetadataStatic().reflection;
3940 }
3941 static const PartitionInfo& default_instance();
3942
3943 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3944 static inline const PartitionInfo* internal_default_instance() {
3945 return reinterpret_cast<const PartitionInfo*>(
3946 &_PartitionInfo_default_instance_);
3947 }
3948 static constexpr int kIndexInFileMessages =
3949 14;
3950
3951 friend void swap(PartitionInfo& a, PartitionInfo& b) {
3952 a.Swap(&b);
3953 }
3954 inline void Swap(PartitionInfo* other) {
3955 if (other == this) return;
3956 if (GetArena() == other->GetArena()) {
3957 InternalSwap(other);
3958 } else {
3959 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3960 }
3961 }
3962 void UnsafeArenaSwap(PartitionInfo* other) {
3963 if (other == this) return;
3964 GOOGLE_DCHECK(GetArena() == other->GetArena());
3965 InternalSwap(other);
3966 }
3967
3968 // implements Message ----------------------------------------------
3969
3970 inline PartitionInfo* New() const final {
3971 return CreateMaybeMessage<PartitionInfo>(nullptr);
3972 }
3973
3974 PartitionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3975 return CreateMaybeMessage<PartitionInfo>(arena);
3976 }
3977 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3978 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3979 void CopyFrom(const PartitionInfo& from);
3980 void MergeFrom(const PartitionInfo& from);
3981 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3982 bool IsInitialized() const final;
3983
3984 size_t ByteSizeLong() const final;
3985 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3986 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
3987 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3988 int GetCachedSize() const final { return _cached_size_.Get(); }
3989
3990 private:
3991 inline void SharedCtor();
3992 inline void SharedDtor();
3993 void SetCachedSize(int size) const final;
3994 void InternalSwap(PartitionInfo* other);
3995 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3996 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3997 return "caffe2.PartitionInfo";
3998 }
3999 protected:
4000 explicit PartitionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4001 private:
4002 static void ArenaDtor(void* object);
4003 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4004 public:
4005
4006 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4007 private:
4008 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
4009 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
4010 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
4011 }
4012
4013 public:
4014
4015 // nested types ----------------------------------------------------
4016
4017 // accessors -------------------------------------------------------
4018
4019 enum : int {
4020 kDeviceIdFieldNumber = 2,
4021 kBackendOptionsFieldNumber = 4,
4022 kNameFieldNumber = 1,
4023 kExtraInfoFieldNumber = 3,
4024 };
4025 // repeated int32 device_id = 2;
4026 int device_id_size() const;
4027 private:
4028 int _internal_device_id_size() const;
4029 public:
4030 void clear_device_id();
4031 private:
4032 ::PROTOBUF_NAMESPACE_ID::int32 _internal_device_id(int index) const;
4033 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
4034 _internal_device_id() const;
4035 void _internal_add_device_id(::PROTOBUF_NAMESPACE_ID::int32 value);
4036 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
4037 _internal_mutable_device_id();
4038 public:
4039 ::PROTOBUF_NAMESPACE_ID::int32 device_id(int index) const;
4040 void set_device_id(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
4041 void add_device_id(::PROTOBUF_NAMESPACE_ID::int32 value);
4042 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
4043 device_id() const;
4044 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
4045 mutable_device_id();
4046
4047 // repeated .caffe2.BackendOptions backend_options = 4;
4048 int backend_options_size() const;
4049 private:
4050 int _internal_backend_options_size() const;
4051 public:
4052 void clear_backend_options();
4053 ::caffe2::BackendOptions* mutable_backend_options(int index);
4054 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions >*
4055 mutable_backend_options();
4056 private:
4057 const ::caffe2::BackendOptions& _internal_backend_options(int index) const;
4058 ::caffe2::BackendOptions* _internal_add_backend_options();
4059 public:
4060 const ::caffe2::BackendOptions& backend_options(int index) const;
4061 ::caffe2::BackendOptions* add_backend_options();
4062 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions >&
4063 backend_options() const;
4064
4065 // required string name = 1;
4066 bool has_name() const;
4067 private:
4068 bool _internal_has_name() const;
4069 public:
4070 void clear_name();
4071 const std::string& name() const;
4072 void set_name(const std::string& value);
4073 void set_name(std::string&& value);
4074 void set_name(const char* value);
4075 void set_name(const char* value, size_t size);
4076 std::string* mutable_name();
4077 std::string* release_name();
4078 void set_allocated_name(std::string* name);
4079 private:
4080 const std::string& _internal_name() const;
4081 void _internal_set_name(const std::string& value);
4082 std::string* _internal_mutable_name();
4083 public:
4084
4085 // optional string extra_info = 3;
4086 bool has_extra_info() const;
4087 private:
4088 bool _internal_has_extra_info() const;
4089 public:
4090 void clear_extra_info();
4091 const std::string& extra_info() const;
4092 void set_extra_info(const std::string& value);
4093 void set_extra_info(std::string&& value);
4094 void set_extra_info(const char* value);
4095 void set_extra_info(const char* value, size_t size);
4096 std::string* mutable_extra_info();
4097 std::string* release_extra_info();
4098 void set_allocated_extra_info(std::string* extra_info);
4099 private:
4100 const std::string& _internal_extra_info() const;
4101 void _internal_set_extra_info(const std::string& value);
4102 std::string* _internal_mutable_extra_info();
4103 public:
4104
4105 // @@protoc_insertion_point(class_scope:caffe2.PartitionInfo)
4106 private:
4107 class _Internal;
4108
4109 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4110 typedef void InternalArenaConstructable_;
4111 typedef void DestructorSkippable_;
4112 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
4113 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4114 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > device_id_;
4115 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions > backend_options_;
4116 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
4117 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extra_info_;
4118 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
4119};
4120// -------------------------------------------------------------------
4121
4122class TORCH_API NetDef PROTOBUF_FINAL :
4123 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.NetDef) */ {
4124 public:
4125 inline NetDef() : NetDef(nullptr) {}
4126 virtual ~NetDef();
4127
4128 NetDef(const NetDef& from);
4129 NetDef(NetDef&& from) noexcept
4130 : NetDef() {
4131 *this = ::std::move(from);
4132 }
4133
4134 inline NetDef& operator=(const NetDef& from) {
4135 CopyFrom(from);
4136 return *this;
4137 }
4138 inline NetDef& operator=(NetDef&& from) noexcept {
4139 if (GetArena() == from.GetArena()) {
4140 if (this != &from) InternalSwap(&from);
4141 } else {
4142 CopyFrom(from);
4143 }
4144 return *this;
4145 }
4146
4147 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
4148 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
4149 }
4150 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
4151 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
4152 }
4153
4154 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
4155 return GetDescriptor();
4156 }
4157 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
4158 return GetMetadataStatic().descriptor;
4159 }
4160 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
4161 return GetMetadataStatic().reflection;
4162 }
4163 static const NetDef& default_instance();
4164
4165 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4166 static inline const NetDef* internal_default_instance() {
4167 return reinterpret_cast<const NetDef*>(
4168 &_NetDef_default_instance_);
4169 }
4170 static constexpr int kIndexInFileMessages =
4171 15;
4172
4173 friend void swap(NetDef& a, NetDef& b) {
4174 a.Swap(&b);
4175 }
4176 inline void Swap(NetDef* other) {
4177 if (other == this) return;
4178 if (GetArena() == other->GetArena()) {
4179 InternalSwap(other);
4180 } else {
4181 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4182 }
4183 }
4184 void UnsafeArenaSwap(NetDef* other) {
4185 if (other == this) return;
4186 GOOGLE_DCHECK(GetArena() == other->GetArena());
4187 InternalSwap(other);
4188 }
4189
4190 // implements Message ----------------------------------------------
4191
4192 inline NetDef* New() const final {
4193 return CreateMaybeMessage<NetDef>(nullptr);
4194 }
4195
4196 NetDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4197 return CreateMaybeMessage<NetDef>(arena);
4198 }
4199 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4200 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4201 void CopyFrom(const NetDef& from);
4202 void MergeFrom(const NetDef& from);
4203 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4204 bool IsInitialized() const final;
4205
4206 size_t ByteSizeLong() const final;
4207 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4208 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
4209 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4210 int GetCachedSize() const final { return _cached_size_.Get(); }
4211
4212 private:
4213 inline void SharedCtor();
4214 inline void SharedDtor();
4215 void SetCachedSize(int size) const final;
4216 void InternalSwap(NetDef* other);
4217 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4218 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4219 return "caffe2.NetDef";
4220 }
4221 protected:
4222 explicit NetDef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4223 private:
4224 static void ArenaDtor(void* object);
4225 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4226 public:
4227
4228 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4229 private:
4230 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
4231 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
4232 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
4233 }
4234
4235 public:
4236
4237 // nested types ----------------------------------------------------
4238
4239 // accessors -------------------------------------------------------
4240
4241 enum : int {
4242 kOpFieldNumber = 2,
4243 kArgFieldNumber = 6,
4244 kExternalInputFieldNumber = 7,
4245 kExternalOutputFieldNumber = 8,
4246 kPartitionInfoFieldNumber = 9,
4247 kNameFieldNumber = 1,
4248 kTypeFieldNumber = 3,
4249 kDeviceOptionFieldNumber = 5,
4250 kNumWorkersFieldNumber = 4,
4251 };
4252 // repeated .caffe2.OperatorDef op = 2;
4253 int op_size() const;
4254 private:
4255 int _internal_op_size() const;
4256 public:
4257 void clear_op();
4258 ::caffe2::OperatorDef* mutable_op(int index);
4259 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef >*
4260 mutable_op();
4261 private:
4262 const ::caffe2::OperatorDef& _internal_op(int index) const;
4263 ::caffe2::OperatorDef* _internal_add_op();
4264 public:
4265 const ::caffe2::OperatorDef& op(int index) const;
4266 ::caffe2::OperatorDef* add_op();
4267 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef >&
4268 op() const;
4269
4270 // repeated .caffe2.Argument arg = 6;
4271 int arg_size() const;
4272 private:
4273 int _internal_arg_size() const;
4274 public:
4275 void clear_arg();
4276 ::caffe2::Argument* mutable_arg(int index);
4277 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >*
4278 mutable_arg();
4279 private:
4280 const ::caffe2::Argument& _internal_arg(int index) const;
4281 ::caffe2::Argument* _internal_add_arg();
4282 public:
4283 const ::caffe2::Argument& arg(int index) const;
4284 ::caffe2::Argument* add_arg();
4285 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >&
4286 arg() const;
4287
4288 // repeated string external_input = 7;
4289 int external_input_size() const;
4290 private:
4291 int _internal_external_input_size() const;
4292 public:
4293 void clear_external_input();
4294 const std::string& external_input(int index) const;
4295 std::string* mutable_external_input(int index);
4296 void set_external_input(int index, const std::string& value);
4297 void set_external_input(int index, std::string&& value);
4298 void set_external_input(int index, const char* value);
4299 void set_external_input(int index, const char* value, size_t size);
4300 std::string* add_external_input();
4301 void add_external_input(const std::string& value);
4302 void add_external_input(std::string&& value);
4303 void add_external_input(const char* value);
4304 void add_external_input(const char* value, size_t size);
4305 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& external_input() const;
4306 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_external_input();
4307 private:
4308 const std::string& _internal_external_input(int index) const;
4309 std::string* _internal_add_external_input();
4310 public:
4311
4312 // repeated string external_output = 8;
4313 int external_output_size() const;
4314 private:
4315 int _internal_external_output_size() const;
4316 public:
4317 void clear_external_output();
4318 const std::string& external_output(int index) const;
4319 std::string* mutable_external_output(int index);
4320 void set_external_output(int index, const std::string& value);
4321 void set_external_output(int index, std::string&& value);
4322 void set_external_output(int index, const char* value);
4323 void set_external_output(int index, const char* value, size_t size);
4324 std::string* add_external_output();
4325 void add_external_output(const std::string& value);
4326 void add_external_output(std::string&& value);
4327 void add_external_output(const char* value);
4328 void add_external_output(const char* value, size_t size);
4329 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& external_output() const;
4330 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_external_output();
4331 private:
4332 const std::string& _internal_external_output(int index) const;
4333 std::string* _internal_add_external_output();
4334 public:
4335
4336 // repeated .caffe2.PartitionInfo partition_info = 9;
4337 int partition_info_size() const;
4338 private:
4339 int _internal_partition_info_size() const;
4340 public:
4341 void clear_partition_info();
4342 ::caffe2::PartitionInfo* mutable_partition_info(int index);
4343 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo >*
4344 mutable_partition_info();
4345 private:
4346 const ::caffe2::PartitionInfo& _internal_partition_info(int index) const;
4347 ::caffe2::PartitionInfo* _internal_add_partition_info();
4348 public:
4349 const ::caffe2::PartitionInfo& partition_info(int index) const;
4350 ::caffe2::PartitionInfo* add_partition_info();
4351 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo >&
4352 partition_info() const;
4353
4354 // optional string name = 1;
4355 bool has_name() const;
4356 private:
4357 bool _internal_has_name() const;
4358 public:
4359 void clear_name();
4360 const std::string& name() const;
4361 void set_name(const std::string& value);
4362 void set_name(std::string&& value);
4363 void set_name(const char* value);
4364 void set_name(const char* value, size_t size);
4365 std::string* mutable_name();
4366 std::string* release_name();
4367 void set_allocated_name(std::string* name);
4368 private:
4369 const std::string& _internal_name() const;
4370 void _internal_set_name(const std::string& value);
4371 std::string* _internal_mutable_name();
4372 public:
4373
4374 // optional string type = 3;
4375 bool has_type() const;
4376 private:
4377 bool _internal_has_type() const;
4378 public:
4379 void clear_type();
4380 const std::string& type() const;
4381 void set_type(const std::string& value);
4382 void set_type(std::string&& value);
4383 void set_type(const char* value);
4384 void set_type(const char* value, size_t size);
4385 std::string* mutable_type();
4386 std::string* release_type();
4387 void set_allocated_type(std::string* type);
4388 private:
4389 const std::string& _internal_type() const;
4390 void _internal_set_type(const std::string& value);
4391 std::string* _internal_mutable_type();
4392 public:
4393
4394 // optional .caffe2.DeviceOption device_option = 5;
4395 bool has_device_option() const;
4396 private:
4397 bool _internal_has_device_option() const;
4398 public:
4399 void clear_device_option();
4400 const ::caffe2::DeviceOption& device_option() const;
4401 ::caffe2::DeviceOption* release_device_option();
4402 ::caffe2::DeviceOption* mutable_device_option();
4403 void set_allocated_device_option(::caffe2::DeviceOption* device_option);
4404 private:
4405 const ::caffe2::DeviceOption& _internal_device_option() const;
4406 ::caffe2::DeviceOption* _internal_mutable_device_option();
4407 public:
4408 void unsafe_arena_set_allocated_device_option(
4409 ::caffe2::DeviceOption* device_option);
4410 ::caffe2::DeviceOption* unsafe_arena_release_device_option();
4411
4412 // optional int32 num_workers = 4;
4413 bool has_num_workers() const;
4414 private:
4415 bool _internal_has_num_workers() const;
4416 public:
4417 void clear_num_workers();
4418 ::PROTOBUF_NAMESPACE_ID::int32 num_workers() const;
4419 void set_num_workers(::PROTOBUF_NAMESPACE_ID::int32 value);
4420 private:
4421 ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_workers() const;
4422 void _internal_set_num_workers(::PROTOBUF_NAMESPACE_ID::int32 value);
4423 public:
4424
4425 // @@protoc_insertion_point(class_scope:caffe2.NetDef)
4426 private:
4427 class _Internal;
4428
4429 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4430 typedef void InternalArenaConstructable_;
4431 typedef void DestructorSkippable_;
4432 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
4433 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4434 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef > op_;
4435 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument > arg_;
4436 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> external_input_;
4437 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> external_output_;
4438 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo > partition_info_;
4439 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
4440 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
4441 ::caffe2::DeviceOption* device_option_;
4442 ::PROTOBUF_NAMESPACE_ID::int32 num_workers_;
4443 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
4444};
4445// -------------------------------------------------------------------
4446
4447class TORCH_API ExecutionStep PROTOBUF_FINAL :
4448 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.ExecutionStep) */ {
4449 public:
4450 inline ExecutionStep() : ExecutionStep(nullptr) {}
4451 virtual ~ExecutionStep();
4452
4453 ExecutionStep(const ExecutionStep& from);
4454 ExecutionStep(ExecutionStep&& from) noexcept
4455 : ExecutionStep() {
4456 *this = ::std::move(from);
4457 }
4458
4459 inline ExecutionStep& operator=(const ExecutionStep& from) {
4460 CopyFrom(from);
4461 return *this;
4462 }
4463 inline ExecutionStep& operator=(ExecutionStep&& from) noexcept {
4464 if (GetArena() == from.GetArena()) {
4465 if (this != &from) InternalSwap(&from);
4466 } else {
4467 CopyFrom(from);
4468 }
4469 return *this;
4470 }
4471
4472 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
4473 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
4474 }
4475 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
4476 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
4477 }
4478
4479 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
4480 return GetDescriptor();
4481 }
4482 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
4483 return GetMetadataStatic().descriptor;
4484 }
4485 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
4486 return GetMetadataStatic().reflection;
4487 }
4488 static const ExecutionStep& default_instance();
4489
4490 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4491 static inline const ExecutionStep* internal_default_instance() {
4492 return reinterpret_cast<const ExecutionStep*>(
4493 &_ExecutionStep_default_instance_);
4494 }
4495 static constexpr int kIndexInFileMessages =
4496 16;
4497
4498 friend void swap(ExecutionStep& a, ExecutionStep& b) {
4499 a.Swap(&b);
4500 }
4501 inline void Swap(ExecutionStep* other) {
4502 if (other == this) return;
4503 if (GetArena() == other->GetArena()) {
4504 InternalSwap(other);
4505 } else {
4506 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4507 }
4508 }
4509 void UnsafeArenaSwap(ExecutionStep* other) {
4510 if (other == this) return;
4511 GOOGLE_DCHECK(GetArena() == other->GetArena());
4512 InternalSwap(other);
4513 }
4514
4515 // implements Message ----------------------------------------------
4516
4517 inline ExecutionStep* New() const final {
4518 return CreateMaybeMessage<ExecutionStep>(nullptr);
4519 }
4520
4521 ExecutionStep* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4522 return CreateMaybeMessage<ExecutionStep>(arena);
4523 }
4524 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4525 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4526 void CopyFrom(const ExecutionStep& from);
4527 void MergeFrom(const ExecutionStep& from);
4528 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4529 bool IsInitialized() const final;
4530
4531 size_t ByteSizeLong() const final;
4532 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4533 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
4534 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4535 int GetCachedSize() const final { return _cached_size_.Get(); }
4536
4537 private:
4538 inline void SharedCtor();
4539 inline void SharedDtor();
4540 void SetCachedSize(int size) const final;
4541 void InternalSwap(ExecutionStep* other);
4542 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4543 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4544 return "caffe2.ExecutionStep";
4545 }
4546 protected:
4547 explicit ExecutionStep(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4548 private:
4549 static void ArenaDtor(void* object);
4550 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4551 public:
4552
4553 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4554 private:
4555 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
4556 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
4557 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
4558 }
4559
4560 public:
4561
4562 // nested types ----------------------------------------------------
4563
4564 // accessors -------------------------------------------------------
4565
4566 enum : int {
4567 kSubstepFieldNumber = 2,
4568 kNetworkFieldNumber = 3,
4569 kNameFieldNumber = 1,
4570 kCriteriaNetworkFieldNumber = 5,
4571 kReportNetFieldNumber = 7,
4572 kShouldStopBlobFieldNumber = 9,
4573 kNumIterFieldNumber = 4,
4574 kReportIntervalFieldNumber = 8,
4575 kConcurrentSubstepsFieldNumber = 6,
4576 kOnlyOnceFieldNumber = 10,
4577 kCreateWorkspaceFieldNumber = 12,
4578 kRunEveryMsFieldNumber = 11,
4579 kNumConcurrentInstancesFieldNumber = 13,
4580 };
4581 // repeated .caffe2.ExecutionStep substep = 2;
4582 int substep_size() const;
4583 private:
4584 int _internal_substep_size() const;
4585 public:
4586 void clear_substep();
4587 ::caffe2::ExecutionStep* mutable_substep(int index);
4588 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >*
4589 mutable_substep();
4590 private:
4591 const ::caffe2::ExecutionStep& _internal_substep(int index) const;
4592 ::caffe2::ExecutionStep* _internal_add_substep();
4593 public:
4594 const ::caffe2::ExecutionStep& substep(int index) const;
4595 ::caffe2::ExecutionStep* add_substep();
4596 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >&
4597 substep() const;
4598
4599 // repeated string network = 3;
4600 int network_size() const;
4601 private:
4602 int _internal_network_size() const;
4603 public:
4604 void clear_network();
4605 const std::string& network(int index) const;
4606 std::string* mutable_network(int index);
4607 void set_network(int index, const std::string& value);
4608 void set_network(int index, std::string&& value);
4609 void set_network(int index, const char* value);
4610 void set_network(int index, const char* value, size_t size);
4611 std::string* add_network();
4612 void add_network(const std::string& value);
4613 void add_network(std::string&& value);
4614 void add_network(const char* value);
4615 void add_network(const char* value, size_t size);
4616 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& network() const;
4617 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_network();
4618 private:
4619 const std::string& _internal_network(int index) const;
4620 std::string* _internal_add_network();
4621 public:
4622
4623 // optional string name = 1;
4624 bool has_name() const;
4625 private:
4626 bool _internal_has_name() const;
4627 public:
4628 void clear_name();
4629 const std::string& name() const;
4630 void set_name(const std::string& value);
4631 void set_name(std::string&& value);
4632 void set_name(const char* value);
4633 void set_name(const char* value, size_t size);
4634 std::string* mutable_name();
4635 std::string* release_name();
4636 void set_allocated_name(std::string* name);
4637 private:
4638 const std::string& _internal_name() const;
4639 void _internal_set_name(const std::string& value);
4640 std::string* _internal_mutable_name();
4641 public:
4642
4643 // optional string criteria_network = 5 [deprecated = true];
4644 PROTOBUF_DEPRECATED bool has_criteria_network() const;
4645 private:
4646 bool _internal_has_criteria_network() const;
4647 public:
4648 PROTOBUF_DEPRECATED void clear_criteria_network();
4649 PROTOBUF_DEPRECATED const std::string& criteria_network() const;
4650 PROTOBUF_DEPRECATED void set_criteria_network(const std::string& value);
4651 PROTOBUF_DEPRECATED void set_criteria_network(std::string&& value);
4652 PROTOBUF_DEPRECATED void set_criteria_network(const char* value);
4653 PROTOBUF_DEPRECATED void set_criteria_network(const char* value, size_t size);
4654 PROTOBUF_DEPRECATED std::string* mutable_criteria_network();
4655 PROTOBUF_DEPRECATED std::string* release_criteria_network();
4656 PROTOBUF_DEPRECATED void set_allocated_criteria_network(std::string* criteria_network);
4657 private:
4658 const std::string& _internal_criteria_network() const;
4659 void _internal_set_criteria_network(const std::string& value);
4660 std::string* _internal_mutable_criteria_network();
4661 public:
4662
4663 // optional string report_net = 7;
4664 bool has_report_net() const;
4665 private:
4666 bool _internal_has_report_net() const;
4667 public:
4668 void clear_report_net();
4669 const std::string& report_net() const;
4670 void set_report_net(const std::string& value);
4671 void set_report_net(std::string&& value);
4672 void set_report_net(const char* value);
4673 void set_report_net(const char* value, size_t size);
4674 std::string* mutable_report_net();
4675 std::string* release_report_net();
4676 void set_allocated_report_net(std::string* report_net);
4677 private:
4678 const std::string& _internal_report_net() const;
4679 void _internal_set_report_net(const std::string& value);
4680 std::string* _internal_mutable_report_net();
4681 public:
4682
4683 // optional string should_stop_blob = 9;
4684 bool has_should_stop_blob() const;
4685 private:
4686 bool _internal_has_should_stop_blob() const;
4687 public:
4688 void clear_should_stop_blob();
4689 const std::string& should_stop_blob() const;
4690 void set_should_stop_blob(const std::string& value);
4691 void set_should_stop_blob(std::string&& value);
4692 void set_should_stop_blob(const char* value);
4693 void set_should_stop_blob(const char* value, size_t size);
4694 std::string* mutable_should_stop_blob();
4695 std::string* release_should_stop_blob();
4696 void set_allocated_should_stop_blob(std::string* should_stop_blob);
4697 private:
4698 const std::string& _internal_should_stop_blob() const;
4699 void _internal_set_should_stop_blob(const std::string& value);
4700 std::string* _internal_mutable_should_stop_blob();
4701 public:
4702
4703 // optional int64 num_iter = 4;
4704 bool has_num_iter() const;
4705 private:
4706 bool _internal_has_num_iter() const;
4707 public:
4708 void clear_num_iter();
4709 ::PROTOBUF_NAMESPACE_ID::int64 num_iter() const;
4710 void set_num_iter(::PROTOBUF_NAMESPACE_ID::int64 value);
4711 private:
4712 ::PROTOBUF_NAMESPACE_ID::int64 _internal_num_iter() const;
4713 void _internal_set_num_iter(::PROTOBUF_NAMESPACE_ID::int64 value);
4714 public:
4715
4716 // optional int32 report_interval = 8;
4717 bool has_report_interval() const;
4718 private:
4719 bool _internal_has_report_interval() const;
4720 public:
4721 void clear_report_interval();
4722 ::PROTOBUF_NAMESPACE_ID::int32 report_interval() const;
4723 void set_report_interval(::PROTOBUF_NAMESPACE_ID::int32 value);
4724 private:
4725 ::PROTOBUF_NAMESPACE_ID::int32 _internal_report_interval() const;
4726 void _internal_set_report_interval(::PROTOBUF_NAMESPACE_ID::int32 value);
4727 public:
4728
4729 // optional bool concurrent_substeps = 6;
4730 bool has_concurrent_substeps() const;
4731 private:
4732 bool _internal_has_concurrent_substeps() const;
4733 public:
4734 void clear_concurrent_substeps();
4735 bool concurrent_substeps() const;
4736 void set_concurrent_substeps(bool value);
4737 private:
4738 bool _internal_concurrent_substeps() const;
4739 void _internal_set_concurrent_substeps(bool value);
4740 public:
4741
4742 // optional bool only_once = 10;
4743 bool has_only_once() const;
4744 private:
4745 bool _internal_has_only_once() const;
4746 public:
4747 void clear_only_once();
4748 bool only_once() const;
4749 void set_only_once(bool value);
4750 private:
4751 bool _internal_only_once() const;
4752 void _internal_set_only_once(bool value);
4753 public:
4754
4755 // optional bool create_workspace = 12;
4756 bool has_create_workspace() const;
4757 private:
4758 bool _internal_has_create_workspace() const;
4759 public:
4760 void clear_create_workspace();
4761 bool create_workspace() const;
4762 void set_create_workspace(bool value);
4763 private:
4764 bool _internal_create_workspace() const;
4765 void _internal_set_create_workspace(bool value);
4766 public:
4767
4768 // optional int64 run_every_ms = 11;
4769 bool has_run_every_ms() const;
4770 private:
4771 bool _internal_has_run_every_ms() const;
4772 public:
4773 void clear_run_every_ms();
4774 ::PROTOBUF_NAMESPACE_ID::int64 run_every_ms() const;
4775 void set_run_every_ms(::PROTOBUF_NAMESPACE_ID::int64 value);
4776 private:
4777 ::PROTOBUF_NAMESPACE_ID::int64 _internal_run_every_ms() const;
4778 void _internal_set_run_every_ms(::PROTOBUF_NAMESPACE_ID::int64 value);
4779 public:
4780
4781 // optional int32 num_concurrent_instances = 13;
4782 bool has_num_concurrent_instances() const;
4783 private:
4784 bool _internal_has_num_concurrent_instances() const;
4785 public:
4786 void clear_num_concurrent_instances();
4787 ::PROTOBUF_NAMESPACE_ID::int32 num_concurrent_instances() const;
4788 void set_num_concurrent_instances(::PROTOBUF_NAMESPACE_ID::int32 value);
4789 private:
4790 ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_concurrent_instances() const;
4791 void _internal_set_num_concurrent_instances(::PROTOBUF_NAMESPACE_ID::int32 value);
4792 public:
4793
4794 // @@protoc_insertion_point(class_scope:caffe2.ExecutionStep)
4795 private:
4796 class _Internal;
4797
4798 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4799 typedef void InternalArenaConstructable_;
4800 typedef void DestructorSkippable_;
4801 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
4802 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4803 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep > substep_;
4804 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> network_;
4805 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
4806 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr criteria_network_;
4807 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr report_net_;
4808 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr should_stop_blob_;
4809 ::PROTOBUF_NAMESPACE_ID::int64 num_iter_;
4810 ::PROTOBUF_NAMESPACE_ID::int32 report_interval_;
4811 bool concurrent_substeps_;
4812 bool only_once_;
4813 bool create_workspace_;
4814 ::PROTOBUF_NAMESPACE_ID::int64 run_every_ms_;
4815 ::PROTOBUF_NAMESPACE_ID::int32 num_concurrent_instances_;
4816 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
4817};
4818// -------------------------------------------------------------------
4819
4820class TORCH_API PlanDef PROTOBUF_FINAL :
4821 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.PlanDef) */ {
4822 public:
4823 inline PlanDef() : PlanDef(nullptr) {}
4824 virtual ~PlanDef();
4825
4826 PlanDef(const PlanDef& from);
4827 PlanDef(PlanDef&& from) noexcept
4828 : PlanDef() {
4829 *this = ::std::move(from);
4830 }
4831
4832 inline PlanDef& operator=(const PlanDef& from) {
4833 CopyFrom(from);
4834 return *this;
4835 }
4836 inline PlanDef& operator=(PlanDef&& from) noexcept {
4837 if (GetArena() == from.GetArena()) {
4838 if (this != &from) InternalSwap(&from);
4839 } else {
4840 CopyFrom(from);
4841 }
4842 return *this;
4843 }
4844
4845 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
4846 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
4847 }
4848 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
4849 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
4850 }
4851
4852 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
4853 return GetDescriptor();
4854 }
4855 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
4856 return GetMetadataStatic().descriptor;
4857 }
4858 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
4859 return GetMetadataStatic().reflection;
4860 }
4861 static const PlanDef& default_instance();
4862
4863 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4864 static inline const PlanDef* internal_default_instance() {
4865 return reinterpret_cast<const PlanDef*>(
4866 &_PlanDef_default_instance_);
4867 }
4868 static constexpr int kIndexInFileMessages =
4869 17;
4870
4871 friend void swap(PlanDef& a, PlanDef& b) {
4872 a.Swap(&b);
4873 }
4874 inline void Swap(PlanDef* other) {
4875 if (other == this) return;
4876 if (GetArena() == other->GetArena()) {
4877 InternalSwap(other);
4878 } else {
4879 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4880 }
4881 }
4882 void UnsafeArenaSwap(PlanDef* other) {
4883 if (other == this) return;
4884 GOOGLE_DCHECK(GetArena() == other->GetArena());
4885 InternalSwap(other);
4886 }
4887
4888 // implements Message ----------------------------------------------
4889
4890 inline PlanDef* New() const final {
4891 return CreateMaybeMessage<PlanDef>(nullptr);
4892 }
4893
4894 PlanDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4895 return CreateMaybeMessage<PlanDef>(arena);
4896 }
4897 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4898 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4899 void CopyFrom(const PlanDef& from);
4900 void MergeFrom(const PlanDef& from);
4901 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4902 bool IsInitialized() const final;
4903
4904 size_t ByteSizeLong() const final;
4905 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4906 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
4907 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4908 int GetCachedSize() const final { return _cached_size_.Get(); }
4909
4910 private:
4911 inline void SharedCtor();
4912 inline void SharedDtor();
4913 void SetCachedSize(int size) const final;
4914 void InternalSwap(PlanDef* other);
4915 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4916 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4917 return "caffe2.PlanDef";
4918 }
4919 protected:
4920 explicit PlanDef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4921 private:
4922 static void ArenaDtor(void* object);
4923 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4924 public:
4925
4926 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4927 private:
4928 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
4929 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
4930 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
4931 }
4932
4933 public:
4934
4935 // nested types ----------------------------------------------------
4936
4937 // accessors -------------------------------------------------------
4938
4939 enum : int {
4940 kNetworkFieldNumber = 2,
4941 kExecutionStepFieldNumber = 3,
4942 kNameFieldNumber = 1,
4943 };
4944 // repeated .caffe2.NetDef network = 2;
4945 int network_size() const;
4946 private:
4947 int _internal_network_size() const;
4948 public:
4949 void clear_network();
4950 ::caffe2::NetDef* mutable_network(int index);
4951 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >*
4952 mutable_network();
4953 private:
4954 const ::caffe2::NetDef& _internal_network(int index) const;
4955 ::caffe2::NetDef* _internal_add_network();
4956 public:
4957 const ::caffe2::NetDef& network(int index) const;
4958 ::caffe2::NetDef* add_network();
4959 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >&
4960 network() const;
4961
4962 // repeated .caffe2.ExecutionStep execution_step = 3;
4963 int execution_step_size() const;
4964 private:
4965 int _internal_execution_step_size() const;
4966 public:
4967 void clear_execution_step();
4968 ::caffe2::ExecutionStep* mutable_execution_step(int index);
4969 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >*
4970 mutable_execution_step();
4971 private:
4972 const ::caffe2::ExecutionStep& _internal_execution_step(int index) const;
4973 ::caffe2::ExecutionStep* _internal_add_execution_step();
4974 public:
4975 const ::caffe2::ExecutionStep& execution_step(int index) const;
4976 ::caffe2::ExecutionStep* add_execution_step();
4977 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >&
4978 execution_step() const;
4979
4980 // optional string name = 1;
4981 bool has_name() const;
4982 private:
4983 bool _internal_has_name() const;
4984 public:
4985 void clear_name();
4986 const std::string& name() const;
4987 void set_name(const std::string& value);
4988 void set_name(std::string&& value);
4989 void set_name(const char* value);
4990 void set_name(const char* value, size_t size);
4991 std::string* mutable_name();
4992 std::string* release_name();
4993 void set_allocated_name(std::string* name);
4994 private:
4995 const std::string& _internal_name() const;
4996 void _internal_set_name(const std::string& value);
4997 std::string* _internal_mutable_name();
4998 public:
4999
5000 // @@protoc_insertion_point(class_scope:caffe2.PlanDef)
5001 private:
5002 class _Internal;
5003
5004 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
5005 typedef void InternalArenaConstructable_;
5006 typedef void DestructorSkippable_;
5007 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
5008 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
5009 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef > network_;
5010 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep > execution_step_;
5011 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
5012 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
5013};
5014// -------------------------------------------------------------------
5015
5016class TORCH_API BlobProto PROTOBUF_FINAL :
5017 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.BlobProto) */ {
5018 public:
5019 inline BlobProto() : BlobProto(nullptr) {}
5020 virtual ~BlobProto();
5021
5022 BlobProto(const BlobProto& from);
5023 BlobProto(BlobProto&& from) noexcept
5024 : BlobProto() {
5025 *this = ::std::move(from);
5026 }
5027
5028 inline BlobProto& operator=(const BlobProto& from) {
5029 CopyFrom(from);
5030 return *this;
5031 }
5032 inline BlobProto& operator=(BlobProto&& from) noexcept {
5033 if (GetArena() == from.GetArena()) {
5034 if (this != &from) InternalSwap(&from);
5035 } else {
5036 CopyFrom(from);
5037 }
5038 return *this;
5039 }
5040
5041 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
5042 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
5043 }
5044 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
5045 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
5046 }
5047
5048 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
5049 return GetDescriptor();
5050 }
5051 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
5052 return GetMetadataStatic().descriptor;
5053 }
5054 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
5055 return GetMetadataStatic().reflection;
5056 }
5057 static const BlobProto& default_instance();
5058
5059 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
5060 static inline const BlobProto* internal_default_instance() {
5061 return reinterpret_cast<const BlobProto*>(
5062 &_BlobProto_default_instance_);
5063 }
5064 static constexpr int kIndexInFileMessages =
5065 18;
5066
5067 friend void swap(BlobProto& a, BlobProto& b) {
5068 a.Swap(&b);
5069 }
5070 inline void Swap(BlobProto* other) {
5071 if (other == this) return;
5072 if (GetArena() == other->GetArena()) {
5073 InternalSwap(other);
5074 } else {
5075 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
5076 }
5077 }
5078 void UnsafeArenaSwap(BlobProto* other) {
5079 if (other == this) return;
5080 GOOGLE_DCHECK(GetArena() == other->GetArena());
5081 InternalSwap(other);
5082 }
5083
5084 // implements Message ----------------------------------------------
5085
5086 inline BlobProto* New() const final {
5087 return CreateMaybeMessage<BlobProto>(nullptr);
5088 }
5089
5090 BlobProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
5091 return CreateMaybeMessage<BlobProto>(arena);
5092 }
5093 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
5094 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
5095 void CopyFrom(const BlobProto& from);
5096 void MergeFrom(const BlobProto& from);
5097 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
5098 bool IsInitialized() const final;
5099
5100 size_t ByteSizeLong() const final;
5101 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
5102 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
5103 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
5104 int GetCachedSize() const final { return _cached_size_.Get(); }
5105
5106 private:
5107 inline void SharedCtor();
5108 inline void SharedDtor();
5109 void SetCachedSize(int size) const final;
5110 void InternalSwap(BlobProto* other);
5111 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
5112 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
5113 return "caffe2.BlobProto";
5114 }
5115 protected:
5116 explicit BlobProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
5117 private:
5118 static void ArenaDtor(void* object);
5119 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
5120 public:
5121
5122 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
5123 private:
5124 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
5125 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
5126 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
5127 }
5128
5129 public:
5130
5131 // nested types ----------------------------------------------------
5132
5133 // accessors -------------------------------------------------------
5134
5135 enum : int {
5136 kNameFieldNumber = 1,
5137 kTypeFieldNumber = 2,
5138 kContentFieldNumber = 4,
5139 kTensorFieldNumber = 3,
5140 kQtensorFieldNumber = 5,
5141 kContentNumChunksFieldNumber = 6,
5142 kContentChunkIdFieldNumber = 7,
5143 };
5144 // optional string name = 1;
5145 bool has_name() const;
5146 private:
5147 bool _internal_has_name() const;
5148 public:
5149 void clear_name();
5150 const std::string& name() const;
5151 void set_name(const std::string& value);
5152 void set_name(std::string&& value);
5153 void set_name(const char* value);
5154 void set_name(const char* value, size_t size);
5155 std::string* mutable_name();
5156 std::string* release_name();
5157 void set_allocated_name(std::string* name);
5158 private:
5159 const std::string& _internal_name() const;
5160 void _internal_set_name(const std::string& value);
5161 std::string* _internal_mutable_name();
5162 public:
5163
5164 // optional string type = 2;
5165 bool has_type() const;
5166 private:
5167 bool _internal_has_type() const;
5168 public:
5169 void clear_type();
5170 const std::string& type() const;
5171 void set_type(const std::string& value);
5172 void set_type(std::string&& value);
5173 void set_type(const char* value);
5174 void set_type(const char* value, size_t size);
5175 std::string* mutable_type();
5176 std::string* release_type();
5177 void set_allocated_type(std::string* type);
5178 private:
5179 const std::string& _internal_type() const;
5180 void _internal_set_type(const std::string& value);
5181 std::string* _internal_mutable_type();
5182 public:
5183
5184 // optional bytes content = 4;
5185 bool has_content() const;
5186 private:
5187 bool _internal_has_content() const;
5188 public:
5189 void clear_content();
5190 const std::string& content() const;
5191 void set_content(const std::string& value);
5192 void set_content(std::string&& value);
5193 void set_content(const char* value);
5194 void set_content(const void* value, size_t size);
5195 std::string* mutable_content();
5196 std::string* release_content();
5197 void set_allocated_content(std::string* content);
5198 private:
5199 const std::string& _internal_content() const;
5200 void _internal_set_content(const std::string& value);
5201 std::string* _internal_mutable_content();
5202 public:
5203
5204 // optional .caffe2.TensorProto tensor = 3;
5205 bool has_tensor() const;
5206 private:
5207 bool _internal_has_tensor() const;
5208 public:
5209 void clear_tensor();
5210 const ::caffe2::TensorProto& tensor() const;
5211 ::caffe2::TensorProto* release_tensor();
5212 ::caffe2::TensorProto* mutable_tensor();
5213 void set_allocated_tensor(::caffe2::TensorProto* tensor);
5214 private:
5215 const ::caffe2::TensorProto& _internal_tensor() const;
5216 ::caffe2::TensorProto* _internal_mutable_tensor();
5217 public:
5218 void unsafe_arena_set_allocated_tensor(
5219 ::caffe2::TensorProto* tensor);
5220 ::caffe2::TensorProto* unsafe_arena_release_tensor();
5221
5222 // optional .caffe2.QTensorProto qtensor = 5;
5223 bool has_qtensor() const;
5224 private:
5225 bool _internal_has_qtensor() const;
5226 public:
5227 void clear_qtensor();
5228 const ::caffe2::QTensorProto& qtensor() const;
5229 ::caffe2::QTensorProto* release_qtensor();
5230 ::caffe2::QTensorProto* mutable_qtensor();
5231 void set_allocated_qtensor(::caffe2::QTensorProto* qtensor);
5232 private:
5233 const ::caffe2::QTensorProto& _internal_qtensor() const;
5234 ::caffe2::QTensorProto* _internal_mutable_qtensor();
5235 public:
5236 void unsafe_arena_set_allocated_qtensor(
5237 ::caffe2::QTensorProto* qtensor);
5238 ::caffe2::QTensorProto* unsafe_arena_release_qtensor();
5239
5240 // optional int32 content_num_chunks = 6;
5241 bool has_content_num_chunks() const;
5242 private:
5243 bool _internal_has_content_num_chunks() const;
5244 public:
5245 void clear_content_num_chunks();
5246 ::PROTOBUF_NAMESPACE_ID::int32 content_num_chunks() const;
5247 void set_content_num_chunks(::PROTOBUF_NAMESPACE_ID::int32 value);
5248 private:
5249 ::PROTOBUF_NAMESPACE_ID::int32 _internal_content_num_chunks() const;
5250 void _internal_set_content_num_chunks(::PROTOBUF_NAMESPACE_ID::int32 value);
5251 public:
5252
5253 // optional int32 content_chunk_id = 7;
5254 bool has_content_chunk_id() const;
5255 private:
5256 bool _internal_has_content_chunk_id() const;
5257 public:
5258 void clear_content_chunk_id();
5259 ::PROTOBUF_NAMESPACE_ID::int32 content_chunk_id() const;
5260 void set_content_chunk_id(::PROTOBUF_NAMESPACE_ID::int32 value);
5261 private:
5262 ::PROTOBUF_NAMESPACE_ID::int32 _internal_content_chunk_id() const;
5263 void _internal_set_content_chunk_id(::PROTOBUF_NAMESPACE_ID::int32 value);
5264 public:
5265
5266 // @@protoc_insertion_point(class_scope:caffe2.BlobProto)
5267 private:
5268 class _Internal;
5269
5270 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
5271 typedef void InternalArenaConstructable_;
5272 typedef void DestructorSkippable_;
5273 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
5274 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
5275 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
5276 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
5277 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_;
5278 ::caffe2::TensorProto* tensor_;
5279 ::caffe2::QTensorProto* qtensor_;
5280 ::PROTOBUF_NAMESPACE_ID::int32 content_num_chunks_;
5281 ::PROTOBUF_NAMESPACE_ID::int32 content_chunk_id_;
5282 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
5283};
5284// -------------------------------------------------------------------
5285
5286class TORCH_API DBReaderProto PROTOBUF_FINAL :
5287 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.DBReaderProto) */ {
5288 public:
5289 inline DBReaderProto() : DBReaderProto(nullptr) {}
5290 virtual ~DBReaderProto();
5291
5292 DBReaderProto(const DBReaderProto& from);
5293 DBReaderProto(DBReaderProto&& from) noexcept
5294 : DBReaderProto() {
5295 *this = ::std::move(from);
5296 }
5297
5298 inline DBReaderProto& operator=(const DBReaderProto& from) {
5299 CopyFrom(from);
5300 return *this;
5301 }
5302 inline DBReaderProto& operator=(DBReaderProto&& from) noexcept {
5303 if (GetArena() == from.GetArena()) {
5304 if (this != &from) InternalSwap(&from);
5305 } else {
5306 CopyFrom(from);
5307 }
5308 return *this;
5309 }
5310
5311 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
5312 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
5313 }
5314 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
5315 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
5316 }
5317
5318 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
5319 return GetDescriptor();
5320 }
5321 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
5322 return GetMetadataStatic().descriptor;
5323 }
5324 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
5325 return GetMetadataStatic().reflection;
5326 }
5327 static const DBReaderProto& default_instance();
5328
5329 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
5330 static inline const DBReaderProto* internal_default_instance() {
5331 return reinterpret_cast<const DBReaderProto*>(
5332 &_DBReaderProto_default_instance_);
5333 }
5334 static constexpr int kIndexInFileMessages =
5335 19;
5336
5337 friend void swap(DBReaderProto& a, DBReaderProto& b) {
5338 a.Swap(&b);
5339 }
5340 inline void Swap(DBReaderProto* other) {
5341 if (other == this) return;
5342 if (GetArena() == other->GetArena()) {
5343 InternalSwap(other);
5344 } else {
5345 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
5346 }
5347 }
5348 void UnsafeArenaSwap(DBReaderProto* other) {
5349 if (other == this) return;
5350 GOOGLE_DCHECK(GetArena() == other->GetArena());
5351 InternalSwap(other);
5352 }
5353
5354 // implements Message ----------------------------------------------
5355
5356 inline DBReaderProto* New() const final {
5357 return CreateMaybeMessage<DBReaderProto>(nullptr);
5358 }
5359
5360 DBReaderProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
5361 return CreateMaybeMessage<DBReaderProto>(arena);
5362 }
5363 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
5364 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
5365 void CopyFrom(const DBReaderProto& from);
5366 void MergeFrom(const DBReaderProto& from);
5367 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
5368 bool IsInitialized() const final;
5369
5370 size_t ByteSizeLong() const final;
5371 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
5372 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
5373 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
5374 int GetCachedSize() const final { return _cached_size_.Get(); }
5375
5376 private:
5377 inline void SharedCtor();
5378 inline void SharedDtor();
5379 void SetCachedSize(int size) const final;
5380 void InternalSwap(DBReaderProto* other);
5381 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
5382 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
5383 return "caffe2.DBReaderProto";
5384 }
5385 protected:
5386 explicit DBReaderProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
5387 private:
5388 static void ArenaDtor(void* object);
5389 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
5390 public:
5391
5392 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
5393 private:
5394 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
5395 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
5396 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
5397 }
5398
5399 public:
5400
5401 // nested types ----------------------------------------------------
5402
5403 // accessors -------------------------------------------------------
5404
5405 enum : int {
5406 kNameFieldNumber = 1,
5407 kSourceFieldNumber = 2,
5408 kDbTypeFieldNumber = 3,
5409 kKeyFieldNumber = 4,
5410 };
5411 // optional string name = 1;
5412 bool has_name() const;
5413 private:
5414 bool _internal_has_name() const;
5415 public:
5416 void clear_name();
5417 const std::string& name() const;
5418 void set_name(const std::string& value);
5419 void set_name(std::string&& value);
5420 void set_name(const char* value);
5421 void set_name(const char* value, size_t size);
5422 std::string* mutable_name();
5423 std::string* release_name();
5424 void set_allocated_name(std::string* name);
5425 private:
5426 const std::string& _internal_name() const;
5427 void _internal_set_name(const std::string& value);
5428 std::string* _internal_mutable_name();
5429 public:
5430
5431 // optional string source = 2;
5432 bool has_source() const;
5433 private:
5434 bool _internal_has_source() const;
5435 public:
5436 void clear_source();
5437 const std::string& source() const;
5438 void set_source(const std::string& value);
5439 void set_source(std::string&& value);
5440 void set_source(const char* value);
5441 void set_source(const char* value, size_t size);
5442 std::string* mutable_source();
5443 std::string* release_source();
5444 void set_allocated_source(std::string* source);
5445 private:
5446 const std::string& _internal_source() const;
5447 void _internal_set_source(const std::string& value);
5448 std::string* _internal_mutable_source();
5449 public:
5450
5451 // optional string db_type = 3;
5452 bool has_db_type() const;
5453 private:
5454 bool _internal_has_db_type() const;
5455 public:
5456 void clear_db_type();
5457 const std::string& db_type() const;
5458 void set_db_type(const std::string& value);
5459 void set_db_type(std::string&& value);
5460 void set_db_type(const char* value);
5461 void set_db_type(const char* value, size_t size);
5462 std::string* mutable_db_type();
5463 std::string* release_db_type();
5464 void set_allocated_db_type(std::string* db_type);
5465 private:
5466 const std::string& _internal_db_type() const;
5467 void _internal_set_db_type(const std::string& value);
5468 std::string* _internal_mutable_db_type();
5469 public:
5470
5471 // optional string key = 4;
5472 bool has_key() const;
5473 private:
5474 bool _internal_has_key() const;
5475 public:
5476 void clear_key();
5477 const std::string& key() const;
5478 void set_key(const std::string& value);
5479 void set_key(std::string&& value);
5480 void set_key(const char* value);
5481 void set_key(const char* value, size_t size);
5482 std::string* mutable_key();
5483 std::string* release_key();
5484 void set_allocated_key(std::string* key);
5485 private:
5486 const std::string& _internal_key() const;
5487 void _internal_set_key(const std::string& value);
5488 std::string* _internal_mutable_key();
5489 public:
5490
5491 // @@protoc_insertion_point(class_scope:caffe2.DBReaderProto)
5492 private:
5493 class _Internal;
5494
5495 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
5496 typedef void InternalArenaConstructable_;
5497 typedef void DestructorSkippable_;
5498 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
5499 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
5500 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
5501 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
5502 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr db_type_;
5503 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
5504 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
5505};
5506// -------------------------------------------------------------------
5507
5508class TORCH_API BlobSerializationOptions PROTOBUF_FINAL :
5509 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.BlobSerializationOptions) */ {
5510 public:
5511 inline BlobSerializationOptions() : BlobSerializationOptions(nullptr) {}
5512 virtual ~BlobSerializationOptions();
5513
5514 BlobSerializationOptions(const BlobSerializationOptions& from);
5515 BlobSerializationOptions(BlobSerializationOptions&& from) noexcept
5516 : BlobSerializationOptions() {
5517 *this = ::std::move(from);
5518 }
5519
5520 inline BlobSerializationOptions& operator=(const BlobSerializationOptions& from) {
5521 CopyFrom(from);
5522 return *this;
5523 }
5524 inline BlobSerializationOptions& operator=(BlobSerializationOptions&& from) noexcept {
5525 if (GetArena() == from.GetArena()) {
5526 if (this != &from) InternalSwap(&from);
5527 } else {
5528 CopyFrom(from);
5529 }
5530 return *this;
5531 }
5532
5533 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
5534 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
5535 }
5536 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
5537 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
5538 }
5539
5540 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
5541 return GetDescriptor();
5542 }
5543 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
5544 return GetMetadataStatic().descriptor;
5545 }
5546 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
5547 return GetMetadataStatic().reflection;
5548 }
5549 static const BlobSerializationOptions& default_instance();
5550
5551 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
5552 static inline const BlobSerializationOptions* internal_default_instance() {
5553 return reinterpret_cast<const BlobSerializationOptions*>(
5554 &_BlobSerializationOptions_default_instance_);
5555 }
5556 static constexpr int kIndexInFileMessages =
5557 20;
5558
5559 friend void swap(BlobSerializationOptions& a, BlobSerializationOptions& b) {
5560 a.Swap(&b);
5561 }
5562 inline void Swap(BlobSerializationOptions* other) {
5563 if (other == this) return;
5564 if (GetArena() == other->GetArena()) {
5565 InternalSwap(other);
5566 } else {
5567 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
5568 }
5569 }
5570 void UnsafeArenaSwap(BlobSerializationOptions* other) {
5571 if (other == this) return;
5572 GOOGLE_DCHECK(GetArena() == other->GetArena());
5573 InternalSwap(other);
5574 }
5575
5576 // implements Message ----------------------------------------------
5577
5578 inline BlobSerializationOptions* New() const final {
5579 return CreateMaybeMessage<BlobSerializationOptions>(nullptr);
5580 }
5581
5582 BlobSerializationOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
5583 return CreateMaybeMessage<BlobSerializationOptions>(arena);
5584 }
5585 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
5586 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
5587 void CopyFrom(const BlobSerializationOptions& from);
5588 void MergeFrom(const BlobSerializationOptions& from);
5589 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
5590 bool IsInitialized() const final;
5591
5592 size_t ByteSizeLong() const final;
5593 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
5594 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
5595 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
5596 int GetCachedSize() const final { return _cached_size_.Get(); }
5597
5598 private:
5599 inline void SharedCtor();
5600 inline void SharedDtor();
5601 void SetCachedSize(int size) const final;
5602 void InternalSwap(BlobSerializationOptions* other);
5603 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
5604 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
5605 return "caffe2.BlobSerializationOptions";
5606 }
5607 protected:
5608 explicit BlobSerializationOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
5609 private:
5610 static void ArenaDtor(void* object);
5611 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
5612 public:
5613
5614 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
5615 private:
5616 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
5617 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
5618 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
5619 }
5620
5621 public:
5622
5623 // nested types ----------------------------------------------------
5624
5625 typedef BlobSerializationOptions_FloatFormat FloatFormat;
5626 static constexpr FloatFormat FLOAT_DEFAULT =
5627 BlobSerializationOptions_FloatFormat_FLOAT_DEFAULT;
5628 static constexpr FloatFormat FLOAT_PROTOBUF =
5629 BlobSerializationOptions_FloatFormat_FLOAT_PROTOBUF;
5630 static constexpr FloatFormat FLOAT_BFLOAT16 =
5631 BlobSerializationOptions_FloatFormat_FLOAT_BFLOAT16;
5632 static inline bool FloatFormat_IsValid(int value) {
5633 return BlobSerializationOptions_FloatFormat_IsValid(value);
5634 }
5635 static constexpr FloatFormat FloatFormat_MIN =
5636 BlobSerializationOptions_FloatFormat_FloatFormat_MIN;
5637 static constexpr FloatFormat FloatFormat_MAX =
5638 BlobSerializationOptions_FloatFormat_FloatFormat_MAX;
5639 static constexpr int FloatFormat_ARRAYSIZE =
5640 BlobSerializationOptions_FloatFormat_FloatFormat_ARRAYSIZE;
5641 static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
5642 FloatFormat_descriptor() {
5643 return BlobSerializationOptions_FloatFormat_descriptor();
5644 }
5645 template<typename T>
5646 static inline const std::string& FloatFormat_Name(T enum_t_value) {
5647 static_assert(::std::is_same<T, FloatFormat>::value ||
5648 ::std::is_integral<T>::value,
5649 "Incorrect type passed to function FloatFormat_Name.");
5650 return BlobSerializationOptions_FloatFormat_Name(enum_t_value);
5651 }
5652 static inline bool FloatFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
5653 FloatFormat* value) {
5654 return BlobSerializationOptions_FloatFormat_Parse(name, value);
5655 }
5656
5657 // accessors -------------------------------------------------------
5658
5659 enum : int {
5660 kBlobNameRegexFieldNumber = 1,
5661 kChunkSizeFieldNumber = 2,
5662 kFloatFormatFieldNumber = 3,
5663 };
5664 // optional string blob_name_regex = 1;
5665 bool has_blob_name_regex() const;
5666 private:
5667 bool _internal_has_blob_name_regex() const;
5668 public:
5669 void clear_blob_name_regex();
5670 const std::string& blob_name_regex() const;
5671 void set_blob_name_regex(const std::string& value);
5672 void set_blob_name_regex(std::string&& value);
5673 void set_blob_name_regex(const char* value);
5674 void set_blob_name_regex(const char* value, size_t size);
5675 std::string* mutable_blob_name_regex();
5676 std::string* release_blob_name_regex();
5677 void set_allocated_blob_name_regex(std::string* blob_name_regex);
5678 private:
5679 const std::string& _internal_blob_name_regex() const;
5680 void _internal_set_blob_name_regex(const std::string& value);
5681 std::string* _internal_mutable_blob_name_regex();
5682 public:
5683
5684 // optional int64 chunk_size = 2;
5685 bool has_chunk_size() const;
5686 private:
5687 bool _internal_has_chunk_size() const;
5688 public:
5689 void clear_chunk_size();
5690 ::PROTOBUF_NAMESPACE_ID::int64 chunk_size() const;
5691 void set_chunk_size(::PROTOBUF_NAMESPACE_ID::int64 value);
5692 private:
5693 ::PROTOBUF_NAMESPACE_ID::int64 _internal_chunk_size() const;
5694 void _internal_set_chunk_size(::PROTOBUF_NAMESPACE_ID::int64 value);
5695 public:
5696
5697 // optional .caffe2.BlobSerializationOptions.FloatFormat float_format = 3;
5698 bool has_float_format() const;
5699 private:
5700 bool _internal_has_float_format() const;
5701 public:
5702 void clear_float_format();
5703 ::caffe2::BlobSerializationOptions_FloatFormat float_format() const;
5704 void set_float_format(::caffe2::BlobSerializationOptions_FloatFormat value);
5705 private:
5706 ::caffe2::BlobSerializationOptions_FloatFormat _internal_float_format() const;
5707 void _internal_set_float_format(::caffe2::BlobSerializationOptions_FloatFormat value);
5708 public:
5709
5710 // @@protoc_insertion_point(class_scope:caffe2.BlobSerializationOptions)
5711 private:
5712 class _Internal;
5713
5714 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
5715 typedef void InternalArenaConstructable_;
5716 typedef void DestructorSkippable_;
5717 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
5718 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
5719 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blob_name_regex_;
5720 ::PROTOBUF_NAMESPACE_ID::int64 chunk_size_;
5721 int float_format_;
5722 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
5723};
5724// -------------------------------------------------------------------
5725
5726class TORCH_API SerializationOptions PROTOBUF_FINAL :
5727 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.SerializationOptions) */ {
5728 public:
5729 inline SerializationOptions() : SerializationOptions(nullptr) {}
5730 virtual ~SerializationOptions();
5731
5732 SerializationOptions(const SerializationOptions& from);
5733 SerializationOptions(SerializationOptions&& from) noexcept
5734 : SerializationOptions() {
5735 *this = ::std::move(from);
5736 }
5737
5738 inline SerializationOptions& operator=(const SerializationOptions& from) {
5739 CopyFrom(from);
5740 return *this;
5741 }
5742 inline SerializationOptions& operator=(SerializationOptions&& from) noexcept {
5743 if (GetArena() == from.GetArena()) {
5744 if (this != &from) InternalSwap(&from);
5745 } else {
5746 CopyFrom(from);
5747 }
5748 return *this;
5749 }
5750
5751 inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
5752 return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
5753 }
5754 inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
5755 return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
5756 }
5757
5758 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
5759 return GetDescriptor();
5760 }
5761 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
5762 return GetMetadataStatic().descriptor;
5763 }
5764 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
5765 return GetMetadataStatic().reflection;
5766 }
5767 static const SerializationOptions& default_instance();
5768
5769 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
5770 static inline const SerializationOptions* internal_default_instance() {
5771 return reinterpret_cast<const SerializationOptions*>(
5772 &_SerializationOptions_default_instance_);
5773 }
5774 static constexpr int kIndexInFileMessages =
5775 21;
5776
5777 friend void swap(SerializationOptions& a, SerializationOptions& b) {
5778 a.Swap(&b);
5779 }
5780 inline void Swap(SerializationOptions* other) {
5781 if (other == this) return;
5782 if (GetArena() == other->GetArena()) {
5783 InternalSwap(other);
5784 } else {
5785 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
5786 }
5787 }
5788 void UnsafeArenaSwap(SerializationOptions* other) {
5789 if (other == this) return;
5790 GOOGLE_DCHECK(GetArena() == other->GetArena());
5791 InternalSwap(other);
5792 }
5793
5794 // implements Message ----------------------------------------------
5795
5796 inline SerializationOptions* New() const final {
5797 return CreateMaybeMessage<SerializationOptions>(nullptr);
5798 }
5799
5800 SerializationOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
5801 return CreateMaybeMessage<SerializationOptions>(arena);
5802 }
5803 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
5804 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
5805 void CopyFrom(const SerializationOptions& from);
5806 void MergeFrom(const SerializationOptions& from);
5807 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
5808 bool IsInitialized() const final;
5809
5810 size_t ByteSizeLong() const final;
5811 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
5812 ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
5813 ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
5814 int GetCachedSize() const final { return _cached_size_.Get(); }
5815
5816 private:
5817 inline void SharedCtor();
5818 inline void SharedDtor();
5819 void SetCachedSize(int size) const final;
5820 void InternalSwap(SerializationOptions* other);
5821 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
5822 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
5823 return "caffe2.SerializationOptions";
5824 }
5825 protected:
5826 explicit SerializationOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
5827 private:
5828 static void ArenaDtor(void* object);
5829 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
5830 public:
5831
5832 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
5833 private:
5834 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
5835 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
5836 return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
5837 }
5838
5839 public:
5840
5841 // nested types ----------------------------------------------------
5842
5843 // accessors -------------------------------------------------------
5844
5845 enum : int {
5846 kOptionsFieldNumber = 1,
5847 };
5848 // repeated .caffe2.BlobSerializationOptions options = 1;
5849 int options_size() const;
5850 private:
5851 int _internal_options_size() const;
5852 public:
5853 void clear_options();
5854 ::caffe2::BlobSerializationOptions* mutable_options(int index);
5855 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions >*
5856 mutable_options();
5857 private:
5858 const ::caffe2::BlobSerializationOptions& _internal_options(int index) const;
5859 ::caffe2::BlobSerializationOptions* _internal_add_options();
5860 public:
5861 const ::caffe2::BlobSerializationOptions& options(int index) const;
5862 ::caffe2::BlobSerializationOptions* add_options();
5863 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions >&
5864 options() const;
5865
5866 // @@protoc_insertion_point(class_scope:caffe2.SerializationOptions)
5867 private:
5868 class _Internal;
5869
5870 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
5871 typedef void InternalArenaConstructable_;
5872 typedef void DestructorSkippable_;
5873 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions > options_;
5874 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
5875 friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
5876};
5877// ===================================================================
5878
5879
5880// ===================================================================
5881
5882#ifdef __GNUC__
5883 #pragma GCC diagnostic push
5884 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
5885#endif // __GNUC__
5886// TensorProto_Segment
5887
5888// required int64 begin = 1;
5889inline bool TensorProto_Segment::_internal_has_begin() const {
5890 bool value = (_has_bits_[0] & 0x00000001u) != 0;
5891 return value;
5892}
5893inline bool TensorProto_Segment::has_begin() const {
5894 return _internal_has_begin();
5895}
5896inline void TensorProto_Segment::clear_begin() {
5897 begin_ = PROTOBUF_LONGLONG(0);
5898 _has_bits_[0] &= ~0x00000001u;
5899}
5900inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::_internal_begin() const {
5901 return begin_;
5902}
5903inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::begin() const {
5904 // @@protoc_insertion_point(field_get:caffe2.TensorProto.Segment.begin)
5905 return _internal_begin();
5906}
5907inline void TensorProto_Segment::_internal_set_begin(::PROTOBUF_NAMESPACE_ID::int64 value) {
5908 _has_bits_[0] |= 0x00000001u;
5909 begin_ = value;
5910}
5911inline void TensorProto_Segment::set_begin(::PROTOBUF_NAMESPACE_ID::int64 value) {
5912 _internal_set_begin(value);
5913 // @@protoc_insertion_point(field_set:caffe2.TensorProto.Segment.begin)
5914}
5915
5916// required int64 end = 2;
5917inline bool TensorProto_Segment::_internal_has_end() const {
5918 bool value = (_has_bits_[0] & 0x00000002u) != 0;
5919 return value;
5920}
5921inline bool TensorProto_Segment::has_end() const {
5922 return _internal_has_end();
5923}
5924inline void TensorProto_Segment::clear_end() {
5925 end_ = PROTOBUF_LONGLONG(0);
5926 _has_bits_[0] &= ~0x00000002u;
5927}
5928inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::_internal_end() const {
5929 return end_;
5930}
5931inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::end() const {
5932 // @@protoc_insertion_point(field_get:caffe2.TensorProto.Segment.end)
5933 return _internal_end();
5934}
5935inline void TensorProto_Segment::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int64 value) {
5936 _has_bits_[0] |= 0x00000002u;
5937 end_ = value;
5938}
5939inline void TensorProto_Segment::set_end(::PROTOBUF_NAMESPACE_ID::int64 value) {
5940 _internal_set_end(value);
5941 // @@protoc_insertion_point(field_set:caffe2.TensorProto.Segment.end)
5942}
5943
5944// -------------------------------------------------------------------
5945
5946// TensorProto
5947
5948// repeated int64 dims = 1;
5949inline int TensorProto::_internal_dims_size() const {
5950 return dims_.size();
5951}
5952inline int TensorProto::dims_size() const {
5953 return _internal_dims_size();
5954}
5955inline void TensorProto::clear_dims() {
5956 dims_.Clear();
5957}
5958inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::_internal_dims(int index) const {
5959 return dims_.Get(index);
5960}
5961inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::dims(int index) const {
5962 // @@protoc_insertion_point(field_get:caffe2.TensorProto.dims)
5963 return _internal_dims(index);
5964}
5965inline void TensorProto::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
5966 dims_.Set(index, value);
5967 // @@protoc_insertion_point(field_set:caffe2.TensorProto.dims)
5968}
5969inline void TensorProto::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
5970 dims_.Add(value);
5971}
5972inline void TensorProto::add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
5973 _internal_add_dims(value);
5974 // @@protoc_insertion_point(field_add:caffe2.TensorProto.dims)
5975}
5976inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
5977TensorProto::_internal_dims() const {
5978 return dims_;
5979}
5980inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
5981TensorProto::dims() const {
5982 // @@protoc_insertion_point(field_list:caffe2.TensorProto.dims)
5983 return _internal_dims();
5984}
5985inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
5986TensorProto::_internal_mutable_dims() {
5987 return &dims_;
5988}
5989inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
5990TensorProto::mutable_dims() {
5991 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.dims)
5992 return _internal_mutable_dims();
5993}
5994
5995// optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT];
5996inline bool TensorProto::_internal_has_data_type() const {
5997 bool value = (_has_bits_[0] & 0x00000040u) != 0;
5998 return value;
5999}
6000inline bool TensorProto::has_data_type() const {
6001 return _internal_has_data_type();
6002}
6003inline void TensorProto::clear_data_type() {
6004 data_type_ = 1;
6005 _has_bits_[0] &= ~0x00000040u;
6006}
6007inline ::caffe2::TensorProto_DataType TensorProto::_internal_data_type() const {
6008 return static_cast< ::caffe2::TensorProto_DataType >(data_type_);
6009}
6010inline ::caffe2::TensorProto_DataType TensorProto::data_type() const {
6011 // @@protoc_insertion_point(field_get:caffe2.TensorProto.data_type)
6012 return _internal_data_type();
6013}
6014inline void TensorProto::_internal_set_data_type(::caffe2::TensorProto_DataType value) {
6015 assert(::caffe2::TensorProto_DataType_IsValid(value));
6016 _has_bits_[0] |= 0x00000040u;
6017 data_type_ = value;
6018}
6019inline void TensorProto::set_data_type(::caffe2::TensorProto_DataType value) {
6020 _internal_set_data_type(value);
6021 // @@protoc_insertion_point(field_set:caffe2.TensorProto.data_type)
6022}
6023
6024// optional uint32 data_format = 15 [default = 0];
6025inline bool TensorProto::_internal_has_data_format() const {
6026 bool value = (_has_bits_[0] & 0x00000020u) != 0;
6027 return value;
6028}
6029inline bool TensorProto::has_data_format() const {
6030 return _internal_has_data_format();
6031}
6032inline void TensorProto::clear_data_format() {
6033 data_format_ = 0u;
6034 _has_bits_[0] &= ~0x00000020u;
6035}
6036inline ::PROTOBUF_NAMESPACE_ID::uint32 TensorProto::_internal_data_format() const {
6037 return data_format_;
6038}
6039inline ::PROTOBUF_NAMESPACE_ID::uint32 TensorProto::data_format() const {
6040 // @@protoc_insertion_point(field_get:caffe2.TensorProto.data_format)
6041 return _internal_data_format();
6042}
6043inline void TensorProto::_internal_set_data_format(::PROTOBUF_NAMESPACE_ID::uint32 value) {
6044 _has_bits_[0] |= 0x00000020u;
6045 data_format_ = value;
6046}
6047inline void TensorProto::set_data_format(::PROTOBUF_NAMESPACE_ID::uint32 value) {
6048 _internal_set_data_format(value);
6049 // @@protoc_insertion_point(field_set:caffe2.TensorProto.data_format)
6050}
6051
6052// repeated float float_data = 3 [packed = true];
6053inline int TensorProto::_internal_float_data_size() const {
6054 return float_data_.size();
6055}
6056inline int TensorProto::float_data_size() const {
6057 return _internal_float_data_size();
6058}
6059inline void TensorProto::clear_float_data() {
6060 float_data_.Clear();
6061}
6062inline float TensorProto::_internal_float_data(int index) const {
6063 return float_data_.Get(index);
6064}
6065inline float TensorProto::float_data(int index) const {
6066 // @@protoc_insertion_point(field_get:caffe2.TensorProto.float_data)
6067 return _internal_float_data(index);
6068}
6069inline void TensorProto::set_float_data(int index, float value) {
6070 float_data_.Set(index, value);
6071 // @@protoc_insertion_point(field_set:caffe2.TensorProto.float_data)
6072}
6073inline void TensorProto::_internal_add_float_data(float value) {
6074 float_data_.Add(value);
6075}
6076inline void TensorProto::add_float_data(float value) {
6077 _internal_add_float_data(value);
6078 // @@protoc_insertion_point(field_add:caffe2.TensorProto.float_data)
6079}
6080inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
6081TensorProto::_internal_float_data() const {
6082 return float_data_;
6083}
6084inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
6085TensorProto::float_data() const {
6086 // @@protoc_insertion_point(field_list:caffe2.TensorProto.float_data)
6087 return _internal_float_data();
6088}
6089inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
6090TensorProto::_internal_mutable_float_data() {
6091 return &float_data_;
6092}
6093inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
6094TensorProto::mutable_float_data() {
6095 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.float_data)
6096 return _internal_mutable_float_data();
6097}
6098
6099// repeated int32 int32_data = 4 [packed = true];
6100inline int TensorProto::_internal_int32_data_size() const {
6101 return int32_data_.size();
6102}
6103inline int TensorProto::int32_data_size() const {
6104 return _internal_int32_data_size();
6105}
6106inline void TensorProto::clear_int32_data() {
6107 int32_data_.Clear();
6108}
6109inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::_internal_int32_data(int index) const {
6110 return int32_data_.Get(index);
6111}
6112inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::int32_data(int index) const {
6113 // @@protoc_insertion_point(field_get:caffe2.TensorProto.int32_data)
6114 return _internal_int32_data(index);
6115}
6116inline void TensorProto::set_int32_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
6117 int32_data_.Set(index, value);
6118 // @@protoc_insertion_point(field_set:caffe2.TensorProto.int32_data)
6119}
6120inline void TensorProto::_internal_add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value) {
6121 int32_data_.Add(value);
6122}
6123inline void TensorProto::add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value) {
6124 _internal_add_int32_data(value);
6125 // @@protoc_insertion_point(field_add:caffe2.TensorProto.int32_data)
6126}
6127inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
6128TensorProto::_internal_int32_data() const {
6129 return int32_data_;
6130}
6131inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
6132TensorProto::int32_data() const {
6133 // @@protoc_insertion_point(field_list:caffe2.TensorProto.int32_data)
6134 return _internal_int32_data();
6135}
6136inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
6137TensorProto::_internal_mutable_int32_data() {
6138 return &int32_data_;
6139}
6140inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
6141TensorProto::mutable_int32_data() {
6142 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.int32_data)
6143 return _internal_mutable_int32_data();
6144}
6145
6146// optional bytes byte_data = 5;
6147inline bool TensorProto::_internal_has_byte_data() const {
6148 bool value = (_has_bits_[0] & 0x00000001u) != 0;
6149 return value;
6150}
6151inline bool TensorProto::has_byte_data() const {
6152 return _internal_has_byte_data();
6153}
6154inline void TensorProto::clear_byte_data() {
6155 byte_data_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
6156 _has_bits_[0] &= ~0x00000001u;
6157}
6158inline const std::string& TensorProto::byte_data() const {
6159 // @@protoc_insertion_point(field_get:caffe2.TensorProto.byte_data)
6160 return _internal_byte_data();
6161}
6162inline void TensorProto::set_byte_data(const std::string& value) {
6163 _internal_set_byte_data(value);
6164 // @@protoc_insertion_point(field_set:caffe2.TensorProto.byte_data)
6165}
6166inline std::string* TensorProto::mutable_byte_data() {
6167 // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.byte_data)
6168 return _internal_mutable_byte_data();
6169}
6170inline const std::string& TensorProto::_internal_byte_data() const {
6171 return byte_data_.Get();
6172}
6173inline void TensorProto::_internal_set_byte_data(const std::string& value) {
6174 _has_bits_[0] |= 0x00000001u;
6175 byte_data_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
6176}
6177inline void TensorProto::set_byte_data(std::string&& value) {
6178 _has_bits_[0] |= 0x00000001u;
6179 byte_data_.Set(
6180 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
6181 // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorProto.byte_data)
6182}
6183inline void TensorProto::set_byte_data(const char* value) {
6184 GOOGLE_DCHECK(value != nullptr);
6185 _has_bits_[0] |= 0x00000001u;
6186 byte_data_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
6187 GetArena());
6188 // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.byte_data)
6189}
6190inline void TensorProto::set_byte_data(const void* value,
6191 size_t size) {
6192 _has_bits_[0] |= 0x00000001u;
6193 byte_data_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
6194 reinterpret_cast<const char*>(value), size), GetArena());
6195 // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.byte_data)
6196}
6197inline std::string* TensorProto::_internal_mutable_byte_data() {
6198 _has_bits_[0] |= 0x00000001u;
6199 return byte_data_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
6200}
6201inline std::string* TensorProto::release_byte_data() {
6202 // @@protoc_insertion_point(field_release:caffe2.TensorProto.byte_data)
6203 if (!_internal_has_byte_data()) {
6204 return nullptr;
6205 }
6206 _has_bits_[0] &= ~0x00000001u;
6207 return byte_data_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
6208}
6209inline void TensorProto::set_allocated_byte_data(std::string* byte_data) {
6210 if (byte_data != nullptr) {
6211 _has_bits_[0] |= 0x00000001u;
6212 } else {
6213 _has_bits_[0] &= ~0x00000001u;
6214 }
6215 byte_data_.SetAllocated(&GetEmptyStringAlreadyInited(), byte_data,
6216 GetArena());
6217 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.byte_data)
6218}
6219
6220// repeated bytes string_data = 6;
6221inline int TensorProto::_internal_string_data_size() const {
6222 return string_data_.size();
6223}
6224inline int TensorProto::string_data_size() const {
6225 return _internal_string_data_size();
6226}
6227inline void TensorProto::clear_string_data() {
6228 string_data_.Clear();
6229}
6230inline std::string* TensorProto::add_string_data() {
6231 // @@protoc_insertion_point(field_add_mutable:caffe2.TensorProto.string_data)
6232 return _internal_add_string_data();
6233}
6234inline const std::string& TensorProto::_internal_string_data(int index) const {
6235 return string_data_.Get(index);
6236}
6237inline const std::string& TensorProto::string_data(int index) const {
6238 // @@protoc_insertion_point(field_get:caffe2.TensorProto.string_data)
6239 return _internal_string_data(index);
6240}
6241inline std::string* TensorProto::mutable_string_data(int index) {
6242 // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.string_data)
6243 return string_data_.Mutable(index);
6244}
6245inline void TensorProto::set_string_data(int index, const std::string& value) {
6246 // @@protoc_insertion_point(field_set:caffe2.TensorProto.string_data)
6247 string_data_.Mutable(index)->assign(value);
6248}
6249inline void TensorProto::set_string_data(int index, std::string&& value) {
6250 // @@protoc_insertion_point(field_set:caffe2.TensorProto.string_data)
6251 string_data_.Mutable(index)->assign(std::move(value));
6252}
6253inline void TensorProto::set_string_data(int index, const char* value) {
6254 GOOGLE_DCHECK(value != nullptr);
6255 string_data_.Mutable(index)->assign(value);
6256 // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.string_data)
6257}
6258inline void TensorProto::set_string_data(int index, const void* value, size_t size) {
6259 string_data_.Mutable(index)->assign(
6260 reinterpret_cast<const char*>(value), size);
6261 // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.string_data)
6262}
6263inline std::string* TensorProto::_internal_add_string_data() {
6264 return string_data_.Add();
6265}
6266inline void TensorProto::add_string_data(const std::string& value) {
6267 string_data_.Add()->assign(value);
6268 // @@protoc_insertion_point(field_add:caffe2.TensorProto.string_data)
6269}
6270inline void TensorProto::add_string_data(std::string&& value) {
6271 string_data_.Add(std::move(value));
6272 // @@protoc_insertion_point(field_add:caffe2.TensorProto.string_data)
6273}
6274inline void TensorProto::add_string_data(const char* value) {
6275 GOOGLE_DCHECK(value != nullptr);
6276 string_data_.Add()->assign(value);
6277 // @@protoc_insertion_point(field_add_char:caffe2.TensorProto.string_data)
6278}
6279inline void TensorProto::add_string_data(const void* value, size_t size) {
6280 string_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
6281 // @@protoc_insertion_point(field_add_pointer:caffe2.TensorProto.string_data)
6282}
6283inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
6284TensorProto::string_data() const {
6285 // @@protoc_insertion_point(field_list:caffe2.TensorProto.string_data)
6286 return string_data_;
6287}
6288inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
6289TensorProto::mutable_string_data() {
6290 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.string_data)
6291 return &string_data_;
6292}
6293
6294// repeated double double_data = 9 [packed = true];
6295inline int TensorProto::_internal_double_data_size() const {
6296 return double_data_.size();
6297}
6298inline int TensorProto::double_data_size() const {
6299 return _internal_double_data_size();
6300}
6301inline void TensorProto::clear_double_data() {
6302 double_data_.Clear();
6303}
6304inline double TensorProto::_internal_double_data(int index) const {
6305 return double_data_.Get(index);
6306}
6307inline double TensorProto::double_data(int index) const {
6308 // @@protoc_insertion_point(field_get:caffe2.TensorProto.double_data)
6309 return _internal_double_data(index);
6310}
6311inline void TensorProto::set_double_data(int index, double value) {
6312 double_data_.Set(index, value);
6313 // @@protoc_insertion_point(field_set:caffe2.TensorProto.double_data)
6314}
6315inline void TensorProto::_internal_add_double_data(double value) {
6316 double_data_.Add(value);
6317}
6318inline void TensorProto::add_double_data(double value) {
6319 _internal_add_double_data(value);
6320 // @@protoc_insertion_point(field_add:caffe2.TensorProto.double_data)
6321}
6322inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
6323TensorProto::_internal_double_data() const {
6324 return double_data_;
6325}
6326inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
6327TensorProto::double_data() const {
6328 // @@protoc_insertion_point(field_list:caffe2.TensorProto.double_data)
6329 return _internal_double_data();
6330}
6331inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
6332TensorProto::_internal_mutable_double_data() {
6333 return &double_data_;
6334}
6335inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
6336TensorProto::mutable_double_data() {
6337 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.double_data)
6338 return _internal_mutable_double_data();
6339}
6340
6341// repeated int64 int64_data = 10 [packed = true];
6342inline int TensorProto::_internal_int64_data_size() const {
6343 return int64_data_.size();
6344}
6345inline int TensorProto::int64_data_size() const {
6346 return _internal_int64_data_size();
6347}
6348inline void TensorProto::clear_int64_data() {
6349 int64_data_.Clear();
6350}
6351inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::_internal_int64_data(int index) const {
6352 return int64_data_.Get(index);
6353}
6354inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::int64_data(int index) const {
6355 // @@protoc_insertion_point(field_get:caffe2.TensorProto.int64_data)
6356 return _internal_int64_data(index);
6357}
6358inline void TensorProto::set_int64_data(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
6359 int64_data_.Set(index, value);
6360 // @@protoc_insertion_point(field_set:caffe2.TensorProto.int64_data)
6361}
6362inline void TensorProto::_internal_add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value) {
6363 int64_data_.Add(value);
6364}
6365inline void TensorProto::add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value) {
6366 _internal_add_int64_data(value);
6367 // @@protoc_insertion_point(field_add:caffe2.TensorProto.int64_data)
6368}
6369inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
6370TensorProto::_internal_int64_data() const {
6371 return int64_data_;
6372}
6373inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
6374TensorProto::int64_data() const {
6375 // @@protoc_insertion_point(field_list:caffe2.TensorProto.int64_data)
6376 return _internal_int64_data();
6377}
6378inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
6379TensorProto::_internal_mutable_int64_data() {
6380 return &int64_data_;
6381}
6382inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
6383TensorProto::mutable_int64_data() {
6384 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.int64_data)
6385 return _internal_mutable_int64_data();
6386}
6387
6388// optional bytes raw_data = 13;
6389inline bool TensorProto::_internal_has_raw_data() const {
6390 bool value = (_has_bits_[0] & 0x00000004u) != 0;
6391 return value;
6392}
6393inline bool TensorProto::has_raw_data() const {
6394 return _internal_has_raw_data();
6395}
6396inline void TensorProto::clear_raw_data() {
6397 raw_data_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
6398 _has_bits_[0] &= ~0x00000004u;
6399}
6400inline const std::string& TensorProto::raw_data() const {
6401 // @@protoc_insertion_point(field_get:caffe2.TensorProto.raw_data)
6402 return _internal_raw_data();
6403}
6404inline void TensorProto::set_raw_data(const std::string& value) {
6405 _internal_set_raw_data(value);
6406 // @@protoc_insertion_point(field_set:caffe2.TensorProto.raw_data)
6407}
6408inline std::string* TensorProto::mutable_raw_data() {
6409 // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.raw_data)
6410 return _internal_mutable_raw_data();
6411}
6412inline const std::string& TensorProto::_internal_raw_data() const {
6413 return raw_data_.Get();
6414}
6415inline void TensorProto::_internal_set_raw_data(const std::string& value) {
6416 _has_bits_[0] |= 0x00000004u;
6417 raw_data_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
6418}
6419inline void TensorProto::set_raw_data(std::string&& value) {
6420 _has_bits_[0] |= 0x00000004u;
6421 raw_data_.Set(
6422 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
6423 // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorProto.raw_data)
6424}
6425inline void TensorProto::set_raw_data(const char* value) {
6426 GOOGLE_DCHECK(value != nullptr);
6427 _has_bits_[0] |= 0x00000004u;
6428 raw_data_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
6429 GetArena());
6430 // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.raw_data)
6431}
6432inline void TensorProto::set_raw_data(const void* value,
6433 size_t size) {
6434 _has_bits_[0] |= 0x00000004u;
6435 raw_data_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
6436 reinterpret_cast<const char*>(value), size), GetArena());
6437 // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.raw_data)
6438}
6439inline std::string* TensorProto::_internal_mutable_raw_data() {
6440 _has_bits_[0] |= 0x00000004u;
6441 return raw_data_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
6442}
6443inline std::string* TensorProto::release_raw_data() {
6444 // @@protoc_insertion_point(field_release:caffe2.TensorProto.raw_data)
6445 if (!_internal_has_raw_data()) {
6446 return nullptr;
6447 }
6448 _has_bits_[0] &= ~0x00000004u;
6449 return raw_data_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
6450}
6451inline void TensorProto::set_allocated_raw_data(std::string* raw_data) {
6452 if (raw_data != nullptr) {
6453 _has_bits_[0] |= 0x00000004u;
6454 } else {
6455 _has_bits_[0] &= ~0x00000004u;
6456 }
6457 raw_data_.SetAllocated(&GetEmptyStringAlreadyInited(), raw_data,
6458 GetArena());
6459 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.raw_data)
6460}
6461
6462// optional string name = 7;
6463inline bool TensorProto::_internal_has_name() const {
6464 bool value = (_has_bits_[0] & 0x00000002u) != 0;
6465 return value;
6466}
6467inline bool TensorProto::has_name() const {
6468 return _internal_has_name();
6469}
6470inline void TensorProto::clear_name() {
6471 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
6472 _has_bits_[0] &= ~0x00000002u;
6473}
6474inline const std::string& TensorProto::name() const {
6475 // @@protoc_insertion_point(field_get:caffe2.TensorProto.name)
6476 return _internal_name();
6477}
6478inline void TensorProto::set_name(const std::string& value) {
6479 _internal_set_name(value);
6480 // @@protoc_insertion_point(field_set:caffe2.TensorProto.name)
6481}
6482inline std::string* TensorProto::mutable_name() {
6483 // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.name)
6484 return _internal_mutable_name();
6485}
6486inline const std::string& TensorProto::_internal_name() const {
6487 return name_.Get();
6488}
6489inline void TensorProto::_internal_set_name(const std::string& value) {
6490 _has_bits_[0] |= 0x00000002u;
6491 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
6492}
6493inline void TensorProto::set_name(std::string&& value) {
6494 _has_bits_[0] |= 0x00000002u;
6495 name_.Set(
6496 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
6497 // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorProto.name)
6498}
6499inline void TensorProto::set_name(const char* value) {
6500 GOOGLE_DCHECK(value != nullptr);
6501 _has_bits_[0] |= 0x00000002u;
6502 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
6503 GetArena());
6504 // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.name)
6505}
6506inline void TensorProto::set_name(const char* value,
6507 size_t size) {
6508 _has_bits_[0] |= 0x00000002u;
6509 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
6510 reinterpret_cast<const char*>(value), size), GetArena());
6511 // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.name)
6512}
6513inline std::string* TensorProto::_internal_mutable_name() {
6514 _has_bits_[0] |= 0x00000002u;
6515 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
6516}
6517inline std::string* TensorProto::release_name() {
6518 // @@protoc_insertion_point(field_release:caffe2.TensorProto.name)
6519 if (!_internal_has_name()) {
6520 return nullptr;
6521 }
6522 _has_bits_[0] &= ~0x00000002u;
6523 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
6524}
6525inline void TensorProto::set_allocated_name(std::string* name) {
6526 if (name != nullptr) {
6527 _has_bits_[0] |= 0x00000002u;
6528 } else {
6529 _has_bits_[0] &= ~0x00000002u;
6530 }
6531 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
6532 GetArena());
6533 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.name)
6534}
6535
6536// optional .caffe2.DeviceOption device_detail = 8;
6537inline bool TensorProto::_internal_has_device_detail() const {
6538 bool value = (_has_bits_[0] & 0x00000008u) != 0;
6539 PROTOBUF_ASSUME(!value || device_detail_ != nullptr);
6540 return value;
6541}
6542inline bool TensorProto::has_device_detail() const {
6543 return _internal_has_device_detail();
6544}
6545inline void TensorProto::clear_device_detail() {
6546 if (device_detail_ != nullptr) device_detail_->Clear();
6547 _has_bits_[0] &= ~0x00000008u;
6548}
6549inline const ::caffe2::DeviceOption& TensorProto::_internal_device_detail() const {
6550 const ::caffe2::DeviceOption* p = device_detail_;
6551 return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::DeviceOption*>(
6552 &::caffe2::_DeviceOption_default_instance_);
6553}
6554inline const ::caffe2::DeviceOption& TensorProto::device_detail() const {
6555 // @@protoc_insertion_point(field_get:caffe2.TensorProto.device_detail)
6556 return _internal_device_detail();
6557}
6558inline void TensorProto::unsafe_arena_set_allocated_device_detail(
6559 ::caffe2::DeviceOption* device_detail) {
6560 if (GetArena() == nullptr) {
6561 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_detail_);
6562 }
6563 device_detail_ = device_detail;
6564 if (device_detail) {
6565 _has_bits_[0] |= 0x00000008u;
6566 } else {
6567 _has_bits_[0] &= ~0x00000008u;
6568 }
6569 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.TensorProto.device_detail)
6570}
6571inline ::caffe2::DeviceOption* TensorProto::release_device_detail() {
6572 _has_bits_[0] &= ~0x00000008u;
6573 ::caffe2::DeviceOption* temp = device_detail_;
6574 device_detail_ = nullptr;
6575 if (GetArena() != nullptr) {
6576 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6577 }
6578 return temp;
6579}
6580inline ::caffe2::DeviceOption* TensorProto::unsafe_arena_release_device_detail() {
6581 // @@protoc_insertion_point(field_release:caffe2.TensorProto.device_detail)
6582 _has_bits_[0] &= ~0x00000008u;
6583 ::caffe2::DeviceOption* temp = device_detail_;
6584 device_detail_ = nullptr;
6585 return temp;
6586}
6587inline ::caffe2::DeviceOption* TensorProto::_internal_mutable_device_detail() {
6588 _has_bits_[0] |= 0x00000008u;
6589 if (device_detail_ == nullptr) {
6590 auto* p = CreateMaybeMessage<::caffe2::DeviceOption>(GetArena());
6591 device_detail_ = p;
6592 }
6593 return device_detail_;
6594}
6595inline ::caffe2::DeviceOption* TensorProto::mutable_device_detail() {
6596 // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.device_detail)
6597 return _internal_mutable_device_detail();
6598}
6599inline void TensorProto::set_allocated_device_detail(::caffe2::DeviceOption* device_detail) {
6600 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
6601 if (message_arena == nullptr) {
6602 delete device_detail_;
6603 }
6604 if (device_detail) {
6605 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6606 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(device_detail);
6607 if (message_arena != submessage_arena) {
6608 device_detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6609 message_arena, device_detail, submessage_arena);
6610 }
6611 _has_bits_[0] |= 0x00000008u;
6612 } else {
6613 _has_bits_[0] &= ~0x00000008u;
6614 }
6615 device_detail_ = device_detail;
6616 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.device_detail)
6617}
6618
6619// optional .caffe2.TensorProto.Segment segment = 11;
6620inline bool TensorProto::_internal_has_segment() const {
6621 bool value = (_has_bits_[0] & 0x00000010u) != 0;
6622 PROTOBUF_ASSUME(!value || segment_ != nullptr);
6623 return value;
6624}
6625inline bool TensorProto::has_segment() const {
6626 return _internal_has_segment();
6627}
6628inline void TensorProto::clear_segment() {
6629 if (segment_ != nullptr) segment_->Clear();
6630 _has_bits_[0] &= ~0x00000010u;
6631}
6632inline const ::caffe2::TensorProto_Segment& TensorProto::_internal_segment() const {
6633 const ::caffe2::TensorProto_Segment* p = segment_;
6634 return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::TensorProto_Segment*>(
6635 &::caffe2::_TensorProto_Segment_default_instance_);
6636}
6637inline const ::caffe2::TensorProto_Segment& TensorProto::segment() const {
6638 // @@protoc_insertion_point(field_get:caffe2.TensorProto.segment)
6639 return _internal_segment();
6640}
6641inline void TensorProto::unsafe_arena_set_allocated_segment(
6642 ::caffe2::TensorProto_Segment* segment) {
6643 if (GetArena() == nullptr) {
6644 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(segment_);
6645 }
6646 segment_ = segment;
6647 if (segment) {
6648 _has_bits_[0] |= 0x00000010u;
6649 } else {
6650 _has_bits_[0] &= ~0x00000010u;
6651 }
6652 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.TensorProto.segment)
6653}
6654inline ::caffe2::TensorProto_Segment* TensorProto::release_segment() {
6655 _has_bits_[0] &= ~0x00000010u;
6656 ::caffe2::TensorProto_Segment* temp = segment_;
6657 segment_ = nullptr;
6658 if (GetArena() != nullptr) {
6659 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6660 }
6661 return temp;
6662}
6663inline ::caffe2::TensorProto_Segment* TensorProto::unsafe_arena_release_segment() {
6664 // @@protoc_insertion_point(field_release:caffe2.TensorProto.segment)
6665 _has_bits_[0] &= ~0x00000010u;
6666 ::caffe2::TensorProto_Segment* temp = segment_;
6667 segment_ = nullptr;
6668 return temp;
6669}
6670inline ::caffe2::TensorProto_Segment* TensorProto::_internal_mutable_segment() {
6671 _has_bits_[0] |= 0x00000010u;
6672 if (segment_ == nullptr) {
6673 auto* p = CreateMaybeMessage<::caffe2::TensorProto_Segment>(GetArena());
6674 segment_ = p;
6675 }
6676 return segment_;
6677}
6678inline ::caffe2::TensorProto_Segment* TensorProto::mutable_segment() {
6679 // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.segment)
6680 return _internal_mutable_segment();
6681}
6682inline void TensorProto::set_allocated_segment(::caffe2::TensorProto_Segment* segment) {
6683 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
6684 if (message_arena == nullptr) {
6685 delete segment_;
6686 }
6687 if (segment) {
6688 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6689 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(segment);
6690 if (message_arena != submessage_arena) {
6691 segment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6692 message_arena, segment, submessage_arena);
6693 }
6694 _has_bits_[0] |= 0x00000010u;
6695 } else {
6696 _has_bits_[0] &= ~0x00000010u;
6697 }
6698 segment_ = segment;
6699 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.segment)
6700}
6701
6702// -------------------------------------------------------------------
6703
6704// QTensorProto
6705
6706// repeated int64 dims = 1;
6707inline int QTensorProto::_internal_dims_size() const {
6708 return dims_.size();
6709}
6710inline int QTensorProto::dims_size() const {
6711 return _internal_dims_size();
6712}
6713inline void QTensorProto::clear_dims() {
6714 dims_.Clear();
6715}
6716inline ::PROTOBUF_NAMESPACE_ID::int64 QTensorProto::_internal_dims(int index) const {
6717 return dims_.Get(index);
6718}
6719inline ::PROTOBUF_NAMESPACE_ID::int64 QTensorProto::dims(int index) const {
6720 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.dims)
6721 return _internal_dims(index);
6722}
6723inline void QTensorProto::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
6724 dims_.Set(index, value);
6725 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.dims)
6726}
6727inline void QTensorProto::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
6728 dims_.Add(value);
6729}
6730inline void QTensorProto::add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
6731 _internal_add_dims(value);
6732 // @@protoc_insertion_point(field_add:caffe2.QTensorProto.dims)
6733}
6734inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
6735QTensorProto::_internal_dims() const {
6736 return dims_;
6737}
6738inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
6739QTensorProto::dims() const {
6740 // @@protoc_insertion_point(field_list:caffe2.QTensorProto.dims)
6741 return _internal_dims();
6742}
6743inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
6744QTensorProto::_internal_mutable_dims() {
6745 return &dims_;
6746}
6747inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
6748QTensorProto::mutable_dims() {
6749 // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.dims)
6750 return _internal_mutable_dims();
6751}
6752
6753// required int32 precision = 2;
6754inline bool QTensorProto::_internal_has_precision() const {
6755 bool value = (_has_bits_[0] & 0x00000008u) != 0;
6756 return value;
6757}
6758inline bool QTensorProto::has_precision() const {
6759 return _internal_has_precision();
6760}
6761inline void QTensorProto::clear_precision() {
6762 precision_ = 0;
6763 _has_bits_[0] &= ~0x00000008u;
6764}
6765inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::_internal_precision() const {
6766 return precision_;
6767}
6768inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::precision() const {
6769 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.precision)
6770 return _internal_precision();
6771}
6772inline void QTensorProto::_internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) {
6773 _has_bits_[0] |= 0x00000008u;
6774 precision_ = value;
6775}
6776inline void QTensorProto::set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) {
6777 _internal_set_precision(value);
6778 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.precision)
6779}
6780
6781// required double scale = 3;
6782inline bool QTensorProto::_internal_has_scale() const {
6783 bool value = (_has_bits_[0] & 0x00000002u) != 0;
6784 return value;
6785}
6786inline bool QTensorProto::has_scale() const {
6787 return _internal_has_scale();
6788}
6789inline void QTensorProto::clear_scale() {
6790 scale_ = 0;
6791 _has_bits_[0] &= ~0x00000002u;
6792}
6793inline double QTensorProto::_internal_scale() const {
6794 return scale_;
6795}
6796inline double QTensorProto::scale() const {
6797 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.scale)
6798 return _internal_scale();
6799}
6800inline void QTensorProto::_internal_set_scale(double value) {
6801 _has_bits_[0] |= 0x00000002u;
6802 scale_ = value;
6803}
6804inline void QTensorProto::set_scale(double value) {
6805 _internal_set_scale(value);
6806 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.scale)
6807}
6808
6809// required double bias = 4;
6810inline bool QTensorProto::_internal_has_bias() const {
6811 bool value = (_has_bits_[0] & 0x00000004u) != 0;
6812 return value;
6813}
6814inline bool QTensorProto::has_bias() const {
6815 return _internal_has_bias();
6816}
6817inline void QTensorProto::clear_bias() {
6818 bias_ = 0;
6819 _has_bits_[0] &= ~0x00000004u;
6820}
6821inline double QTensorProto::_internal_bias() const {
6822 return bias_;
6823}
6824inline double QTensorProto::bias() const {
6825 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.bias)
6826 return _internal_bias();
6827}
6828inline void QTensorProto::_internal_set_bias(double value) {
6829 _has_bits_[0] |= 0x00000004u;
6830 bias_ = value;
6831}
6832inline void QTensorProto::set_bias(double value) {
6833 _internal_set_bias(value);
6834 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.bias)
6835}
6836
6837// required bool is_signed = 5;
6838inline bool QTensorProto::_internal_has_is_signed() const {
6839 bool value = (_has_bits_[0] & 0x00000010u) != 0;
6840 return value;
6841}
6842inline bool QTensorProto::has_is_signed() const {
6843 return _internal_has_is_signed();
6844}
6845inline void QTensorProto::clear_is_signed() {
6846 is_signed_ = false;
6847 _has_bits_[0] &= ~0x00000010u;
6848}
6849inline bool QTensorProto::_internal_is_signed() const {
6850 return is_signed_;
6851}
6852inline bool QTensorProto::is_signed() const {
6853 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.is_signed)
6854 return _internal_is_signed();
6855}
6856inline void QTensorProto::_internal_set_is_signed(bool value) {
6857 _has_bits_[0] |= 0x00000010u;
6858 is_signed_ = value;
6859}
6860inline void QTensorProto::set_is_signed(bool value) {
6861 _internal_set_is_signed(value);
6862 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.is_signed)
6863}
6864
6865// repeated int32 data = 6 [packed = true];
6866inline int QTensorProto::_internal_data_size() const {
6867 return data_.size();
6868}
6869inline int QTensorProto::data_size() const {
6870 return _internal_data_size();
6871}
6872inline void QTensorProto::clear_data() {
6873 data_.Clear();
6874}
6875inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::_internal_data(int index) const {
6876 return data_.Get(index);
6877}
6878inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::data(int index) const {
6879 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.data)
6880 return _internal_data(index);
6881}
6882inline void QTensorProto::set_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
6883 data_.Set(index, value);
6884 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.data)
6885}
6886inline void QTensorProto::_internal_add_data(::PROTOBUF_NAMESPACE_ID::int32 value) {
6887 data_.Add(value);
6888}
6889inline void QTensorProto::add_data(::PROTOBUF_NAMESPACE_ID::int32 value) {
6890 _internal_add_data(value);
6891 // @@protoc_insertion_point(field_add:caffe2.QTensorProto.data)
6892}
6893inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
6894QTensorProto::_internal_data() const {
6895 return data_;
6896}
6897inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
6898QTensorProto::data() const {
6899 // @@protoc_insertion_point(field_list:caffe2.QTensorProto.data)
6900 return _internal_data();
6901}
6902inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
6903QTensorProto::_internal_mutable_data() {
6904 return &data_;
6905}
6906inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
6907QTensorProto::mutable_data() {
6908 // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.data)
6909 return _internal_mutable_data();
6910}
6911
6912// optional string name = 7;
6913inline bool QTensorProto::_internal_has_name() const {
6914 bool value = (_has_bits_[0] & 0x00000001u) != 0;
6915 return value;
6916}
6917inline bool QTensorProto::has_name() const {
6918 return _internal_has_name();
6919}
6920inline void QTensorProto::clear_name() {
6921 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
6922 _has_bits_[0] &= ~0x00000001u;
6923}
6924inline const std::string& QTensorProto::name() const {
6925 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.name)
6926 return _internal_name();
6927}
6928inline void QTensorProto::set_name(const std::string& value) {
6929 _internal_set_name(value);
6930 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.name)
6931}
6932inline std::string* QTensorProto::mutable_name() {
6933 // @@protoc_insertion_point(field_mutable:caffe2.QTensorProto.name)
6934 return _internal_mutable_name();
6935}
6936inline const std::string& QTensorProto::_internal_name() const {
6937 return name_.Get();
6938}
6939inline void QTensorProto::_internal_set_name(const std::string& value) {
6940 _has_bits_[0] |= 0x00000001u;
6941 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
6942}
6943inline void QTensorProto::set_name(std::string&& value) {
6944 _has_bits_[0] |= 0x00000001u;
6945 name_.Set(
6946 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
6947 // @@protoc_insertion_point(field_set_rvalue:caffe2.QTensorProto.name)
6948}
6949inline void QTensorProto::set_name(const char* value) {
6950 GOOGLE_DCHECK(value != nullptr);
6951 _has_bits_[0] |= 0x00000001u;
6952 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
6953 GetArena());
6954 // @@protoc_insertion_point(field_set_char:caffe2.QTensorProto.name)
6955}
6956inline void QTensorProto::set_name(const char* value,
6957 size_t size) {
6958 _has_bits_[0] |= 0x00000001u;
6959 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
6960 reinterpret_cast<const char*>(value), size), GetArena());
6961 // @@protoc_insertion_point(field_set_pointer:caffe2.QTensorProto.name)
6962}
6963inline std::string* QTensorProto::_internal_mutable_name() {
6964 _has_bits_[0] |= 0x00000001u;
6965 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
6966}
6967inline std::string* QTensorProto::release_name() {
6968 // @@protoc_insertion_point(field_release:caffe2.QTensorProto.name)
6969 if (!_internal_has_name()) {
6970 return nullptr;
6971 }
6972 _has_bits_[0] &= ~0x00000001u;
6973 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
6974}
6975inline void QTensorProto::set_allocated_name(std::string* name) {
6976 if (name != nullptr) {
6977 _has_bits_[0] |= 0x00000001u;
6978 } else {
6979 _has_bits_[0] &= ~0x00000001u;
6980 }
6981 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
6982 GetArena());
6983 // @@protoc_insertion_point(field_set_allocated:caffe2.QTensorProto.name)
6984}
6985
6986// optional .caffe2.TensorProto.DataType data_type = 8 [default = INT32];
6987inline bool QTensorProto::_internal_has_data_type() const {
6988 bool value = (_has_bits_[0] & 0x00000080u) != 0;
6989 return value;
6990}
6991inline bool QTensorProto::has_data_type() const {
6992 return _internal_has_data_type();
6993}
6994inline void QTensorProto::clear_data_type() {
6995 data_type_ = 2;
6996 _has_bits_[0] &= ~0x00000080u;
6997}
6998inline ::caffe2::TensorProto_DataType QTensorProto::_internal_data_type() const {
6999 return static_cast< ::caffe2::TensorProto_DataType >(data_type_);
7000}
7001inline ::caffe2::TensorProto_DataType QTensorProto::data_type() const {
7002 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.data_type)
7003 return _internal_data_type();
7004}
7005inline void QTensorProto::_internal_set_data_type(::caffe2::TensorProto_DataType value) {
7006 assert(::caffe2::TensorProto_DataType_IsValid(value));
7007 _has_bits_[0] |= 0x00000080u;
7008 data_type_ = value;
7009}
7010inline void QTensorProto::set_data_type(::caffe2::TensorProto_DataType value) {
7011 _internal_set_data_type(value);
7012 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.data_type)
7013}
7014
7015// repeated double scales = 9;
7016inline int QTensorProto::_internal_scales_size() const {
7017 return scales_.size();
7018}
7019inline int QTensorProto::scales_size() const {
7020 return _internal_scales_size();
7021}
7022inline void QTensorProto::clear_scales() {
7023 scales_.Clear();
7024}
7025inline double QTensorProto::_internal_scales(int index) const {
7026 return scales_.Get(index);
7027}
7028inline double QTensorProto::scales(int index) const {
7029 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.scales)
7030 return _internal_scales(index);
7031}
7032inline void QTensorProto::set_scales(int index, double value) {
7033 scales_.Set(index, value);
7034 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.scales)
7035}
7036inline void QTensorProto::_internal_add_scales(double value) {
7037 scales_.Add(value);
7038}
7039inline void QTensorProto::add_scales(double value) {
7040 _internal_add_scales(value);
7041 // @@protoc_insertion_point(field_add:caffe2.QTensorProto.scales)
7042}
7043inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
7044QTensorProto::_internal_scales() const {
7045 return scales_;
7046}
7047inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
7048QTensorProto::scales() const {
7049 // @@protoc_insertion_point(field_list:caffe2.QTensorProto.scales)
7050 return _internal_scales();
7051}
7052inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
7053QTensorProto::_internal_mutable_scales() {
7054 return &scales_;
7055}
7056inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
7057QTensorProto::mutable_scales() {
7058 // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.scales)
7059 return _internal_mutable_scales();
7060}
7061
7062// repeated double biases = 10;
7063inline int QTensorProto::_internal_biases_size() const {
7064 return biases_.size();
7065}
7066inline int QTensorProto::biases_size() const {
7067 return _internal_biases_size();
7068}
7069inline void QTensorProto::clear_biases() {
7070 biases_.Clear();
7071}
7072inline double QTensorProto::_internal_biases(int index) const {
7073 return biases_.Get(index);
7074}
7075inline double QTensorProto::biases(int index) const {
7076 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.biases)
7077 return _internal_biases(index);
7078}
7079inline void QTensorProto::set_biases(int index, double value) {
7080 biases_.Set(index, value);
7081 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.biases)
7082}
7083inline void QTensorProto::_internal_add_biases(double value) {
7084 biases_.Add(value);
7085}
7086inline void QTensorProto::add_biases(double value) {
7087 _internal_add_biases(value);
7088 // @@protoc_insertion_point(field_add:caffe2.QTensorProto.biases)
7089}
7090inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
7091QTensorProto::_internal_biases() const {
7092 return biases_;
7093}
7094inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
7095QTensorProto::biases() const {
7096 // @@protoc_insertion_point(field_list:caffe2.QTensorProto.biases)
7097 return _internal_biases();
7098}
7099inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
7100QTensorProto::_internal_mutable_biases() {
7101 return &biases_;
7102}
7103inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
7104QTensorProto::mutable_biases() {
7105 // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.biases)
7106 return _internal_mutable_biases();
7107}
7108
7109// optional int32 axis = 11;
7110inline bool QTensorProto::_internal_has_axis() const {
7111 bool value = (_has_bits_[0] & 0x00000040u) != 0;
7112 return value;
7113}
7114inline bool QTensorProto::has_axis() const {
7115 return _internal_has_axis();
7116}
7117inline void QTensorProto::clear_axis() {
7118 axis_ = 0;
7119 _has_bits_[0] &= ~0x00000040u;
7120}
7121inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::_internal_axis() const {
7122 return axis_;
7123}
7124inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::axis() const {
7125 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.axis)
7126 return _internal_axis();
7127}
7128inline void QTensorProto::_internal_set_axis(::PROTOBUF_NAMESPACE_ID::int32 value) {
7129 _has_bits_[0] |= 0x00000040u;
7130 axis_ = value;
7131}
7132inline void QTensorProto::set_axis(::PROTOBUF_NAMESPACE_ID::int32 value) {
7133 _internal_set_axis(value);
7134 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.axis)
7135}
7136
7137// optional bool is_multiparam = 12 [default = false];
7138inline bool QTensorProto::_internal_has_is_multiparam() const {
7139 bool value = (_has_bits_[0] & 0x00000020u) != 0;
7140 return value;
7141}
7142inline bool QTensorProto::has_is_multiparam() const {
7143 return _internal_has_is_multiparam();
7144}
7145inline void QTensorProto::clear_is_multiparam() {
7146 is_multiparam_ = false;
7147 _has_bits_[0] &= ~0x00000020u;
7148}
7149inline bool QTensorProto::_internal_is_multiparam() const {
7150 return is_multiparam_;
7151}
7152inline bool QTensorProto::is_multiparam() const {
7153 // @@protoc_insertion_point(field_get:caffe2.QTensorProto.is_multiparam)
7154 return _internal_is_multiparam();
7155}
7156inline void QTensorProto::_internal_set_is_multiparam(bool value) {
7157 _has_bits_[0] |= 0x00000020u;
7158 is_multiparam_ = value;
7159}
7160inline void QTensorProto::set_is_multiparam(bool value) {
7161 _internal_set_is_multiparam(value);
7162 // @@protoc_insertion_point(field_set:caffe2.QTensorProto.is_multiparam)
7163}
7164
7165// -------------------------------------------------------------------
7166
7167// TensorProtos
7168
7169// repeated .caffe2.TensorProto protos = 1;
7170inline int TensorProtos::_internal_protos_size() const {
7171 return protos_.size();
7172}
7173inline int TensorProtos::protos_size() const {
7174 return _internal_protos_size();
7175}
7176inline void TensorProtos::clear_protos() {
7177 protos_.Clear();
7178}
7179inline ::caffe2::TensorProto* TensorProtos::mutable_protos(int index) {
7180 // @@protoc_insertion_point(field_mutable:caffe2.TensorProtos.protos)
7181 return protos_.Mutable(index);
7182}
7183inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >*
7184TensorProtos::mutable_protos() {
7185 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProtos.protos)
7186 return &protos_;
7187}
7188inline const ::caffe2::TensorProto& TensorProtos::_internal_protos(int index) const {
7189 return protos_.Get(index);
7190}
7191inline const ::caffe2::TensorProto& TensorProtos::protos(int index) const {
7192 // @@protoc_insertion_point(field_get:caffe2.TensorProtos.protos)
7193 return _internal_protos(index);
7194}
7195inline ::caffe2::TensorProto* TensorProtos::_internal_add_protos() {
7196 return protos_.Add();
7197}
7198inline ::caffe2::TensorProto* TensorProtos::add_protos() {
7199 // @@protoc_insertion_point(field_add:caffe2.TensorProtos.protos)
7200 return _internal_add_protos();
7201}
7202inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >&
7203TensorProtos::protos() const {
7204 // @@protoc_insertion_point(field_list:caffe2.TensorProtos.protos)
7205 return protos_;
7206}
7207
7208// -------------------------------------------------------------------
7209
7210// TensorShape
7211
7212// repeated int64 dims = 1;
7213inline int TensorShape::_internal_dims_size() const {
7214 return dims_.size();
7215}
7216inline int TensorShape::dims_size() const {
7217 return _internal_dims_size();
7218}
7219inline void TensorShape::clear_dims() {
7220 dims_.Clear();
7221}
7222inline ::PROTOBUF_NAMESPACE_ID::int64 TensorShape::_internal_dims(int index) const {
7223 return dims_.Get(index);
7224}
7225inline ::PROTOBUF_NAMESPACE_ID::int64 TensorShape::dims(int index) const {
7226 // @@protoc_insertion_point(field_get:caffe2.TensorShape.dims)
7227 return _internal_dims(index);
7228}
7229inline void TensorShape::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
7230 dims_.Set(index, value);
7231 // @@protoc_insertion_point(field_set:caffe2.TensorShape.dims)
7232}
7233inline void TensorShape::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
7234 dims_.Add(value);
7235}
7236inline void TensorShape::add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
7237 _internal_add_dims(value);
7238 // @@protoc_insertion_point(field_add:caffe2.TensorShape.dims)
7239}
7240inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
7241TensorShape::_internal_dims() const {
7242 return dims_;
7243}
7244inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
7245TensorShape::dims() const {
7246 // @@protoc_insertion_point(field_list:caffe2.TensorShape.dims)
7247 return _internal_dims();
7248}
7249inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
7250TensorShape::_internal_mutable_dims() {
7251 return &dims_;
7252}
7253inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
7254TensorShape::mutable_dims() {
7255 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorShape.dims)
7256 return _internal_mutable_dims();
7257}
7258
7259// optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT];
7260inline bool TensorShape::_internal_has_data_type() const {
7261 bool value = (_has_bits_[0] & 0x00000004u) != 0;
7262 return value;
7263}
7264inline bool TensorShape::has_data_type() const {
7265 return _internal_has_data_type();
7266}
7267inline void TensorShape::clear_data_type() {
7268 data_type_ = 1;
7269 _has_bits_[0] &= ~0x00000004u;
7270}
7271inline ::caffe2::TensorProto_DataType TensorShape::_internal_data_type() const {
7272 return static_cast< ::caffe2::TensorProto_DataType >(data_type_);
7273}
7274inline ::caffe2::TensorProto_DataType TensorShape::data_type() const {
7275 // @@protoc_insertion_point(field_get:caffe2.TensorShape.data_type)
7276 return _internal_data_type();
7277}
7278inline void TensorShape::_internal_set_data_type(::caffe2::TensorProto_DataType value) {
7279 assert(::caffe2::TensorProto_DataType_IsValid(value));
7280 _has_bits_[0] |= 0x00000004u;
7281 data_type_ = value;
7282}
7283inline void TensorShape::set_data_type(::caffe2::TensorProto_DataType value) {
7284 _internal_set_data_type(value);
7285 // @@protoc_insertion_point(field_set:caffe2.TensorShape.data_type)
7286}
7287
7288// repeated int32 unknown_dims = 3;
7289inline int TensorShape::_internal_unknown_dims_size() const {
7290 return unknown_dims_.size();
7291}
7292inline int TensorShape::unknown_dims_size() const {
7293 return _internal_unknown_dims_size();
7294}
7295inline void TensorShape::clear_unknown_dims() {
7296 unknown_dims_.Clear();
7297}
7298inline ::PROTOBUF_NAMESPACE_ID::int32 TensorShape::_internal_unknown_dims(int index) const {
7299 return unknown_dims_.Get(index);
7300}
7301inline ::PROTOBUF_NAMESPACE_ID::int32 TensorShape::unknown_dims(int index) const {
7302 // @@protoc_insertion_point(field_get:caffe2.TensorShape.unknown_dims)
7303 return _internal_unknown_dims(index);
7304}
7305inline void TensorShape::set_unknown_dims(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
7306 unknown_dims_.Set(index, value);
7307 // @@protoc_insertion_point(field_set:caffe2.TensorShape.unknown_dims)
7308}
7309inline void TensorShape::_internal_add_unknown_dims(::PROTOBUF_NAMESPACE_ID::int32 value) {
7310 unknown_dims_.Add(value);
7311}
7312inline void TensorShape::add_unknown_dims(::PROTOBUF_NAMESPACE_ID::int32 value) {
7313 _internal_add_unknown_dims(value);
7314 // @@protoc_insertion_point(field_add:caffe2.TensorShape.unknown_dims)
7315}
7316inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
7317TensorShape::_internal_unknown_dims() const {
7318 return unknown_dims_;
7319}
7320inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
7321TensorShape::unknown_dims() const {
7322 // @@protoc_insertion_point(field_list:caffe2.TensorShape.unknown_dims)
7323 return _internal_unknown_dims();
7324}
7325inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
7326TensorShape::_internal_mutable_unknown_dims() {
7327 return &unknown_dims_;
7328}
7329inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
7330TensorShape::mutable_unknown_dims() {
7331 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorShape.unknown_dims)
7332 return _internal_mutable_unknown_dims();
7333}
7334
7335// optional bool unknown_shape = 4 [default = false];
7336inline bool TensorShape::_internal_has_unknown_shape() const {
7337 bool value = (_has_bits_[0] & 0x00000002u) != 0;
7338 return value;
7339}
7340inline bool TensorShape::has_unknown_shape() const {
7341 return _internal_has_unknown_shape();
7342}
7343inline void TensorShape::clear_unknown_shape() {
7344 unknown_shape_ = false;
7345 _has_bits_[0] &= ~0x00000002u;
7346}
7347inline bool TensorShape::_internal_unknown_shape() const {
7348 return unknown_shape_;
7349}
7350inline bool TensorShape::unknown_shape() const {
7351 // @@protoc_insertion_point(field_get:caffe2.TensorShape.unknown_shape)
7352 return _internal_unknown_shape();
7353}
7354inline void TensorShape::_internal_set_unknown_shape(bool value) {
7355 _has_bits_[0] |= 0x00000002u;
7356 unknown_shape_ = value;
7357}
7358inline void TensorShape::set_unknown_shape(bool value) {
7359 _internal_set_unknown_shape(value);
7360 // @@protoc_insertion_point(field_set:caffe2.TensorShape.unknown_shape)
7361}
7362
7363// optional string name = 5;
7364inline bool TensorShape::_internal_has_name() const {
7365 bool value = (_has_bits_[0] & 0x00000001u) != 0;
7366 return value;
7367}
7368inline bool TensorShape::has_name() const {
7369 return _internal_has_name();
7370}
7371inline void TensorShape::clear_name() {
7372 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
7373 _has_bits_[0] &= ~0x00000001u;
7374}
7375inline const std::string& TensorShape::name() const {
7376 // @@protoc_insertion_point(field_get:caffe2.TensorShape.name)
7377 return _internal_name();
7378}
7379inline void TensorShape::set_name(const std::string& value) {
7380 _internal_set_name(value);
7381 // @@protoc_insertion_point(field_set:caffe2.TensorShape.name)
7382}
7383inline std::string* TensorShape::mutable_name() {
7384 // @@protoc_insertion_point(field_mutable:caffe2.TensorShape.name)
7385 return _internal_mutable_name();
7386}
7387inline const std::string& TensorShape::_internal_name() const {
7388 return name_.Get();
7389}
7390inline void TensorShape::_internal_set_name(const std::string& value) {
7391 _has_bits_[0] |= 0x00000001u;
7392 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
7393}
7394inline void TensorShape::set_name(std::string&& value) {
7395 _has_bits_[0] |= 0x00000001u;
7396 name_.Set(
7397 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
7398 // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorShape.name)
7399}
7400inline void TensorShape::set_name(const char* value) {
7401 GOOGLE_DCHECK(value != nullptr);
7402 _has_bits_[0] |= 0x00000001u;
7403 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
7404 GetArena());
7405 // @@protoc_insertion_point(field_set_char:caffe2.TensorShape.name)
7406}
7407inline void TensorShape::set_name(const char* value,
7408 size_t size) {
7409 _has_bits_[0] |= 0x00000001u;
7410 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
7411 reinterpret_cast<const char*>(value), size), GetArena());
7412 // @@protoc_insertion_point(field_set_pointer:caffe2.TensorShape.name)
7413}
7414inline std::string* TensorShape::_internal_mutable_name() {
7415 _has_bits_[0] |= 0x00000001u;
7416 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
7417}
7418inline std::string* TensorShape::release_name() {
7419 // @@protoc_insertion_point(field_release:caffe2.TensorShape.name)
7420 if (!_internal_has_name()) {
7421 return nullptr;
7422 }
7423 _has_bits_[0] &= ~0x00000001u;
7424 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
7425}
7426inline void TensorShape::set_allocated_name(std::string* name) {
7427 if (name != nullptr) {
7428 _has_bits_[0] |= 0x00000001u;
7429 } else {
7430 _has_bits_[0] &= ~0x00000001u;
7431 }
7432 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
7433 GetArena());
7434 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorShape.name)
7435}
7436
7437// -------------------------------------------------------------------
7438
7439// TensorShapes
7440
7441// repeated .caffe2.TensorShape shapes = 1;
7442inline int TensorShapes::_internal_shapes_size() const {
7443 return shapes_.size();
7444}
7445inline int TensorShapes::shapes_size() const {
7446 return _internal_shapes_size();
7447}
7448inline void TensorShapes::clear_shapes() {
7449 shapes_.Clear();
7450}
7451inline ::caffe2::TensorShape* TensorShapes::mutable_shapes(int index) {
7452 // @@protoc_insertion_point(field_mutable:caffe2.TensorShapes.shapes)
7453 return shapes_.Mutable(index);
7454}
7455inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape >*
7456TensorShapes::mutable_shapes() {
7457 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorShapes.shapes)
7458 return &shapes_;
7459}
7460inline const ::caffe2::TensorShape& TensorShapes::_internal_shapes(int index) const {
7461 return shapes_.Get(index);
7462}
7463inline const ::caffe2::TensorShape& TensorShapes::shapes(int index) const {
7464 // @@protoc_insertion_point(field_get:caffe2.TensorShapes.shapes)
7465 return _internal_shapes(index);
7466}
7467inline ::caffe2::TensorShape* TensorShapes::_internal_add_shapes() {
7468 return shapes_.Add();
7469}
7470inline ::caffe2::TensorShape* TensorShapes::add_shapes() {
7471 // @@protoc_insertion_point(field_add:caffe2.TensorShapes.shapes)
7472 return _internal_add_shapes();
7473}
7474inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape >&
7475TensorShapes::shapes() const {
7476 // @@protoc_insertion_point(field_list:caffe2.TensorShapes.shapes)
7477 return shapes_;
7478}
7479
7480// -------------------------------------------------------------------
7481
7482// TensorBoundShape
7483
7484// optional .caffe2.TensorShape shape = 1;
7485inline bool TensorBoundShape::_internal_has_shape() const {
7486 bool value = (_has_bits_[0] & 0x00000002u) != 0;
7487 PROTOBUF_ASSUME(!value || shape_ != nullptr);
7488 return value;
7489}
7490inline bool TensorBoundShape::has_shape() const {
7491 return _internal_has_shape();
7492}
7493inline void TensorBoundShape::clear_shape() {
7494 if (shape_ != nullptr) shape_->Clear();
7495 _has_bits_[0] &= ~0x00000002u;
7496}
7497inline const ::caffe2::TensorShape& TensorBoundShape::_internal_shape() const {
7498 const ::caffe2::TensorShape* p = shape_;
7499 return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::TensorShape*>(
7500 &::caffe2::_TensorShape_default_instance_);
7501}
7502inline const ::caffe2::TensorShape& TensorBoundShape::shape() const {
7503 // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.shape)
7504 return _internal_shape();
7505}
7506inline void TensorBoundShape::unsafe_arena_set_allocated_shape(
7507 ::caffe2::TensorShape* shape) {
7508 if (GetArena() == nullptr) {
7509 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
7510 }
7511 shape_ = shape;
7512 if (shape) {
7513 _has_bits_[0] |= 0x00000002u;
7514 } else {
7515 _has_bits_[0] &= ~0x00000002u;
7516 }
7517 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.TensorBoundShape.shape)
7518}
7519inline ::caffe2::TensorShape* TensorBoundShape::release_shape() {
7520 _has_bits_[0] &= ~0x00000002u;
7521 ::caffe2::TensorShape* temp = shape_;
7522 shape_ = nullptr;
7523 if (GetArena() != nullptr) {
7524 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7525 }
7526 return temp;
7527}
7528inline ::caffe2::TensorShape* TensorBoundShape::unsafe_arena_release_shape() {
7529 // @@protoc_insertion_point(field_release:caffe2.TensorBoundShape.shape)
7530 _has_bits_[0] &= ~0x00000002u;
7531 ::caffe2::TensorShape* temp = shape_;
7532 shape_ = nullptr;
7533 return temp;
7534}
7535inline ::caffe2::TensorShape* TensorBoundShape::_internal_mutable_shape() {
7536 _has_bits_[0] |= 0x00000002u;
7537 if (shape_ == nullptr) {
7538 auto* p = CreateMaybeMessage<::caffe2::TensorShape>(GetArena());
7539 shape_ = p;
7540 }
7541 return shape_;
7542}
7543inline ::caffe2::TensorShape* TensorBoundShape::mutable_shape() {
7544 // @@protoc_insertion_point(field_mutable:caffe2.TensorBoundShape.shape)
7545 return _internal_mutable_shape();
7546}
7547inline void TensorBoundShape::set_allocated_shape(::caffe2::TensorShape* shape) {
7548 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
7549 if (message_arena == nullptr) {
7550 delete shape_;
7551 }
7552 if (shape) {
7553 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
7554 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(shape);
7555 if (message_arena != submessage_arena) {
7556 shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
7557 message_arena, shape, submessage_arena);
7558 }
7559 _has_bits_[0] |= 0x00000002u;
7560 } else {
7561 _has_bits_[0] &= ~0x00000002u;
7562 }
7563 shape_ = shape;
7564 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorBoundShape.shape)
7565}
7566
7567// repeated .caffe2.TensorBoundShape.DimType dim_type = 2;
7568inline int TensorBoundShape::_internal_dim_type_size() const {
7569 return dim_type_.size();
7570}
7571inline int TensorBoundShape::dim_type_size() const {
7572 return _internal_dim_type_size();
7573}
7574inline void TensorBoundShape::clear_dim_type() {
7575 dim_type_.Clear();
7576}
7577inline ::caffe2::TensorBoundShape_DimType TensorBoundShape::_internal_dim_type(int index) const {
7578 return static_cast< ::caffe2::TensorBoundShape_DimType >(dim_type_.Get(index));
7579}
7580inline ::caffe2::TensorBoundShape_DimType TensorBoundShape::dim_type(int index) const {
7581 // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.dim_type)
7582 return _internal_dim_type(index);
7583}
7584inline void TensorBoundShape::set_dim_type(int index, ::caffe2::TensorBoundShape_DimType value) {
7585 assert(::caffe2::TensorBoundShape_DimType_IsValid(value));
7586 dim_type_.Set(index, value);
7587 // @@protoc_insertion_point(field_set:caffe2.TensorBoundShape.dim_type)
7588}
7589inline void TensorBoundShape::_internal_add_dim_type(::caffe2::TensorBoundShape_DimType value) {
7590 assert(::caffe2::TensorBoundShape_DimType_IsValid(value));
7591 dim_type_.Add(value);
7592}
7593inline void TensorBoundShape::add_dim_type(::caffe2::TensorBoundShape_DimType value) {
7594 // @@protoc_insertion_point(field_add:caffe2.TensorBoundShape.dim_type)
7595 _internal_add_dim_type(value);
7596}
7597inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
7598TensorBoundShape::dim_type() const {
7599 // @@protoc_insertion_point(field_list:caffe2.TensorBoundShape.dim_type)
7600 return dim_type_;
7601}
7602inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
7603TensorBoundShape::_internal_mutable_dim_type() {
7604 return &dim_type_;
7605}
7606inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
7607TensorBoundShape::mutable_dim_type() {
7608 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorBoundShape.dim_type)
7609 return _internal_mutable_dim_type();
7610}
7611
7612// optional string name = 3;
7613inline bool TensorBoundShape::_internal_has_name() const {
7614 bool value = (_has_bits_[0] & 0x00000001u) != 0;
7615 return value;
7616}
7617inline bool TensorBoundShape::has_name() const {
7618 return _internal_has_name();
7619}
7620inline void TensorBoundShape::clear_name() {
7621 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
7622 _has_bits_[0] &= ~0x00000001u;
7623}
7624inline const std::string& TensorBoundShape::name() const {
7625 // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.name)
7626 return _internal_name();
7627}
7628inline void TensorBoundShape::set_name(const std::string& value) {
7629 _internal_set_name(value);
7630 // @@protoc_insertion_point(field_set:caffe2.TensorBoundShape.name)
7631}
7632inline std::string* TensorBoundShape::mutable_name() {
7633 // @@protoc_insertion_point(field_mutable:caffe2.TensorBoundShape.name)
7634 return _internal_mutable_name();
7635}
7636inline const std::string& TensorBoundShape::_internal_name() const {
7637 return name_.Get();
7638}
7639inline void TensorBoundShape::_internal_set_name(const std::string& value) {
7640 _has_bits_[0] |= 0x00000001u;
7641 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
7642}
7643inline void TensorBoundShape::set_name(std::string&& value) {
7644 _has_bits_[0] |= 0x00000001u;
7645 name_.Set(
7646 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
7647 // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorBoundShape.name)
7648}
7649inline void TensorBoundShape::set_name(const char* value) {
7650 GOOGLE_DCHECK(value != nullptr);
7651 _has_bits_[0] |= 0x00000001u;
7652 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
7653 GetArena());
7654 // @@protoc_insertion_point(field_set_char:caffe2.TensorBoundShape.name)
7655}
7656inline void TensorBoundShape::set_name(const char* value,
7657 size_t size) {
7658 _has_bits_[0] |= 0x00000001u;
7659 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
7660 reinterpret_cast<const char*>(value), size), GetArena());
7661 // @@protoc_insertion_point(field_set_pointer:caffe2.TensorBoundShape.name)
7662}
7663inline std::string* TensorBoundShape::_internal_mutable_name() {
7664 _has_bits_[0] |= 0x00000001u;
7665 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
7666}
7667inline std::string* TensorBoundShape::release_name() {
7668 // @@protoc_insertion_point(field_release:caffe2.TensorBoundShape.name)
7669 if (!_internal_has_name()) {
7670 return nullptr;
7671 }
7672 _has_bits_[0] &= ~0x00000001u;
7673 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
7674}
7675inline void TensorBoundShape::set_allocated_name(std::string* name) {
7676 if (name != nullptr) {
7677 _has_bits_[0] |= 0x00000001u;
7678 } else {
7679 _has_bits_[0] &= ~0x00000001u;
7680 }
7681 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
7682 GetArena());
7683 // @@protoc_insertion_point(field_set_allocated:caffe2.TensorBoundShape.name)
7684}
7685
7686// optional bool shape_is_final = 4;
7687inline bool TensorBoundShape::_internal_has_shape_is_final() const {
7688 bool value = (_has_bits_[0] & 0x00000004u) != 0;
7689 return value;
7690}
7691inline bool TensorBoundShape::has_shape_is_final() const {
7692 return _internal_has_shape_is_final();
7693}
7694inline void TensorBoundShape::clear_shape_is_final() {
7695 shape_is_final_ = false;
7696 _has_bits_[0] &= ~0x00000004u;
7697}
7698inline bool TensorBoundShape::_internal_shape_is_final() const {
7699 return shape_is_final_;
7700}
7701inline bool TensorBoundShape::shape_is_final() const {
7702 // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.shape_is_final)
7703 return _internal_shape_is_final();
7704}
7705inline void TensorBoundShape::_internal_set_shape_is_final(bool value) {
7706 _has_bits_[0] |= 0x00000004u;
7707 shape_is_final_ = value;
7708}
7709inline void TensorBoundShape::set_shape_is_final(bool value) {
7710 _internal_set_shape_is_final(value);
7711 // @@protoc_insertion_point(field_set:caffe2.TensorBoundShape.shape_is_final)
7712}
7713
7714// -------------------------------------------------------------------
7715
7716// TensorBoundShapes
7717
7718// repeated .caffe2.TensorBoundShape shapes = 1;
7719inline int TensorBoundShapes::_internal_shapes_size() const {
7720 return shapes_.size();
7721}
7722inline int TensorBoundShapes::shapes_size() const {
7723 return _internal_shapes_size();
7724}
7725inline void TensorBoundShapes::clear_shapes() {
7726 shapes_.Clear();
7727}
7728inline ::caffe2::TensorBoundShape* TensorBoundShapes::mutable_shapes(int index) {
7729 // @@protoc_insertion_point(field_mutable:caffe2.TensorBoundShapes.shapes)
7730 return shapes_.Mutable(index);
7731}
7732inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape >*
7733TensorBoundShapes::mutable_shapes() {
7734 // @@protoc_insertion_point(field_mutable_list:caffe2.TensorBoundShapes.shapes)
7735 return &shapes_;
7736}
7737inline const ::caffe2::TensorBoundShape& TensorBoundShapes::_internal_shapes(int index) const {
7738 return shapes_.Get(index);
7739}
7740inline const ::caffe2::TensorBoundShape& TensorBoundShapes::shapes(int index) const {
7741 // @@protoc_insertion_point(field_get:caffe2.TensorBoundShapes.shapes)
7742 return _internal_shapes(index);
7743}
7744inline ::caffe2::TensorBoundShape* TensorBoundShapes::_internal_add_shapes() {
7745 return shapes_.Add();
7746}
7747inline ::caffe2::TensorBoundShape* TensorBoundShapes::add_shapes() {
7748 // @@protoc_insertion_point(field_add:caffe2.TensorBoundShapes.shapes)
7749 return _internal_add_shapes();
7750}
7751inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape >&
7752TensorBoundShapes::shapes() const {
7753 // @@protoc_insertion_point(field_list:caffe2.TensorBoundShapes.shapes)
7754 return shapes_;
7755}
7756
7757// optional int64 max_batch_size = 2;
7758inline bool TensorBoundShapes::_internal_has_max_batch_size() const {
7759 bool value = (_has_bits_[0] & 0x00000001u) != 0;
7760 return value;
7761}
7762inline bool TensorBoundShapes::has_max_batch_size() const {
7763 return _internal_has_max_batch_size();
7764}
7765inline void TensorBoundShapes::clear_max_batch_size() {
7766 max_batch_size_ = PROTOBUF_LONGLONG(0);
7767 _has_bits_[0] &= ~0x00000001u;
7768}
7769inline ::PROTOBUF_NAMESPACE_ID::int64 TensorBoundShapes::_internal_max_batch_size() const {
7770 return max_batch_size_;
7771}
7772inline ::PROTOBUF_NAMESPACE_ID::int64 TensorBoundShapes::max_batch_size() const {
7773 // @@protoc_insertion_point(field_get:caffe2.TensorBoundShapes.max_batch_size)
7774 return _internal_max_batch_size();
7775}
7776inline void TensorBoundShapes::_internal_set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
7777 _has_bits_[0] |= 0x00000001u;
7778 max_batch_size_ = value;
7779}
7780inline void TensorBoundShapes::set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
7781 _internal_set_max_batch_size(value);
7782 // @@protoc_insertion_point(field_set:caffe2.TensorBoundShapes.max_batch_size)
7783}
7784
7785// optional int64 max_feature_len = 3;
7786inline bool TensorBoundShapes::_internal_has_max_feature_len() const {
7787 bool value = (_has_bits_[0] & 0x00000002u) != 0;
7788 return value;
7789}
7790inline bool TensorBoundShapes::has_max_feature_len() const {
7791 return _internal_has_max_feature_len();
7792}
7793inline void TensorBoundShapes::clear_max_feature_len() {
7794 max_feature_len_ = PROTOBUF_LONGLONG(0);
7795 _has_bits_[0] &= ~0x00000002u;
7796}
7797inline ::PROTOBUF_NAMESPACE_ID::int64 TensorBoundShapes::_internal_max_feature_len() const {
7798 return max_feature_len_;
7799}
7800inline ::PROTOBUF_NAMESPACE_ID::int64 TensorBoundShapes::max_feature_len() const {
7801 // @@protoc_insertion_point(field_get:caffe2.TensorBoundShapes.max_feature_len)
7802 return _internal_max_feature_len();
7803}
7804inline void TensorBoundShapes::_internal_set_max_feature_len(::PROTOBUF_NAMESPACE_ID::int64 value) {
7805 _has_bits_[0] |= 0x00000002u;
7806 max_feature_len_ = value;
7807}
7808inline void TensorBoundShapes::set_max_feature_len(::PROTOBUF_NAMESPACE_ID::int64 value) {
7809 _internal_set_max_feature_len(value);
7810 // @@protoc_insertion_point(field_set:caffe2.TensorBoundShapes.max_feature_len)
7811}
7812
7813// -------------------------------------------------------------------
7814
7815// AOTConfig
7816
7817// required int64 max_batch_size = 1;
7818inline bool AOTConfig::_internal_has_max_batch_size() const {
7819 bool value = (_has_bits_[0] & 0x00000002u) != 0;
7820 return value;
7821}
7822inline bool AOTConfig::has_max_batch_size() const {
7823 return _internal_has_max_batch_size();
7824}
7825inline void AOTConfig::clear_max_batch_size() {
7826 max_batch_size_ = PROTOBUF_LONGLONG(0);
7827 _has_bits_[0] &= ~0x00000002u;
7828}
7829inline ::PROTOBUF_NAMESPACE_ID::int64 AOTConfig::_internal_max_batch_size() const {
7830 return max_batch_size_;
7831}
7832inline ::PROTOBUF_NAMESPACE_ID::int64 AOTConfig::max_batch_size() const {
7833 // @@protoc_insertion_point(field_get:caffe2.AOTConfig.max_batch_size)
7834 return _internal_max_batch_size();
7835}
7836inline void AOTConfig::_internal_set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
7837 _has_bits_[0] |= 0x00000002u;
7838 max_batch_size_ = value;
7839}
7840inline void AOTConfig::set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
7841 _internal_set_max_batch_size(value);
7842 // @@protoc_insertion_point(field_set:caffe2.AOTConfig.max_batch_size)
7843}
7844
7845// required int64 max_seq_size = 2;
7846inline bool AOTConfig::_internal_has_max_seq_size() const {
7847 bool value = (_has_bits_[0] & 0x00000004u) != 0;
7848 return value;
7849}
7850inline bool AOTConfig::has_max_seq_size() const {
7851 return _internal_has_max_seq_size();
7852}
7853inline void AOTConfig::clear_max_seq_size() {
7854 max_seq_size_ = PROTOBUF_LONGLONG(0);
7855 _has_bits_[0] &= ~0x00000004u;
7856}
7857inline ::PROTOBUF_NAMESPACE_ID::int64 AOTConfig::_internal_max_seq_size() const {
7858 return max_seq_size_;
7859}
7860inline ::PROTOBUF_NAMESPACE_ID::int64 AOTConfig::max_seq_size() const {
7861 // @@protoc_insertion_point(field_get:caffe2.AOTConfig.max_seq_size)
7862 return _internal_max_seq_size();
7863}
7864inline void AOTConfig::_internal_set_max_seq_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
7865 _has_bits_[0] |= 0x00000004u;
7866 max_seq_size_ = value;
7867}
7868inline void AOTConfig::set_max_seq_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
7869 _internal_set_max_seq_size(value);
7870 // @@protoc_insertion_point(field_set:caffe2.AOTConfig.max_seq_size)
7871}
7872
7873// required bool in_batch_broadcast = 3;
7874inline bool AOTConfig::_internal_has_in_batch_broadcast() const {
7875 bool value = (_has_bits_[0] & 0x00000008u) != 0;
7876 return value;
7877}
7878inline bool AOTConfig::has_in_batch_broadcast() const {
7879 return _internal_has_in_batch_broadcast();
7880}
7881inline void AOTConfig::clear_in_batch_broadcast() {
7882 in_batch_broadcast_ = false;
7883 _has_bits_[0] &= ~0x00000008u;
7884}
7885inline bool AOTConfig::_internal_in_batch_broadcast() const {
7886 return in_batch_broadcast_;
7887}
7888inline bool AOTConfig::in_batch_broadcast() const {
7889 // @@protoc_insertion_point(field_get:caffe2.AOTConfig.in_batch_broadcast)
7890 return _internal_in_batch_broadcast();
7891}
7892inline void AOTConfig::_internal_set_in_batch_broadcast(bool value) {
7893 _has_bits_[0] |= 0x00000008u;
7894 in_batch_broadcast_ = value;
7895}
7896inline void AOTConfig::set_in_batch_broadcast(bool value) {
7897 _internal_set_in_batch_broadcast(value);
7898 // @@protoc_insertion_point(field_set:caffe2.AOTConfig.in_batch_broadcast)
7899}
7900
7901// optional string onnxifi_blacklist_ops = 4;
7902inline bool AOTConfig::_internal_has_onnxifi_blacklist_ops() const {
7903 bool value = (_has_bits_[0] & 0x00000001u) != 0;
7904 return value;
7905}
7906inline bool AOTConfig::has_onnxifi_blacklist_ops() const {
7907 return _internal_has_onnxifi_blacklist_ops();
7908}
7909inline void AOTConfig::clear_onnxifi_blacklist_ops() {
7910 onnxifi_blacklist_ops_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
7911 _has_bits_[0] &= ~0x00000001u;
7912}
7913inline const std::string& AOTConfig::onnxifi_blacklist_ops() const {
7914 // @@protoc_insertion_point(field_get:caffe2.AOTConfig.onnxifi_blacklist_ops)
7915 return _internal_onnxifi_blacklist_ops();
7916}
7917inline void AOTConfig::set_onnxifi_blacklist_ops(const std::string& value) {
7918 _internal_set_onnxifi_blacklist_ops(value);
7919 // @@protoc_insertion_point(field_set:caffe2.AOTConfig.onnxifi_blacklist_ops)
7920}
7921inline std::string* AOTConfig::mutable_onnxifi_blacklist_ops() {
7922 // @@protoc_insertion_point(field_mutable:caffe2.AOTConfig.onnxifi_blacklist_ops)
7923 return _internal_mutable_onnxifi_blacklist_ops();
7924}
7925inline const std::string& AOTConfig::_internal_onnxifi_blacklist_ops() const {
7926 return onnxifi_blacklist_ops_.Get();
7927}
7928inline void AOTConfig::_internal_set_onnxifi_blacklist_ops(const std::string& value) {
7929 _has_bits_[0] |= 0x00000001u;
7930 onnxifi_blacklist_ops_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
7931}
7932inline void AOTConfig::set_onnxifi_blacklist_ops(std::string&& value) {
7933 _has_bits_[0] |= 0x00000001u;
7934 onnxifi_blacklist_ops_.Set(
7935 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
7936 // @@protoc_insertion_point(field_set_rvalue:caffe2.AOTConfig.onnxifi_blacklist_ops)
7937}
7938inline void AOTConfig::set_onnxifi_blacklist_ops(const char* value) {
7939 GOOGLE_DCHECK(value != nullptr);
7940 _has_bits_[0] |= 0x00000001u;
7941 onnxifi_blacklist_ops_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
7942 GetArena());
7943 // @@protoc_insertion_point(field_set_char:caffe2.AOTConfig.onnxifi_blacklist_ops)
7944}
7945inline void AOTConfig::set_onnxifi_blacklist_ops(const char* value,
7946 size_t size) {
7947 _has_bits_[0] |= 0x00000001u;
7948 onnxifi_blacklist_ops_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
7949 reinterpret_cast<const char*>(value), size), GetArena());
7950 // @@protoc_insertion_point(field_set_pointer:caffe2.AOTConfig.onnxifi_blacklist_ops)
7951}
7952inline std::string* AOTConfig::_internal_mutable_onnxifi_blacklist_ops() {
7953 _has_bits_[0] |= 0x00000001u;
7954 return onnxifi_blacklist_ops_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
7955}
7956inline std::string* AOTConfig::release_onnxifi_blacklist_ops() {
7957 // @@protoc_insertion_point(field_release:caffe2.AOTConfig.onnxifi_blacklist_ops)
7958 if (!_internal_has_onnxifi_blacklist_ops()) {
7959 return nullptr;
7960 }
7961 _has_bits_[0] &= ~0x00000001u;
7962 return onnxifi_blacklist_ops_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
7963}
7964inline void AOTConfig::set_allocated_onnxifi_blacklist_ops(std::string* onnxifi_blacklist_ops) {
7965 if (onnxifi_blacklist_ops != nullptr) {
7966 _has_bits_[0] |= 0x00000001u;
7967 } else {
7968 _has_bits_[0] &= ~0x00000001u;
7969 }
7970 onnxifi_blacklist_ops_.SetAllocated(&GetEmptyStringAlreadyInited(), onnxifi_blacklist_ops,
7971 GetArena());
7972 // @@protoc_insertion_point(field_set_allocated:caffe2.AOTConfig.onnxifi_blacklist_ops)
7973}
7974
7975// optional int32 onnxifi_min_ops = 5;
7976inline bool AOTConfig::_internal_has_onnxifi_min_ops() const {
7977 bool value = (_has_bits_[0] & 0x00000010u) != 0;
7978 return value;
7979}
7980inline bool AOTConfig::has_onnxifi_min_ops() const {
7981 return _internal_has_onnxifi_min_ops();
7982}
7983inline void AOTConfig::clear_onnxifi_min_ops() {
7984 onnxifi_min_ops_ = 0;
7985 _has_bits_[0] &= ~0x00000010u;
7986}
7987inline ::PROTOBUF_NAMESPACE_ID::int32 AOTConfig::_internal_onnxifi_min_ops() const {
7988 return onnxifi_min_ops_;
7989}
7990inline ::PROTOBUF_NAMESPACE_ID::int32 AOTConfig::onnxifi_min_ops() const {
7991 // @@protoc_insertion_point(field_get:caffe2.AOTConfig.onnxifi_min_ops)
7992 return _internal_onnxifi_min_ops();
7993}
7994inline void AOTConfig::_internal_set_onnxifi_min_ops(::PROTOBUF_NAMESPACE_ID::int32 value) {
7995 _has_bits_[0] |= 0x00000010u;
7996 onnxifi_min_ops_ = value;
7997}
7998inline void AOTConfig::set_onnxifi_min_ops(::PROTOBUF_NAMESPACE_ID::int32 value) {
7999 _internal_set_onnxifi_min_ops(value);
8000 // @@protoc_insertion_point(field_set:caffe2.AOTConfig.onnxifi_min_ops)
8001}
8002
8003// -------------------------------------------------------------------
8004
8005// Argument
8006
8007// optional string name = 1;
8008inline bool Argument::_internal_has_name() const {
8009 bool value = (_has_bits_[0] & 0x00000001u) != 0;
8010 return value;
8011}
8012inline bool Argument::has_name() const {
8013 return _internal_has_name();
8014}
8015inline void Argument::clear_name() {
8016 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
8017 _has_bits_[0] &= ~0x00000001u;
8018}
8019inline const std::string& Argument::name() const {
8020 // @@protoc_insertion_point(field_get:caffe2.Argument.name)
8021 return _internal_name();
8022}
8023inline void Argument::set_name(const std::string& value) {
8024 _internal_set_name(value);
8025 // @@protoc_insertion_point(field_set:caffe2.Argument.name)
8026}
8027inline std::string* Argument::mutable_name() {
8028 // @@protoc_insertion_point(field_mutable:caffe2.Argument.name)
8029 return _internal_mutable_name();
8030}
8031inline const std::string& Argument::_internal_name() const {
8032 return name_.Get();
8033}
8034inline void Argument::_internal_set_name(const std::string& value) {
8035 _has_bits_[0] |= 0x00000001u;
8036 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
8037}
8038inline void Argument::set_name(std::string&& value) {
8039 _has_bits_[0] |= 0x00000001u;
8040 name_.Set(
8041 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
8042 // @@protoc_insertion_point(field_set_rvalue:caffe2.Argument.name)
8043}
8044inline void Argument::set_name(const char* value) {
8045 GOOGLE_DCHECK(value != nullptr);
8046 _has_bits_[0] |= 0x00000001u;
8047 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
8048 GetArena());
8049 // @@protoc_insertion_point(field_set_char:caffe2.Argument.name)
8050}
8051inline void Argument::set_name(const char* value,
8052 size_t size) {
8053 _has_bits_[0] |= 0x00000001u;
8054 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
8055 reinterpret_cast<const char*>(value), size), GetArena());
8056 // @@protoc_insertion_point(field_set_pointer:caffe2.Argument.name)
8057}
8058inline std::string* Argument::_internal_mutable_name() {
8059 _has_bits_[0] |= 0x00000001u;
8060 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
8061}
8062inline std::string* Argument::release_name() {
8063 // @@protoc_insertion_point(field_release:caffe2.Argument.name)
8064 if (!_internal_has_name()) {
8065 return nullptr;
8066 }
8067 _has_bits_[0] &= ~0x00000001u;
8068 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
8069}
8070inline void Argument::set_allocated_name(std::string* name) {
8071 if (name != nullptr) {
8072 _has_bits_[0] |= 0x00000001u;
8073 } else {
8074 _has_bits_[0] &= ~0x00000001u;
8075 }
8076 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
8077 GetArena());
8078 // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.name)
8079}
8080
8081// optional float f = 2;
8082inline bool Argument::_internal_has_f() const {
8083 bool value = (_has_bits_[0] & 0x00000020u) != 0;
8084 return value;
8085}
8086inline bool Argument::has_f() const {
8087 return _internal_has_f();
8088}
8089inline void Argument::clear_f() {
8090 f_ = 0;
8091 _has_bits_[0] &= ~0x00000020u;
8092}
8093inline float Argument::_internal_f() const {
8094 return f_;
8095}
8096inline float Argument::f() const {
8097 // @@protoc_insertion_point(field_get:caffe2.Argument.f)
8098 return _internal_f();
8099}
8100inline void Argument::_internal_set_f(float value) {
8101 _has_bits_[0] |= 0x00000020u;
8102 f_ = value;
8103}
8104inline void Argument::set_f(float value) {
8105 _internal_set_f(value);
8106 // @@protoc_insertion_point(field_set:caffe2.Argument.f)
8107}
8108
8109// optional int64 i = 3;
8110inline bool Argument::_internal_has_i() const {
8111 bool value = (_has_bits_[0] & 0x00000010u) != 0;
8112 return value;
8113}
8114inline bool Argument::has_i() const {
8115 return _internal_has_i();
8116}
8117inline void Argument::clear_i() {
8118 i_ = PROTOBUF_LONGLONG(0);
8119 _has_bits_[0] &= ~0x00000010u;
8120}
8121inline ::PROTOBUF_NAMESPACE_ID::int64 Argument::_internal_i() const {
8122 return i_;
8123}
8124inline ::PROTOBUF_NAMESPACE_ID::int64 Argument::i() const {
8125 // @@protoc_insertion_point(field_get:caffe2.Argument.i)
8126 return _internal_i();
8127}
8128inline void Argument::_internal_set_i(::PROTOBUF_NAMESPACE_ID::int64 value) {
8129 _has_bits_[0] |= 0x00000010u;
8130 i_ = value;
8131}
8132inline void Argument::set_i(::PROTOBUF_NAMESPACE_ID::int64 value) {
8133 _internal_set_i(value);
8134 // @@protoc_insertion_point(field_set:caffe2.Argument.i)
8135}
8136
8137// optional bytes s = 4;
8138inline bool Argument::_internal_has_s() const {
8139 bool value = (_has_bits_[0] & 0x00000002u) != 0;
8140 return value;
8141}
8142inline bool Argument::has_s() const {
8143 return _internal_has_s();
8144}
8145inline void Argument::clear_s() {
8146 s_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
8147 _has_bits_[0] &= ~0x00000002u;
8148}
8149inline const std::string& Argument::s() const {
8150 // @@protoc_insertion_point(field_get:caffe2.Argument.s)
8151 return _internal_s();
8152}
8153inline void Argument::set_s(const std::string& value) {
8154 _internal_set_s(value);
8155 // @@protoc_insertion_point(field_set:caffe2.Argument.s)
8156}
8157inline std::string* Argument::mutable_s() {
8158 // @@protoc_insertion_point(field_mutable:caffe2.Argument.s)
8159 return _internal_mutable_s();
8160}
8161inline const std::string& Argument::_internal_s() const {
8162 return s_.Get();
8163}
8164inline void Argument::_internal_set_s(const std::string& value) {
8165 _has_bits_[0] |= 0x00000002u;
8166 s_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
8167}
8168inline void Argument::set_s(std::string&& value) {
8169 _has_bits_[0] |= 0x00000002u;
8170 s_.Set(
8171 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
8172 // @@protoc_insertion_point(field_set_rvalue:caffe2.Argument.s)
8173}
8174inline void Argument::set_s(const char* value) {
8175 GOOGLE_DCHECK(value != nullptr);
8176 _has_bits_[0] |= 0x00000002u;
8177 s_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
8178 GetArena());
8179 // @@protoc_insertion_point(field_set_char:caffe2.Argument.s)
8180}
8181inline void Argument::set_s(const void* value,
8182 size_t size) {
8183 _has_bits_[0] |= 0x00000002u;
8184 s_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
8185 reinterpret_cast<const char*>(value), size), GetArena());
8186 // @@protoc_insertion_point(field_set_pointer:caffe2.Argument.s)
8187}
8188inline std::string* Argument::_internal_mutable_s() {
8189 _has_bits_[0] |= 0x00000002u;
8190 return s_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
8191}
8192inline std::string* Argument::release_s() {
8193 // @@protoc_insertion_point(field_release:caffe2.Argument.s)
8194 if (!_internal_has_s()) {
8195 return nullptr;
8196 }
8197 _has_bits_[0] &= ~0x00000002u;
8198 return s_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
8199}
8200inline void Argument::set_allocated_s(std::string* s) {
8201 if (s != nullptr) {
8202 _has_bits_[0] |= 0x00000002u;
8203 } else {
8204 _has_bits_[0] &= ~0x00000002u;
8205 }
8206 s_.SetAllocated(&GetEmptyStringAlreadyInited(), s,
8207 GetArena());
8208 // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.s)
8209}
8210
8211// optional .caffe2.TensorProto t = 10;
8212inline bool Argument::_internal_has_t() const {
8213 bool value = (_has_bits_[0] & 0x00000008u) != 0;
8214 PROTOBUF_ASSUME(!value || t_ != nullptr);
8215 return value;
8216}
8217inline bool Argument::has_t() const {
8218 return _internal_has_t();
8219}
8220inline void Argument::clear_t() {
8221 if (t_ != nullptr) t_->Clear();
8222 _has_bits_[0] &= ~0x00000008u;
8223}
8224inline const ::caffe2::TensorProto& Argument::_internal_t() const {
8225 const ::caffe2::TensorProto* p = t_;
8226 return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::TensorProto*>(
8227 &::caffe2::_TensorProto_default_instance_);
8228}
8229inline const ::caffe2::TensorProto& Argument::t() const {
8230 // @@protoc_insertion_point(field_get:caffe2.Argument.t)
8231 return _internal_t();
8232}
8233inline void Argument::unsafe_arena_set_allocated_t(
8234 ::caffe2::TensorProto* t) {
8235 if (GetArena() == nullptr) {
8236 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(t_);
8237 }
8238 t_ = t;
8239 if (t) {
8240 _has_bits_[0] |= 0x00000008u;
8241 } else {
8242 _has_bits_[0] &= ~0x00000008u;
8243 }
8244 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.Argument.t)
8245}
8246inline ::caffe2::TensorProto* Argument::release_t() {
8247 _has_bits_[0] &= ~0x00000008u;
8248 ::caffe2::TensorProto* temp = t_;
8249 t_ = nullptr;
8250 if (GetArena() != nullptr) {
8251 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8252 }
8253 return temp;
8254}
8255inline ::caffe2::TensorProto* Argument::unsafe_arena_release_t() {
8256 // @@protoc_insertion_point(field_release:caffe2.Argument.t)
8257 _has_bits_[0] &= ~0x00000008u;
8258 ::caffe2::TensorProto* temp = t_;
8259 t_ = nullptr;
8260 return temp;
8261}
8262inline ::caffe2::TensorProto* Argument::_internal_mutable_t() {
8263 _has_bits_[0] |= 0x00000008u;
8264 if (t_ == nullptr) {
8265 auto* p = CreateMaybeMessage<::caffe2::TensorProto>(GetArena());
8266 t_ = p;
8267 }
8268 return t_;
8269}
8270inline ::caffe2::TensorProto* Argument::mutable_t() {
8271 // @@protoc_insertion_point(field_mutable:caffe2.Argument.t)
8272 return _internal_mutable_t();
8273}
8274inline void Argument::set_allocated_t(::caffe2::TensorProto* t) {
8275 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
8276 if (message_arena == nullptr) {
8277 delete t_;
8278 }
8279 if (t) {
8280 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
8281 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(t);
8282 if (message_arena != submessage_arena) {
8283 t = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
8284 message_arena, t, submessage_arena);
8285 }
8286 _has_bits_[0] |= 0x00000008u;
8287 } else {
8288 _has_bits_[0] &= ~0x00000008u;
8289 }
8290 t_ = t;
8291 // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.t)
8292}
8293
8294// optional .caffe2.NetDef n = 8;
8295inline bool Argument::_internal_has_n() const {
8296 bool value = (_has_bits_[0] & 0x00000004u) != 0;
8297 PROTOBUF_ASSUME(!value || n_ != nullptr);
8298 return value;
8299}
8300inline bool Argument::has_n() const {
8301 return _internal_has_n();
8302}
8303inline void Argument::clear_n() {
8304 if (n_ != nullptr) n_->Clear();
8305 _has_bits_[0] &= ~0x00000004u;
8306}
8307inline const ::caffe2::NetDef& Argument::_internal_n() const {
8308 const ::caffe2::NetDef* p = n_;
8309 return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::NetDef*>(
8310 &::caffe2::_NetDef_default_instance_);
8311}
8312inline const ::caffe2::NetDef& Argument::n() const {
8313 // @@protoc_insertion_point(field_get:caffe2.Argument.n)
8314 return _internal_n();
8315}
8316inline void Argument::unsafe_arena_set_allocated_n(
8317 ::caffe2::NetDef* n) {
8318 if (GetArena() == nullptr) {
8319 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(n_);
8320 }
8321 n_ = n;
8322 if (n) {
8323 _has_bits_[0] |= 0x00000004u;
8324 } else {
8325 _has_bits_[0] &= ~0x00000004u;
8326 }
8327 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.Argument.n)
8328}
8329inline ::caffe2::NetDef* Argument::release_n() {
8330 _has_bits_[0] &= ~0x00000004u;
8331 ::caffe2::NetDef* temp = n_;
8332 n_ = nullptr;
8333 if (GetArena() != nullptr) {
8334 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8335 }
8336 return temp;
8337}
8338inline ::caffe2::NetDef* Argument::unsafe_arena_release_n() {
8339 // @@protoc_insertion_point(field_release:caffe2.Argument.n)
8340 _has_bits_[0] &= ~0x00000004u;
8341 ::caffe2::NetDef* temp = n_;
8342 n_ = nullptr;
8343 return temp;
8344}
8345inline ::caffe2::NetDef* Argument::_internal_mutable_n() {
8346 _has_bits_[0] |= 0x00000004u;
8347 if (n_ == nullptr) {
8348 auto* p = CreateMaybeMessage<::caffe2::NetDef>(GetArena());
8349 n_ = p;
8350 }
8351 return n_;
8352}
8353inline ::caffe2::NetDef* Argument::mutable_n() {
8354 // @@protoc_insertion_point(field_mutable:caffe2.Argument.n)
8355 return _internal_mutable_n();
8356}
8357inline void Argument::set_allocated_n(::caffe2::NetDef* n) {
8358 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
8359 if (message_arena == nullptr) {
8360 delete n_;
8361 }
8362 if (n) {
8363 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
8364 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(n);
8365 if (message_arena != submessage_arena) {
8366 n = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
8367 message_arena, n, submessage_arena);
8368 }
8369 _has_bits_[0] |= 0x00000004u;
8370 } else {
8371 _has_bits_[0] &= ~0x00000004u;
8372 }
8373 n_ = n;
8374 // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.n)
8375}
8376
8377// repeated float floats = 5;
8378inline int Argument::_internal_floats_size() const {
8379 return floats_.size();
8380}
8381inline int Argument::floats_size() const {
8382 return _internal_floats_size();
8383}
8384inline void Argument::clear_floats() {
8385 floats_.Clear();
8386}
8387inline float Argument::_internal_floats(int index) const {
8388 return floats_.Get(index);
8389}
8390inline float Argument::floats(int index) const {
8391 // @@protoc_insertion_point(field_get:caffe2.Argument.floats)
8392 return _internal_floats(index);
8393}
8394inline void Argument::set_floats(int index, float value) {
8395 floats_.Set(index, value);
8396 // @@protoc_insertion_point(field_set:caffe2.Argument.floats)
8397}
8398inline void Argument::_internal_add_floats(float value) {
8399 floats_.Add(value);
8400}
8401inline void Argument::add_floats(float value) {
8402 _internal_add_floats(value);
8403 // @@protoc_insertion_point(field_add:caffe2.Argument.floats)
8404}
8405inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
8406Argument::_internal_floats() const {
8407 return floats_;
8408}
8409inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
8410Argument::floats() const {
8411 // @@protoc_insertion_point(field_list:caffe2.Argument.floats)
8412 return _internal_floats();
8413}
8414inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
8415Argument::_internal_mutable_floats() {
8416 return &floats_;
8417}
8418inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
8419Argument::mutable_floats() {
8420 // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.floats)
8421 return _internal_mutable_floats();
8422}
8423
8424// repeated int64 ints = 6;
8425inline int Argument::_internal_ints_size() const {
8426 return ints_.size();
8427}
8428inline int Argument::ints_size() const {
8429 return _internal_ints_size();
8430}
8431inline void Argument::clear_ints() {
8432 ints_.Clear();
8433}
8434inline ::PROTOBUF_NAMESPACE_ID::int64 Argument::_internal_ints(int index) const {
8435 return ints_.Get(index);
8436}
8437inline ::PROTOBUF_NAMESPACE_ID::int64 Argument::ints(int index) const {
8438 // @@protoc_insertion_point(field_get:caffe2.Argument.ints)
8439 return _internal_ints(index);
8440}
8441inline void Argument::set_ints(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
8442 ints_.Set(index, value);
8443 // @@protoc_insertion_point(field_set:caffe2.Argument.ints)
8444}
8445inline void Argument::_internal_add_ints(::PROTOBUF_NAMESPACE_ID::int64 value) {
8446 ints_.Add(value);
8447}
8448inline void Argument::add_ints(::PROTOBUF_NAMESPACE_ID::int64 value) {
8449 _internal_add_ints(value);
8450 // @@protoc_insertion_point(field_add:caffe2.Argument.ints)
8451}
8452inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
8453Argument::_internal_ints() const {
8454 return ints_;
8455}
8456inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
8457Argument::ints() const {
8458 // @@protoc_insertion_point(field_list:caffe2.Argument.ints)
8459 return _internal_ints();
8460}
8461inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
8462Argument::_internal_mutable_ints() {
8463 return &ints_;
8464}
8465inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
8466Argument::mutable_ints() {
8467 // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.ints)
8468 return _internal_mutable_ints();
8469}
8470
8471// repeated bytes strings = 7;
8472inline int Argument::_internal_strings_size() const {
8473 return strings_.size();
8474}
8475inline int Argument::strings_size() const {
8476 return _internal_strings_size();
8477}
8478inline void Argument::clear_strings() {
8479 strings_.Clear();
8480}
8481inline std::string* Argument::add_strings() {
8482 // @@protoc_insertion_point(field_add_mutable:caffe2.Argument.strings)
8483 return _internal_add_strings();
8484}
8485inline const std::string& Argument::_internal_strings(int index) const {
8486 return strings_.Get(index);
8487}
8488inline const std::string& Argument::strings(int index) const {
8489 // @@protoc_insertion_point(field_get:caffe2.Argument.strings)
8490 return _internal_strings(index);
8491}
8492inline std::string* Argument::mutable_strings(int index) {
8493 // @@protoc_insertion_point(field_mutable:caffe2.Argument.strings)
8494 return strings_.Mutable(index);
8495}
8496inline void Argument::set_strings(int index, const std::string& value) {
8497 // @@protoc_insertion_point(field_set:caffe2.Argument.strings)
8498 strings_.Mutable(index)->assign(value);
8499}
8500inline void Argument::set_strings(int index, std::string&& value) {
8501 // @@protoc_insertion_point(field_set:caffe2.Argument.strings)
8502 strings_.Mutable(index)->assign(std::move(value));
8503}
8504inline void Argument::set_strings(int index, const char* value) {
8505 GOOGLE_DCHECK(value != nullptr);
8506 strings_.Mutable(index)->assign(value);
8507 // @@protoc_insertion_point(field_set_char:caffe2.Argument.strings)
8508}
8509inline void Argument::set_strings(int index, const void* value, size_t size) {
8510 strings_.Mutable(index)->assign(
8511 reinterpret_cast<const char*>(value), size);
8512 // @@protoc_insertion_point(field_set_pointer:caffe2.Argument.strings)
8513}
8514inline std::string* Argument::_internal_add_strings() {
8515 return strings_.Add();
8516}
8517inline void Argument::add_strings(const std::string& value) {
8518 strings_.Add()->assign(value);
8519 // @@protoc_insertion_point(field_add:caffe2.Argument.strings)
8520}
8521inline void Argument::add_strings(std::string&& value) {
8522 strings_.Add(std::move(value));
8523 // @@protoc_insertion_point(field_add:caffe2.Argument.strings)
8524}
8525inline void Argument::add_strings(const char* value) {
8526 GOOGLE_DCHECK(value != nullptr);
8527 strings_.Add()->assign(value);
8528 // @@protoc_insertion_point(field_add_char:caffe2.Argument.strings)
8529}
8530inline void Argument::add_strings(const void* value, size_t size) {
8531 strings_.Add()->assign(reinterpret_cast<const char*>(value), size);
8532 // @@protoc_insertion_point(field_add_pointer:caffe2.Argument.strings)
8533}
8534inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
8535Argument::strings() const {
8536 // @@protoc_insertion_point(field_list:caffe2.Argument.strings)
8537 return strings_;
8538}
8539inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
8540Argument::mutable_strings() {
8541 // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.strings)
8542 return &strings_;
8543}
8544
8545// repeated .caffe2.TensorProto tensors = 11;
8546inline int Argument::_internal_tensors_size() const {
8547 return tensors_.size();
8548}
8549inline int Argument::tensors_size() const {
8550 return _internal_tensors_size();
8551}
8552inline void Argument::clear_tensors() {
8553 tensors_.Clear();
8554}
8555inline ::caffe2::TensorProto* Argument::mutable_tensors(int index) {
8556 // @@protoc_insertion_point(field_mutable:caffe2.Argument.tensors)
8557 return tensors_.Mutable(index);
8558}
8559inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >*
8560Argument::mutable_tensors() {
8561 // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.tensors)
8562 return &tensors_;
8563}
8564inline const ::caffe2::TensorProto& Argument::_internal_tensors(int index) const {
8565 return tensors_.Get(index);
8566}
8567inline const ::caffe2::TensorProto& Argument::tensors(int index) const {
8568 // @@protoc_insertion_point(field_get:caffe2.Argument.tensors)
8569 return _internal_tensors(index);
8570}
8571inline ::caffe2::TensorProto* Argument::_internal_add_tensors() {
8572 return tensors_.Add();
8573}
8574inline ::caffe2::TensorProto* Argument::add_tensors() {
8575 // @@protoc_insertion_point(field_add:caffe2.Argument.tensors)
8576 return _internal_add_tensors();
8577}
8578inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >&
8579Argument::tensors() const {
8580 // @@protoc_insertion_point(field_list:caffe2.Argument.tensors)
8581 return tensors_;
8582}
8583
8584// repeated .caffe2.NetDef nets = 9;
8585inline int Argument::_internal_nets_size() const {
8586 return nets_.size();
8587}
8588inline int Argument::nets_size() const {
8589 return _internal_nets_size();
8590}
8591inline void Argument::clear_nets() {
8592 nets_.Clear();
8593}
8594inline ::caffe2::NetDef* Argument::mutable_nets(int index) {
8595 // @@protoc_insertion_point(field_mutable:caffe2.Argument.nets)
8596 return nets_.Mutable(index);
8597}
8598inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >*
8599Argument::mutable_nets() {
8600 // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.nets)
8601 return &nets_;
8602}
8603inline const ::caffe2::NetDef& Argument::_internal_nets(int index) const {
8604 return nets_.Get(index);
8605}
8606inline const ::caffe2::NetDef& Argument::nets(int index) const {
8607 // @@protoc_insertion_point(field_get:caffe2.Argument.nets)
8608 return _internal_nets(index);
8609}
8610inline ::caffe2::NetDef* Argument::_internal_add_nets() {
8611 return nets_.Add();
8612}
8613inline ::caffe2::NetDef* Argument::add_nets() {
8614 // @@protoc_insertion_point(field_add:caffe2.Argument.nets)
8615 return _internal_add_nets();
8616}
8617inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >&
8618Argument::nets() const {
8619 // @@protoc_insertion_point(field_list:caffe2.Argument.nets)
8620 return nets_;
8621}
8622
8623// repeated .caffe2.QTensorProto qtensors = 12;
8624inline int Argument::_internal_qtensors_size() const {
8625 return qtensors_.size();
8626}
8627inline int Argument::qtensors_size() const {
8628 return _internal_qtensors_size();
8629}
8630inline void Argument::clear_qtensors() {
8631 qtensors_.Clear();
8632}
8633inline ::caffe2::QTensorProto* Argument::mutable_qtensors(int index) {
8634 // @@protoc_insertion_point(field_mutable:caffe2.Argument.qtensors)
8635 return qtensors_.Mutable(index);
8636}
8637inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto >*
8638Argument::mutable_qtensors() {
8639 // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.qtensors)
8640 return &qtensors_;
8641}
8642inline const ::caffe2::QTensorProto& Argument::_internal_qtensors(int index) const {
8643 return qtensors_.Get(index);
8644}
8645inline const ::caffe2::QTensorProto& Argument::qtensors(int index) const {
8646 // @@protoc_insertion_point(field_get:caffe2.Argument.qtensors)
8647 return _internal_qtensors(index);
8648}
8649inline ::caffe2::QTensorProto* Argument::_internal_add_qtensors() {
8650 return qtensors_.Add();
8651}
8652inline ::caffe2::QTensorProto* Argument::add_qtensors() {
8653 // @@protoc_insertion_point(field_add:caffe2.Argument.qtensors)
8654 return _internal_add_qtensors();
8655}
8656inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto >&
8657Argument::qtensors() const {
8658 // @@protoc_insertion_point(field_list:caffe2.Argument.qtensors)
8659 return qtensors_;
8660}
8661
8662// -------------------------------------------------------------------
8663
8664// DeviceOption
8665
8666// optional int32 device_type = 1 [default = 0];
8667inline bool DeviceOption::_internal_has_device_type() const {
8668 bool value = (_has_bits_[0] & 0x00000002u) != 0;
8669 return value;
8670}
8671inline bool DeviceOption::has_device_type() const {
8672 return _internal_has_device_type();
8673}
8674inline void DeviceOption::clear_device_type() {
8675 device_type_ = 0;
8676 _has_bits_[0] &= ~0x00000002u;
8677}
8678inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::_internal_device_type() const {
8679 return device_type_;
8680}
8681inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::device_type() const {
8682 // @@protoc_insertion_point(field_get:caffe2.DeviceOption.device_type)
8683 return _internal_device_type();
8684}
8685inline void DeviceOption::_internal_set_device_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
8686 _has_bits_[0] |= 0x00000002u;
8687 device_type_ = value;
8688}
8689inline void DeviceOption::set_device_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
8690 _internal_set_device_type(value);
8691 // @@protoc_insertion_point(field_set:caffe2.DeviceOption.device_type)
8692}
8693
8694// optional int32 device_id = 2;
8695inline bool DeviceOption::_internal_has_device_id() const {
8696 bool value = (_has_bits_[0] & 0x00000004u) != 0;
8697 return value;
8698}
8699inline bool DeviceOption::has_device_id() const {
8700 return _internal_has_device_id();
8701}
8702inline void DeviceOption::clear_device_id() {
8703 device_id_ = 0;
8704 _has_bits_[0] &= ~0x00000004u;
8705}
8706inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::_internal_device_id() const {
8707 return device_id_;
8708}
8709inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::device_id() const {
8710 // @@protoc_insertion_point(field_get:caffe2.DeviceOption.device_id)
8711 return _internal_device_id();
8712}
8713inline void DeviceOption::_internal_set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
8714 _has_bits_[0] |= 0x00000004u;
8715 device_id_ = value;
8716}
8717inline void DeviceOption::set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
8718 _internal_set_device_id(value);
8719 // @@protoc_insertion_point(field_set:caffe2.DeviceOption.device_id)
8720}
8721
8722// optional uint32 random_seed = 3;
8723inline bool DeviceOption::_internal_has_random_seed() const {
8724 bool value = (_has_bits_[0] & 0x00000008u) != 0;
8725 return value;
8726}
8727inline bool DeviceOption::has_random_seed() const {
8728 return _internal_has_random_seed();
8729}
8730inline void DeviceOption::clear_random_seed() {
8731 random_seed_ = 0u;
8732 _has_bits_[0] &= ~0x00000008u;
8733}
8734inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceOption::_internal_random_seed() const {
8735 return random_seed_;
8736}
8737inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceOption::random_seed() const {
8738 // @@protoc_insertion_point(field_get:caffe2.DeviceOption.random_seed)
8739 return _internal_random_seed();
8740}
8741inline void DeviceOption::_internal_set_random_seed(::PROTOBUF_NAMESPACE_ID::uint32 value) {
8742 _has_bits_[0] |= 0x00000008u;
8743 random_seed_ = value;
8744}
8745inline void DeviceOption::set_random_seed(::PROTOBUF_NAMESPACE_ID::uint32 value) {
8746 _internal_set_random_seed(value);
8747 // @@protoc_insertion_point(field_set:caffe2.DeviceOption.random_seed)
8748}
8749
8750// optional string node_name = 4;
8751inline bool DeviceOption::_internal_has_node_name() const {
8752 bool value = (_has_bits_[0] & 0x00000001u) != 0;
8753 return value;
8754}
8755inline bool DeviceOption::has_node_name() const {
8756 return _internal_has_node_name();
8757}
8758inline void DeviceOption::clear_node_name() {
8759 node_name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
8760 _has_bits_[0] &= ~0x00000001u;
8761}
8762inline const std::string& DeviceOption::node_name() const {
8763 // @@protoc_insertion_point(field_get:caffe2.DeviceOption.node_name)
8764 return _internal_node_name();
8765}
8766inline void DeviceOption::set_node_name(const std::string& value) {
8767 _internal_set_node_name(value);
8768 // @@protoc_insertion_point(field_set:caffe2.DeviceOption.node_name)
8769}
8770inline std::string* DeviceOption::mutable_node_name() {
8771 // @@protoc_insertion_point(field_mutable:caffe2.DeviceOption.node_name)
8772 return _internal_mutable_node_name();
8773}
8774inline const std::string& DeviceOption::_internal_node_name() const {
8775 return node_name_.Get();
8776}
8777inline void DeviceOption::_internal_set_node_name(const std::string& value) {
8778 _has_bits_[0] |= 0x00000001u;
8779 node_name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
8780}
8781inline void DeviceOption::set_node_name(std::string&& value) {
8782 _has_bits_[0] |= 0x00000001u;
8783 node_name_.Set(
8784 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
8785 // @@protoc_insertion_point(field_set_rvalue:caffe2.DeviceOption.node_name)
8786}
8787inline void DeviceOption::set_node_name(const char* value) {
8788 GOOGLE_DCHECK(value != nullptr);
8789 _has_bits_[0] |= 0x00000001u;
8790 node_name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
8791 GetArena());
8792 // @@protoc_insertion_point(field_set_char:caffe2.DeviceOption.node_name)
8793}
8794inline void DeviceOption::set_node_name(const char* value,
8795 size_t size) {
8796 _has_bits_[0] |= 0x00000001u;
8797 node_name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
8798 reinterpret_cast<const char*>(value), size), GetArena());
8799 // @@protoc_insertion_point(field_set_pointer:caffe2.DeviceOption.node_name)
8800}
8801inline std::string* DeviceOption::_internal_mutable_node_name() {
8802 _has_bits_[0] |= 0x00000001u;
8803 return node_name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
8804}
8805inline std::string* DeviceOption::release_node_name() {
8806 // @@protoc_insertion_point(field_release:caffe2.DeviceOption.node_name)
8807 if (!_internal_has_node_name()) {
8808 return nullptr;
8809 }
8810 _has_bits_[0] &= ~0x00000001u;
8811 return node_name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
8812}
8813inline void DeviceOption::set_allocated_node_name(std::string* node_name) {
8814 if (node_name != nullptr) {
8815 _has_bits_[0] |= 0x00000001u;
8816 } else {
8817 _has_bits_[0] &= ~0x00000001u;
8818 }
8819 node_name_.SetAllocated(&GetEmptyStringAlreadyInited(), node_name,
8820 GetArena());
8821 // @@protoc_insertion_point(field_set_allocated:caffe2.DeviceOption.node_name)
8822}
8823
8824// optional int32 numa_node_id = 5;
8825inline bool DeviceOption::_internal_has_numa_node_id() const {
8826 bool value = (_has_bits_[0] & 0x00000010u) != 0;
8827 return value;
8828}
8829inline bool DeviceOption::has_numa_node_id() const {
8830 return _internal_has_numa_node_id();
8831}
8832inline void DeviceOption::clear_numa_node_id() {
8833 numa_node_id_ = 0;
8834 _has_bits_[0] &= ~0x00000010u;
8835}
8836inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::_internal_numa_node_id() const {
8837 return numa_node_id_;
8838}
8839inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::numa_node_id() const {
8840 // @@protoc_insertion_point(field_get:caffe2.DeviceOption.numa_node_id)
8841 return _internal_numa_node_id();
8842}
8843inline void DeviceOption::_internal_set_numa_node_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
8844 _has_bits_[0] |= 0x00000010u;
8845 numa_node_id_ = value;
8846}
8847inline void DeviceOption::set_numa_node_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
8848 _internal_set_numa_node_id(value);
8849 // @@protoc_insertion_point(field_set:caffe2.DeviceOption.numa_node_id)
8850}
8851
8852// repeated string extra_info = 6;
8853inline int DeviceOption::_internal_extra_info_size() const {
8854 return extra_info_.size();
8855}
8856inline int DeviceOption::extra_info_size() const {
8857 return _internal_extra_info_size();
8858}
8859inline void DeviceOption::clear_extra_info() {
8860 extra_info_.Clear();
8861}
8862inline std::string* DeviceOption::add_extra_info() {
8863 // @@protoc_insertion_point(field_add_mutable:caffe2.DeviceOption.extra_info)
8864 return _internal_add_extra_info();
8865}
8866inline const std::string& DeviceOption::_internal_extra_info(int index) const {
8867 return extra_info_.Get(index);
8868}
8869inline const std::string& DeviceOption::extra_info(int index) const {
8870 // @@protoc_insertion_point(field_get:caffe2.DeviceOption.extra_info)
8871 return _internal_extra_info(index);
8872}
8873inline std::string* DeviceOption::mutable_extra_info(int index) {
8874 // @@protoc_insertion_point(field_mutable:caffe2.DeviceOption.extra_info)
8875 return extra_info_.Mutable(index);
8876}
8877inline void DeviceOption::set_extra_info(int index, const std::string& value) {
8878 // @@protoc_insertion_point(field_set:caffe2.DeviceOption.extra_info)
8879 extra_info_.Mutable(index)->assign(value);
8880}
8881inline void DeviceOption::set_extra_info(int index, std::string&& value) {
8882 // @@protoc_insertion_point(field_set:caffe2.DeviceOption.extra_info)
8883 extra_info_.Mutable(index)->assign(std::move(value));
8884}
8885inline void DeviceOption::set_extra_info(int index, const char* value) {
8886 GOOGLE_DCHECK(value != nullptr);
8887 extra_info_.Mutable(index)->assign(value);
8888 // @@protoc_insertion_point(field_set_char:caffe2.DeviceOption.extra_info)
8889}
8890inline void DeviceOption::set_extra_info(int index, const char* value, size_t size) {
8891 extra_info_.Mutable(index)->assign(
8892 reinterpret_cast<const char*>(value), size);
8893 // @@protoc_insertion_point(field_set_pointer:caffe2.DeviceOption.extra_info)
8894}
8895inline std::string* DeviceOption::_internal_add_extra_info() {
8896 return extra_info_.Add();
8897}
8898inline void DeviceOption::add_extra_info(const std::string& value) {
8899 extra_info_.Add()->assign(value);
8900 // @@protoc_insertion_point(field_add:caffe2.DeviceOption.extra_info)
8901}
8902inline void DeviceOption::add_extra_info(std::string&& value) {
8903 extra_info_.Add(std::move(value));
8904 // @@protoc_insertion_point(field_add:caffe2.DeviceOption.extra_info)
8905}
8906inline void DeviceOption::add_extra_info(const char* value) {
8907 GOOGLE_DCHECK(value != nullptr);
8908 extra_info_.Add()->assign(value);
8909 // @@protoc_insertion_point(field_add_char:caffe2.DeviceOption.extra_info)
8910}
8911inline void DeviceOption::add_extra_info(const char* value, size_t size) {
8912 extra_info_.Add()->assign(reinterpret_cast<const char*>(value), size);
8913 // @@protoc_insertion_point(field_add_pointer:caffe2.DeviceOption.extra_info)
8914}
8915inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
8916DeviceOption::extra_info() const {
8917 // @@protoc_insertion_point(field_list:caffe2.DeviceOption.extra_info)
8918 return extra_info_;
8919}
8920inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
8921DeviceOption::mutable_extra_info() {
8922 // @@protoc_insertion_point(field_mutable_list:caffe2.DeviceOption.extra_info)
8923 return &extra_info_;
8924}
8925
8926// -------------------------------------------------------------------
8927
8928// OperatorDef
8929
8930// repeated string input = 1;
8931inline int OperatorDef::_internal_input_size() const {
8932 return input_.size();
8933}
8934inline int OperatorDef::input_size() const {
8935 return _internal_input_size();
8936}
8937inline void OperatorDef::clear_input() {
8938 input_.Clear();
8939}
8940inline std::string* OperatorDef::add_input() {
8941 // @@protoc_insertion_point(field_add_mutable:caffe2.OperatorDef.input)
8942 return _internal_add_input();
8943}
8944inline const std::string& OperatorDef::_internal_input(int index) const {
8945 return input_.Get(index);
8946}
8947inline const std::string& OperatorDef::input(int index) const {
8948 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.input)
8949 return _internal_input(index);
8950}
8951inline std::string* OperatorDef::mutable_input(int index) {
8952 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.input)
8953 return input_.Mutable(index);
8954}
8955inline void OperatorDef::set_input(int index, const std::string& value) {
8956 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.input)
8957 input_.Mutable(index)->assign(value);
8958}
8959inline void OperatorDef::set_input(int index, std::string&& value) {
8960 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.input)
8961 input_.Mutable(index)->assign(std::move(value));
8962}
8963inline void OperatorDef::set_input(int index, const char* value) {
8964 GOOGLE_DCHECK(value != nullptr);
8965 input_.Mutable(index)->assign(value);
8966 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.input)
8967}
8968inline void OperatorDef::set_input(int index, const char* value, size_t size) {
8969 input_.Mutable(index)->assign(
8970 reinterpret_cast<const char*>(value), size);
8971 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.input)
8972}
8973inline std::string* OperatorDef::_internal_add_input() {
8974 return input_.Add();
8975}
8976inline void OperatorDef::add_input(const std::string& value) {
8977 input_.Add()->assign(value);
8978 // @@protoc_insertion_point(field_add:caffe2.OperatorDef.input)
8979}
8980inline void OperatorDef::add_input(std::string&& value) {
8981 input_.Add(std::move(value));
8982 // @@protoc_insertion_point(field_add:caffe2.OperatorDef.input)
8983}
8984inline void OperatorDef::add_input(const char* value) {
8985 GOOGLE_DCHECK(value != nullptr);
8986 input_.Add()->assign(value);
8987 // @@protoc_insertion_point(field_add_char:caffe2.OperatorDef.input)
8988}
8989inline void OperatorDef::add_input(const char* value, size_t size) {
8990 input_.Add()->assign(reinterpret_cast<const char*>(value), size);
8991 // @@protoc_insertion_point(field_add_pointer:caffe2.OperatorDef.input)
8992}
8993inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
8994OperatorDef::input() const {
8995 // @@protoc_insertion_point(field_list:caffe2.OperatorDef.input)
8996 return input_;
8997}
8998inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
8999OperatorDef::mutable_input() {
9000 // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.input)
9001 return &input_;
9002}
9003
9004// repeated string output = 2;
9005inline int OperatorDef::_internal_output_size() const {
9006 return output_.size();
9007}
9008inline int OperatorDef::output_size() const {
9009 return _internal_output_size();
9010}
9011inline void OperatorDef::clear_output() {
9012 output_.Clear();
9013}
9014inline std::string* OperatorDef::add_output() {
9015 // @@protoc_insertion_point(field_add_mutable:caffe2.OperatorDef.output)
9016 return _internal_add_output();
9017}
9018inline const std::string& OperatorDef::_internal_output(int index) const {
9019 return output_.Get(index);
9020}
9021inline const std::string& OperatorDef::output(int index) const {
9022 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.output)
9023 return _internal_output(index);
9024}
9025inline std::string* OperatorDef::mutable_output(int index) {
9026 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.output)
9027 return output_.Mutable(index);
9028}
9029inline void OperatorDef::set_output(int index, const std::string& value) {
9030 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.output)
9031 output_.Mutable(index)->assign(value);
9032}
9033inline void OperatorDef::set_output(int index, std::string&& value) {
9034 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.output)
9035 output_.Mutable(index)->assign(std::move(value));
9036}
9037inline void OperatorDef::set_output(int index, const char* value) {
9038 GOOGLE_DCHECK(value != nullptr);
9039 output_.Mutable(index)->assign(value);
9040 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.output)
9041}
9042inline void OperatorDef::set_output(int index, const char* value, size_t size) {
9043 output_.Mutable(index)->assign(
9044 reinterpret_cast<const char*>(value), size);
9045 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.output)
9046}
9047inline std::string* OperatorDef::_internal_add_output() {
9048 return output_.Add();
9049}
9050inline void OperatorDef::add_output(const std::string& value) {
9051 output_.Add()->assign(value);
9052 // @@protoc_insertion_point(field_add:caffe2.OperatorDef.output)
9053}
9054inline void OperatorDef::add_output(std::string&& value) {
9055 output_.Add(std::move(value));
9056 // @@protoc_insertion_point(field_add:caffe2.OperatorDef.output)
9057}
9058inline void OperatorDef::add_output(const char* value) {
9059 GOOGLE_DCHECK(value != nullptr);
9060 output_.Add()->assign(value);
9061 // @@protoc_insertion_point(field_add_char:caffe2.OperatorDef.output)
9062}
9063inline void OperatorDef::add_output(const char* value, size_t size) {
9064 output_.Add()->assign(reinterpret_cast<const char*>(value), size);
9065 // @@protoc_insertion_point(field_add_pointer:caffe2.OperatorDef.output)
9066}
9067inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
9068OperatorDef::output() const {
9069 // @@protoc_insertion_point(field_list:caffe2.OperatorDef.output)
9070 return output_;
9071}
9072inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
9073OperatorDef::mutable_output() {
9074 // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.output)
9075 return &output_;
9076}
9077
9078// optional string name = 3;
9079inline bool OperatorDef::_internal_has_name() const {
9080 bool value = (_has_bits_[0] & 0x00000001u) != 0;
9081 return value;
9082}
9083inline bool OperatorDef::has_name() const {
9084 return _internal_has_name();
9085}
9086inline void OperatorDef::clear_name() {
9087 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
9088 _has_bits_[0] &= ~0x00000001u;
9089}
9090inline const std::string& OperatorDef::name() const {
9091 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.name)
9092 return _internal_name();
9093}
9094inline void OperatorDef::set_name(const std::string& value) {
9095 _internal_set_name(value);
9096 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.name)
9097}
9098inline std::string* OperatorDef::mutable_name() {
9099 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.name)
9100 return _internal_mutable_name();
9101}
9102inline const std::string& OperatorDef::_internal_name() const {
9103 return name_.Get();
9104}
9105inline void OperatorDef::_internal_set_name(const std::string& value) {
9106 _has_bits_[0] |= 0x00000001u;
9107 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
9108}
9109inline void OperatorDef::set_name(std::string&& value) {
9110 _has_bits_[0] |= 0x00000001u;
9111 name_.Set(
9112 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
9113 // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.name)
9114}
9115inline void OperatorDef::set_name(const char* value) {
9116 GOOGLE_DCHECK(value != nullptr);
9117 _has_bits_[0] |= 0x00000001u;
9118 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
9119 GetArena());
9120 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.name)
9121}
9122inline void OperatorDef::set_name(const char* value,
9123 size_t size) {
9124 _has_bits_[0] |= 0x00000001u;
9125 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
9126 reinterpret_cast<const char*>(value), size), GetArena());
9127 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.name)
9128}
9129inline std::string* OperatorDef::_internal_mutable_name() {
9130 _has_bits_[0] |= 0x00000001u;
9131 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
9132}
9133inline std::string* OperatorDef::release_name() {
9134 // @@protoc_insertion_point(field_release:caffe2.OperatorDef.name)
9135 if (!_internal_has_name()) {
9136 return nullptr;
9137 }
9138 _has_bits_[0] &= ~0x00000001u;
9139 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
9140}
9141inline void OperatorDef::set_allocated_name(std::string* name) {
9142 if (name != nullptr) {
9143 _has_bits_[0] |= 0x00000001u;
9144 } else {
9145 _has_bits_[0] &= ~0x00000001u;
9146 }
9147 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
9148 GetArena());
9149 // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.name)
9150}
9151
9152// optional string type = 4;
9153inline bool OperatorDef::_internal_has_type() const {
9154 bool value = (_has_bits_[0] & 0x00000002u) != 0;
9155 return value;
9156}
9157inline bool OperatorDef::has_type() const {
9158 return _internal_has_type();
9159}
9160inline void OperatorDef::clear_type() {
9161 type_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
9162 _has_bits_[0] &= ~0x00000002u;
9163}
9164inline const std::string& OperatorDef::type() const {
9165 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.type)
9166 return _internal_type();
9167}
9168inline void OperatorDef::set_type(const std::string& value) {
9169 _internal_set_type(value);
9170 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.type)
9171}
9172inline std::string* OperatorDef::mutable_type() {
9173 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.type)
9174 return _internal_mutable_type();
9175}
9176inline const std::string& OperatorDef::_internal_type() const {
9177 return type_.Get();
9178}
9179inline void OperatorDef::_internal_set_type(const std::string& value) {
9180 _has_bits_[0] |= 0x00000002u;
9181 type_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
9182}
9183inline void OperatorDef::set_type(std::string&& value) {
9184 _has_bits_[0] |= 0x00000002u;
9185 type_.Set(
9186 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
9187 // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.type)
9188}
9189inline void OperatorDef::set_type(const char* value) {
9190 GOOGLE_DCHECK(value != nullptr);
9191 _has_bits_[0] |= 0x00000002u;
9192 type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
9193 GetArena());
9194 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.type)
9195}
9196inline void OperatorDef::set_type(const char* value,
9197 size_t size) {
9198 _has_bits_[0] |= 0x00000002u;
9199 type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
9200 reinterpret_cast<const char*>(value), size), GetArena());
9201 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.type)
9202}
9203inline std::string* OperatorDef::_internal_mutable_type() {
9204 _has_bits_[0] |= 0x00000002u;
9205 return type_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
9206}
9207inline std::string* OperatorDef::release_type() {
9208 // @@protoc_insertion_point(field_release:caffe2.OperatorDef.type)
9209 if (!_internal_has_type()) {
9210 return nullptr;
9211 }
9212 _has_bits_[0] &= ~0x00000002u;
9213 return type_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
9214}
9215inline void OperatorDef::set_allocated_type(std::string* type) {
9216 if (type != nullptr) {
9217 _has_bits_[0] |= 0x00000002u;
9218 } else {
9219 _has_bits_[0] &= ~0x00000002u;
9220 }
9221 type_.SetAllocated(&GetEmptyStringAlreadyInited(), type,
9222 GetArena());
9223 // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.type)
9224}
9225
9226// repeated .caffe2.Argument arg = 5;
9227inline int OperatorDef::_internal_arg_size() const {
9228 return arg_.size();
9229}
9230inline int OperatorDef::arg_size() const {
9231 return _internal_arg_size();
9232}
9233inline void OperatorDef::clear_arg() {
9234 arg_.Clear();
9235}
9236inline ::caffe2::Argument* OperatorDef::mutable_arg(int index) {
9237 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.arg)
9238 return arg_.Mutable(index);
9239}
9240inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >*
9241OperatorDef::mutable_arg() {
9242 // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.arg)
9243 return &arg_;
9244}
9245inline const ::caffe2::Argument& OperatorDef::_internal_arg(int index) const {
9246 return arg_.Get(index);
9247}
9248inline const ::caffe2::Argument& OperatorDef::arg(int index) const {
9249 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.arg)
9250 return _internal_arg(index);
9251}
9252inline ::caffe2::Argument* OperatorDef::_internal_add_arg() {
9253 return arg_.Add();
9254}
9255inline ::caffe2::Argument* OperatorDef::add_arg() {
9256 // @@protoc_insertion_point(field_add:caffe2.OperatorDef.arg)
9257 return _internal_add_arg();
9258}
9259inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >&
9260OperatorDef::arg() const {
9261 // @@protoc_insertion_point(field_list:caffe2.OperatorDef.arg)
9262 return arg_;
9263}
9264
9265// optional .caffe2.DeviceOption device_option = 6;
9266inline bool OperatorDef::_internal_has_device_option() const {
9267 bool value = (_has_bits_[0] & 0x00000020u) != 0;
9268 PROTOBUF_ASSUME(!value || device_option_ != nullptr);
9269 return value;
9270}
9271inline bool OperatorDef::has_device_option() const {
9272 return _internal_has_device_option();
9273}
9274inline void OperatorDef::clear_device_option() {
9275 if (device_option_ != nullptr) device_option_->Clear();
9276 _has_bits_[0] &= ~0x00000020u;
9277}
9278inline const ::caffe2::DeviceOption& OperatorDef::_internal_device_option() const {
9279 const ::caffe2::DeviceOption* p = device_option_;
9280 return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::DeviceOption*>(
9281 &::caffe2::_DeviceOption_default_instance_);
9282}
9283inline const ::caffe2::DeviceOption& OperatorDef::device_option() const {
9284 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.device_option)
9285 return _internal_device_option();
9286}
9287inline void OperatorDef::unsafe_arena_set_allocated_device_option(
9288 ::caffe2::DeviceOption* device_option) {
9289 if (GetArena() == nullptr) {
9290 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_option_);
9291 }
9292 device_option_ = device_option;
9293 if (device_option) {
9294 _has_bits_[0] |= 0x00000020u;
9295 } else {
9296 _has_bits_[0] &= ~0x00000020u;
9297 }
9298 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.OperatorDef.device_option)
9299}
9300inline ::caffe2::DeviceOption* OperatorDef::release_device_option() {
9301 _has_bits_[0] &= ~0x00000020u;
9302 ::caffe2::DeviceOption* temp = device_option_;
9303 device_option_ = nullptr;
9304 if (GetArena() != nullptr) {
9305 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
9306 }
9307 return temp;
9308}
9309inline ::caffe2::DeviceOption* OperatorDef::unsafe_arena_release_device_option() {
9310 // @@protoc_insertion_point(field_release:caffe2.OperatorDef.device_option)
9311 _has_bits_[0] &= ~0x00000020u;
9312 ::caffe2::DeviceOption* temp = device_option_;
9313 device_option_ = nullptr;
9314 return temp;
9315}
9316inline ::caffe2::DeviceOption* OperatorDef::_internal_mutable_device_option() {
9317 _has_bits_[0] |= 0x00000020u;
9318 if (device_option_ == nullptr) {
9319 auto* p = CreateMaybeMessage<::caffe2::DeviceOption>(GetArena());
9320 device_option_ = p;
9321 }
9322 return device_option_;
9323}
9324inline ::caffe2::DeviceOption* OperatorDef::mutable_device_option() {
9325 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.device_option)
9326 return _internal_mutable_device_option();
9327}
9328inline void OperatorDef::set_allocated_device_option(::caffe2::DeviceOption* device_option) {
9329 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
9330 if (message_arena == nullptr) {
9331 delete device_option_;
9332 }
9333 if (device_option) {
9334 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
9335 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(device_option);
9336 if (message_arena != submessage_arena) {
9337 device_option = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
9338 message_arena, device_option, submessage_arena);
9339 }
9340 _has_bits_[0] |= 0x00000020u;
9341 } else {
9342 _has_bits_[0] &= ~0x00000020u;
9343 }
9344 device_option_ = device_option;
9345 // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.device_option)
9346}
9347
9348// optional string engine = 7;
9349inline bool OperatorDef::_internal_has_engine() const {
9350 bool value = (_has_bits_[0] & 0x00000004u) != 0;
9351 return value;
9352}
9353inline bool OperatorDef::has_engine() const {
9354 return _internal_has_engine();
9355}
9356inline void OperatorDef::clear_engine() {
9357 engine_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
9358 _has_bits_[0] &= ~0x00000004u;
9359}
9360inline const std::string& OperatorDef::engine() const {
9361 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.engine)
9362 return _internal_engine();
9363}
9364inline void OperatorDef::set_engine(const std::string& value) {
9365 _internal_set_engine(value);
9366 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.engine)
9367}
9368inline std::string* OperatorDef::mutable_engine() {
9369 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.engine)
9370 return _internal_mutable_engine();
9371}
9372inline const std::string& OperatorDef::_internal_engine() const {
9373 return engine_.Get();
9374}
9375inline void OperatorDef::_internal_set_engine(const std::string& value) {
9376 _has_bits_[0] |= 0x00000004u;
9377 engine_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
9378}
9379inline void OperatorDef::set_engine(std::string&& value) {
9380 _has_bits_[0] |= 0x00000004u;
9381 engine_.Set(
9382 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
9383 // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.engine)
9384}
9385inline void OperatorDef::set_engine(const char* value) {
9386 GOOGLE_DCHECK(value != nullptr);
9387 _has_bits_[0] |= 0x00000004u;
9388 engine_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
9389 GetArena());
9390 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.engine)
9391}
9392inline void OperatorDef::set_engine(const char* value,
9393 size_t size) {
9394 _has_bits_[0] |= 0x00000004u;
9395 engine_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
9396 reinterpret_cast<const char*>(value), size), GetArena());
9397 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.engine)
9398}
9399inline std::string* OperatorDef::_internal_mutable_engine() {
9400 _has_bits_[0] |= 0x00000004u;
9401 return engine_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
9402}
9403inline std::string* OperatorDef::release_engine() {
9404 // @@protoc_insertion_point(field_release:caffe2.OperatorDef.engine)
9405 if (!_internal_has_engine()) {
9406 return nullptr;
9407 }
9408 _has_bits_[0] &= ~0x00000004u;
9409 return engine_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
9410}
9411inline void OperatorDef::set_allocated_engine(std::string* engine) {
9412 if (engine != nullptr) {
9413 _has_bits_[0] |= 0x00000004u;
9414 } else {
9415 _has_bits_[0] &= ~0x00000004u;
9416 }
9417 engine_.SetAllocated(&GetEmptyStringAlreadyInited(), engine,
9418 GetArena());
9419 // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.engine)
9420}
9421
9422// repeated string control_input = 8;
9423inline int OperatorDef::_internal_control_input_size() const {
9424 return control_input_.size();
9425}
9426inline int OperatorDef::control_input_size() const {
9427 return _internal_control_input_size();
9428}
9429inline void OperatorDef::clear_control_input() {
9430 control_input_.Clear();
9431}
9432inline std::string* OperatorDef::add_control_input() {
9433 // @@protoc_insertion_point(field_add_mutable:caffe2.OperatorDef.control_input)
9434 return _internal_add_control_input();
9435}
9436inline const std::string& OperatorDef::_internal_control_input(int index) const {
9437 return control_input_.Get(index);
9438}
9439inline const std::string& OperatorDef::control_input(int index) const {
9440 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.control_input)
9441 return _internal_control_input(index);
9442}
9443inline std::string* OperatorDef::mutable_control_input(int index) {
9444 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.control_input)
9445 return control_input_.Mutable(index);
9446}
9447inline void OperatorDef::set_control_input(int index, const std::string& value) {
9448 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.control_input)
9449 control_input_.Mutable(index)->assign(value);
9450}
9451inline void OperatorDef::set_control_input(int index, std::string&& value) {
9452 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.control_input)
9453 control_input_.Mutable(index)->assign(std::move(value));
9454}
9455inline void OperatorDef::set_control_input(int index, const char* value) {
9456 GOOGLE_DCHECK(value != nullptr);
9457 control_input_.Mutable(index)->assign(value);
9458 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.control_input)
9459}
9460inline void OperatorDef::set_control_input(int index, const char* value, size_t size) {
9461 control_input_.Mutable(index)->assign(
9462 reinterpret_cast<const char*>(value), size);
9463 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.control_input)
9464}
9465inline std::string* OperatorDef::_internal_add_control_input() {
9466 return control_input_.Add();
9467}
9468inline void OperatorDef::add_control_input(const std::string& value) {
9469 control_input_.Add()->assign(value);
9470 // @@protoc_insertion_point(field_add:caffe2.OperatorDef.control_input)
9471}
9472inline void OperatorDef::add_control_input(std::string&& value) {
9473 control_input_.Add(std::move(value));
9474 // @@protoc_insertion_point(field_add:caffe2.OperatorDef.control_input)
9475}
9476inline void OperatorDef::add_control_input(const char* value) {
9477 GOOGLE_DCHECK(value != nullptr);
9478 control_input_.Add()->assign(value);
9479 // @@protoc_insertion_point(field_add_char:caffe2.OperatorDef.control_input)
9480}
9481inline void OperatorDef::add_control_input(const char* value, size_t size) {
9482 control_input_.Add()->assign(reinterpret_cast<const char*>(value), size);
9483 // @@protoc_insertion_point(field_add_pointer:caffe2.OperatorDef.control_input)
9484}
9485inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
9486OperatorDef::control_input() const {
9487 // @@protoc_insertion_point(field_list:caffe2.OperatorDef.control_input)
9488 return control_input_;
9489}
9490inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
9491OperatorDef::mutable_control_input() {
9492 // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.control_input)
9493 return &control_input_;
9494}
9495
9496// optional bool is_gradient_op = 9 [default = false];
9497inline bool OperatorDef::_internal_has_is_gradient_op() const {
9498 bool value = (_has_bits_[0] & 0x00000080u) != 0;
9499 return value;
9500}
9501inline bool OperatorDef::has_is_gradient_op() const {
9502 return _internal_has_is_gradient_op();
9503}
9504inline void OperatorDef::clear_is_gradient_op() {
9505 is_gradient_op_ = false;
9506 _has_bits_[0] &= ~0x00000080u;
9507}
9508inline bool OperatorDef::_internal_is_gradient_op() const {
9509 return is_gradient_op_;
9510}
9511inline bool OperatorDef::is_gradient_op() const {
9512 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.is_gradient_op)
9513 return _internal_is_gradient_op();
9514}
9515inline void OperatorDef::_internal_set_is_gradient_op(bool value) {
9516 _has_bits_[0] |= 0x00000080u;
9517 is_gradient_op_ = value;
9518}
9519inline void OperatorDef::set_is_gradient_op(bool value) {
9520 _internal_set_is_gradient_op(value);
9521 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.is_gradient_op)
9522}
9523
9524// optional string debug_info = 10;
9525inline bool OperatorDef::_internal_has_debug_info() const {
9526 bool value = (_has_bits_[0] & 0x00000008u) != 0;
9527 return value;
9528}
9529inline bool OperatorDef::has_debug_info() const {
9530 return _internal_has_debug_info();
9531}
9532inline void OperatorDef::clear_debug_info() {
9533 debug_info_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
9534 _has_bits_[0] &= ~0x00000008u;
9535}
9536inline const std::string& OperatorDef::debug_info() const {
9537 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.debug_info)
9538 return _internal_debug_info();
9539}
9540inline void OperatorDef::set_debug_info(const std::string& value) {
9541 _internal_set_debug_info(value);
9542 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.debug_info)
9543}
9544inline std::string* OperatorDef::mutable_debug_info() {
9545 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.debug_info)
9546 return _internal_mutable_debug_info();
9547}
9548inline const std::string& OperatorDef::_internal_debug_info() const {
9549 return debug_info_.Get();
9550}
9551inline void OperatorDef::_internal_set_debug_info(const std::string& value) {
9552 _has_bits_[0] |= 0x00000008u;
9553 debug_info_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
9554}
9555inline void OperatorDef::set_debug_info(std::string&& value) {
9556 _has_bits_[0] |= 0x00000008u;
9557 debug_info_.Set(
9558 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
9559 // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.debug_info)
9560}
9561inline void OperatorDef::set_debug_info(const char* value) {
9562 GOOGLE_DCHECK(value != nullptr);
9563 _has_bits_[0] |= 0x00000008u;
9564 debug_info_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
9565 GetArena());
9566 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.debug_info)
9567}
9568inline void OperatorDef::set_debug_info(const char* value,
9569 size_t size) {
9570 _has_bits_[0] |= 0x00000008u;
9571 debug_info_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
9572 reinterpret_cast<const char*>(value), size), GetArena());
9573 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.debug_info)
9574}
9575inline std::string* OperatorDef::_internal_mutable_debug_info() {
9576 _has_bits_[0] |= 0x00000008u;
9577 return debug_info_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
9578}
9579inline std::string* OperatorDef::release_debug_info() {
9580 // @@protoc_insertion_point(field_release:caffe2.OperatorDef.debug_info)
9581 if (!_internal_has_debug_info()) {
9582 return nullptr;
9583 }
9584 _has_bits_[0] &= ~0x00000008u;
9585 return debug_info_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
9586}
9587inline void OperatorDef::set_allocated_debug_info(std::string* debug_info) {
9588 if (debug_info != nullptr) {
9589 _has_bits_[0] |= 0x00000008u;
9590 } else {
9591 _has_bits_[0] &= ~0x00000008u;
9592 }
9593 debug_info_.SetAllocated(&GetEmptyStringAlreadyInited(), debug_info,
9594 GetArena());
9595 // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.debug_info)
9596}
9597
9598// optional string domain = 11;
9599inline bool OperatorDef::_internal_has_domain() const {
9600 bool value = (_has_bits_[0] & 0x00000010u) != 0;
9601 return value;
9602}
9603inline bool OperatorDef::has_domain() const {
9604 return _internal_has_domain();
9605}
9606inline void OperatorDef::clear_domain() {
9607 domain_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
9608 _has_bits_[0] &= ~0x00000010u;
9609}
9610inline const std::string& OperatorDef::domain() const {
9611 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.domain)
9612 return _internal_domain();
9613}
9614inline void OperatorDef::set_domain(const std::string& value) {
9615 _internal_set_domain(value);
9616 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.domain)
9617}
9618inline std::string* OperatorDef::mutable_domain() {
9619 // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.domain)
9620 return _internal_mutable_domain();
9621}
9622inline const std::string& OperatorDef::_internal_domain() const {
9623 return domain_.Get();
9624}
9625inline void OperatorDef::_internal_set_domain(const std::string& value) {
9626 _has_bits_[0] |= 0x00000010u;
9627 domain_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
9628}
9629inline void OperatorDef::set_domain(std::string&& value) {
9630 _has_bits_[0] |= 0x00000010u;
9631 domain_.Set(
9632 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
9633 // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.domain)
9634}
9635inline void OperatorDef::set_domain(const char* value) {
9636 GOOGLE_DCHECK(value != nullptr);
9637 _has_bits_[0] |= 0x00000010u;
9638 domain_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
9639 GetArena());
9640 // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.domain)
9641}
9642inline void OperatorDef::set_domain(const char* value,
9643 size_t size) {
9644 _has_bits_[0] |= 0x00000010u;
9645 domain_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
9646 reinterpret_cast<const char*>(value), size), GetArena());
9647 // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.domain)
9648}
9649inline std::string* OperatorDef::_internal_mutable_domain() {
9650 _has_bits_[0] |= 0x00000010u;
9651 return domain_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
9652}
9653inline std::string* OperatorDef::release_domain() {
9654 // @@protoc_insertion_point(field_release:caffe2.OperatorDef.domain)
9655 if (!_internal_has_domain()) {
9656 return nullptr;
9657 }
9658 _has_bits_[0] &= ~0x00000010u;
9659 return domain_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
9660}
9661inline void OperatorDef::set_allocated_domain(std::string* domain) {
9662 if (domain != nullptr) {
9663 _has_bits_[0] |= 0x00000010u;
9664 } else {
9665 _has_bits_[0] &= ~0x00000010u;
9666 }
9667 domain_.SetAllocated(&GetEmptyStringAlreadyInited(), domain,
9668 GetArena());
9669 // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.domain)
9670}
9671
9672// optional int64 op_version = 12;
9673inline bool OperatorDef::_internal_has_op_version() const {
9674 bool value = (_has_bits_[0] & 0x00000040u) != 0;
9675 return value;
9676}
9677inline bool OperatorDef::has_op_version() const {
9678 return _internal_has_op_version();
9679}
9680inline void OperatorDef::clear_op_version() {
9681 op_version_ = PROTOBUF_LONGLONG(0);
9682 _has_bits_[0] &= ~0x00000040u;
9683}
9684inline ::PROTOBUF_NAMESPACE_ID::int64 OperatorDef::_internal_op_version() const {
9685 return op_version_;
9686}
9687inline ::PROTOBUF_NAMESPACE_ID::int64 OperatorDef::op_version() const {
9688 // @@protoc_insertion_point(field_get:caffe2.OperatorDef.op_version)
9689 return _internal_op_version();
9690}
9691inline void OperatorDef::_internal_set_op_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
9692 _has_bits_[0] |= 0x00000040u;
9693 op_version_ = value;
9694}
9695inline void OperatorDef::set_op_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
9696 _internal_set_op_version(value);
9697 // @@protoc_insertion_point(field_set:caffe2.OperatorDef.op_version)
9698}
9699
9700// -------------------------------------------------------------------
9701
9702// MapFieldEntry
9703
9704// required string key = 1;
9705inline bool MapFieldEntry::_internal_has_key() const {
9706 bool value = (_has_bits_[0] & 0x00000001u) != 0;
9707 return value;
9708}
9709inline bool MapFieldEntry::has_key() const {
9710 return _internal_has_key();
9711}
9712inline void MapFieldEntry::clear_key() {
9713 key_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
9714 _has_bits_[0] &= ~0x00000001u;
9715}
9716inline const std::string& MapFieldEntry::key() const {
9717 // @@protoc_insertion_point(field_get:caffe2.MapFieldEntry.key)
9718 return _internal_key();
9719}
9720inline void MapFieldEntry::set_key(const std::string& value) {
9721 _internal_set_key(value);
9722 // @@protoc_insertion_point(field_set:caffe2.MapFieldEntry.key)
9723}
9724inline std::string* MapFieldEntry::mutable_key() {
9725 // @@protoc_insertion_point(field_mutable:caffe2.MapFieldEntry.key)
9726 return _internal_mutable_key();
9727}
9728inline const std::string& MapFieldEntry::_internal_key() const {
9729 return key_.Get();
9730}
9731inline void MapFieldEntry::_internal_set_key(const std::string& value) {
9732 _has_bits_[0] |= 0x00000001u;
9733 key_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
9734}
9735inline void MapFieldEntry::set_key(std::string&& value) {
9736 _has_bits_[0] |= 0x00000001u;
9737 key_.Set(
9738 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
9739 // @@protoc_insertion_point(field_set_rvalue:caffe2.MapFieldEntry.key)
9740}
9741inline void MapFieldEntry::set_key(const char* value) {
9742 GOOGLE_DCHECK(value != nullptr);
9743 _has_bits_[0] |= 0x00000001u;
9744 key_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
9745 GetArena());
9746 // @@protoc_insertion_point(field_set_char:caffe2.MapFieldEntry.key)
9747}
9748inline void MapFieldEntry::set_key(const char* value,
9749 size_t size) {
9750 _has_bits_[0] |= 0x00000001u;
9751 key_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
9752 reinterpret_cast<const char*>(value), size), GetArena());
9753 // @@protoc_insertion_point(field_set_pointer:caffe2.MapFieldEntry.key)
9754}
9755inline std::string* MapFieldEntry::_internal_mutable_key() {
9756 _has_bits_[0] |= 0x00000001u;
9757 return key_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
9758}
9759inline std::string* MapFieldEntry::release_key() {
9760 // @@protoc_insertion_point(field_release:caffe2.MapFieldEntry.key)
9761 if (!_internal_has_key()) {
9762 return nullptr;
9763 }
9764 _has_bits_[0] &= ~0x00000001u;
9765 return key_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
9766}
9767inline void MapFieldEntry::set_allocated_key(std::string* key) {
9768 if (key != nullptr) {
9769 _has_bits_[0] |= 0x00000001u;
9770 } else {
9771 _has_bits_[0] &= ~0x00000001u;
9772 }
9773 key_.SetAllocated(&GetEmptyStringAlreadyInited(), key,
9774 GetArena());
9775 // @@protoc_insertion_point(field_set_allocated:caffe2.MapFieldEntry.key)
9776}
9777
9778// required string val = 2;
9779inline bool MapFieldEntry::_internal_has_val() const {
9780 bool value = (_has_bits_[0] & 0x00000002u) != 0;
9781 return value;
9782}
9783inline bool MapFieldEntry::has_val() const {
9784 return _internal_has_val();
9785}
9786inline void MapFieldEntry::clear_val() {
9787 val_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
9788 _has_bits_[0] &= ~0x00000002u;
9789}
9790inline const std::string& MapFieldEntry::val() const {
9791 // @@protoc_insertion_point(field_get:caffe2.MapFieldEntry.val)
9792 return _internal_val();
9793}
9794inline void MapFieldEntry::set_val(const std::string& value) {
9795 _internal_set_val(value);
9796 // @@protoc_insertion_point(field_set:caffe2.MapFieldEntry.val)
9797}
9798inline std::string* MapFieldEntry::mutable_val() {
9799 // @@protoc_insertion_point(field_mutable:caffe2.MapFieldEntry.val)
9800 return _internal_mutable_val();
9801}
9802inline const std::string& MapFieldEntry::_internal_val() const {
9803 return val_.Get();
9804}
9805inline void MapFieldEntry::_internal_set_val(const std::string& value) {
9806 _has_bits_[0] |= 0x00000002u;
9807 val_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
9808}
9809inline void MapFieldEntry::set_val(std::string&& value) {
9810 _has_bits_[0] |= 0x00000002u;
9811 val_.Set(
9812 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
9813 // @@protoc_insertion_point(field_set_rvalue:caffe2.MapFieldEntry.val)
9814}
9815inline void MapFieldEntry::set_val(const char* value) {
9816 GOOGLE_DCHECK(value != nullptr);
9817 _has_bits_[0] |= 0x00000002u;
9818 val_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
9819 GetArena());
9820 // @@protoc_insertion_point(field_set_char:caffe2.MapFieldEntry.val)
9821}
9822inline void MapFieldEntry::set_val(const char* value,
9823 size_t size) {
9824 _has_bits_[0] |= 0x00000002u;
9825 val_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
9826 reinterpret_cast<const char*>(value), size), GetArena());
9827 // @@protoc_insertion_point(field_set_pointer:caffe2.MapFieldEntry.val)
9828}
9829inline std::string* MapFieldEntry::_internal_mutable_val() {
9830 _has_bits_[0] |= 0x00000002u;
9831 return val_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
9832}
9833inline std::string* MapFieldEntry::release_val() {
9834 // @@protoc_insertion_point(field_release:caffe2.MapFieldEntry.val)
9835 if (!_internal_has_val()) {
9836 return nullptr;
9837 }
9838 _has_bits_[0] &= ~0x00000002u;
9839 return val_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
9840}
9841inline void MapFieldEntry::set_allocated_val(std::string* val) {
9842 if (val != nullptr) {
9843 _has_bits_[0] |= 0x00000002u;
9844 } else {
9845 _has_bits_[0] &= ~0x00000002u;
9846 }
9847 val_.SetAllocated(&GetEmptyStringAlreadyInited(), val,
9848 GetArena());
9849 // @@protoc_insertion_point(field_set_allocated:caffe2.MapFieldEntry.val)
9850}
9851
9852// -------------------------------------------------------------------
9853
9854// BackendOptions
9855
9856// required string backend_name = 1;
9857inline bool BackendOptions::_internal_has_backend_name() const {
9858 bool value = (_has_bits_[0] & 0x00000001u) != 0;
9859 return value;
9860}
9861inline bool BackendOptions::has_backend_name() const {
9862 return _internal_has_backend_name();
9863}
9864inline void BackendOptions::clear_backend_name() {
9865 backend_name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
9866 _has_bits_[0] &= ~0x00000001u;
9867}
9868inline const std::string& BackendOptions::backend_name() const {
9869 // @@protoc_insertion_point(field_get:caffe2.BackendOptions.backend_name)
9870 return _internal_backend_name();
9871}
9872inline void BackendOptions::set_backend_name(const std::string& value) {
9873 _internal_set_backend_name(value);
9874 // @@protoc_insertion_point(field_set:caffe2.BackendOptions.backend_name)
9875}
9876inline std::string* BackendOptions::mutable_backend_name() {
9877 // @@protoc_insertion_point(field_mutable:caffe2.BackendOptions.backend_name)
9878 return _internal_mutable_backend_name();
9879}
9880inline const std::string& BackendOptions::_internal_backend_name() const {
9881 return backend_name_.Get();
9882}
9883inline void BackendOptions::_internal_set_backend_name(const std::string& value) {
9884 _has_bits_[0] |= 0x00000001u;
9885 backend_name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
9886}
9887inline void BackendOptions::set_backend_name(std::string&& value) {
9888 _has_bits_[0] |= 0x00000001u;
9889 backend_name_.Set(
9890 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
9891 // @@protoc_insertion_point(field_set_rvalue:caffe2.BackendOptions.backend_name)
9892}
9893inline void BackendOptions::set_backend_name(const char* value) {
9894 GOOGLE_DCHECK(value != nullptr);
9895 _has_bits_[0] |= 0x00000001u;
9896 backend_name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
9897 GetArena());
9898 // @@protoc_insertion_point(field_set_char:caffe2.BackendOptions.backend_name)
9899}
9900inline void BackendOptions::set_backend_name(const char* value,
9901 size_t size) {
9902 _has_bits_[0] |= 0x00000001u;
9903 backend_name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
9904 reinterpret_cast<const char*>(value), size), GetArena());
9905 // @@protoc_insertion_point(field_set_pointer:caffe2.BackendOptions.backend_name)
9906}
9907inline std::string* BackendOptions::_internal_mutable_backend_name() {
9908 _has_bits_[0] |= 0x00000001u;
9909 return backend_name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
9910}
9911inline std::string* BackendOptions::release_backend_name() {
9912 // @@protoc_insertion_point(field_release:caffe2.BackendOptions.backend_name)
9913 if (!_internal_has_backend_name()) {
9914 return nullptr;
9915 }
9916 _has_bits_[0] &= ~0x00000001u;
9917 return backend_name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
9918}
9919inline void BackendOptions::set_allocated_backend_name(std::string* backend_name) {
9920 if (backend_name != nullptr) {
9921 _has_bits_[0] |= 0x00000001u;
9922 } else {
9923 _has_bits_[0] &= ~0x00000001u;
9924 }
9925 backend_name_.SetAllocated(&GetEmptyStringAlreadyInited(), backend_name,
9926 GetArena());
9927 // @@protoc_insertion_point(field_set_allocated:caffe2.BackendOptions.backend_name)
9928}
9929
9930// repeated .caffe2.MapFieldEntry option = 2;
9931inline int BackendOptions::_internal_option_size() const {
9932 return option_.size();
9933}
9934inline int BackendOptions::option_size() const {
9935 return _internal_option_size();
9936}
9937inline void BackendOptions::clear_option() {
9938 option_.Clear();
9939}
9940inline ::caffe2::MapFieldEntry* BackendOptions::mutable_option(int index) {
9941 // @@protoc_insertion_point(field_mutable:caffe2.BackendOptions.option)
9942 return option_.Mutable(index);
9943}
9944inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry >*
9945BackendOptions::mutable_option() {
9946 // @@protoc_insertion_point(field_mutable_list:caffe2.BackendOptions.option)
9947 return &option_;
9948}
9949inline const ::caffe2::MapFieldEntry& BackendOptions::_internal_option(int index) const {
9950 return option_.Get(index);
9951}
9952inline const ::caffe2::MapFieldEntry& BackendOptions::option(int index) const {
9953 // @@protoc_insertion_point(field_get:caffe2.BackendOptions.option)
9954 return _internal_option(index);
9955}
9956inline ::caffe2::MapFieldEntry* BackendOptions::_internal_add_option() {
9957 return option_.Add();
9958}
9959inline ::caffe2::MapFieldEntry* BackendOptions::add_option() {
9960 // @@protoc_insertion_point(field_add:caffe2.BackendOptions.option)
9961 return _internal_add_option();
9962}
9963inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry >&
9964BackendOptions::option() const {
9965 // @@protoc_insertion_point(field_list:caffe2.BackendOptions.option)
9966 return option_;
9967}
9968
9969// -------------------------------------------------------------------
9970
9971// PartitionInfo
9972
9973// required string name = 1;
9974inline bool PartitionInfo::_internal_has_name() const {
9975 bool value = (_has_bits_[0] & 0x00000001u) != 0;
9976 return value;
9977}
9978inline bool PartitionInfo::has_name() const {
9979 return _internal_has_name();
9980}
9981inline void PartitionInfo::clear_name() {
9982 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
9983 _has_bits_[0] &= ~0x00000001u;
9984}
9985inline const std::string& PartitionInfo::name() const {
9986 // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.name)
9987 return _internal_name();
9988}
9989inline void PartitionInfo::set_name(const std::string& value) {
9990 _internal_set_name(value);
9991 // @@protoc_insertion_point(field_set:caffe2.PartitionInfo.name)
9992}
9993inline std::string* PartitionInfo::mutable_name() {
9994 // @@protoc_insertion_point(field_mutable:caffe2.PartitionInfo.name)
9995 return _internal_mutable_name();
9996}
9997inline const std::string& PartitionInfo::_internal_name() const {
9998 return name_.Get();
9999}
10000inline void PartitionInfo::_internal_set_name(const std::string& value) {
10001 _has_bits_[0] |= 0x00000001u;
10002 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
10003}
10004inline void PartitionInfo::set_name(std::string&& value) {
10005 _has_bits_[0] |= 0x00000001u;
10006 name_.Set(
10007 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
10008 // @@protoc_insertion_point(field_set_rvalue:caffe2.PartitionInfo.name)
10009}
10010inline void PartitionInfo::set_name(const char* value) {
10011 GOOGLE_DCHECK(value != nullptr);
10012 _has_bits_[0] |= 0x00000001u;
10013 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
10014 GetArena());
10015 // @@protoc_insertion_point(field_set_char:caffe2.PartitionInfo.name)
10016}
10017inline void PartitionInfo::set_name(const char* value,
10018 size_t size) {
10019 _has_bits_[0] |= 0x00000001u;
10020 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
10021 reinterpret_cast<const char*>(value), size), GetArena());
10022 // @@protoc_insertion_point(field_set_pointer:caffe2.PartitionInfo.name)
10023}
10024inline std::string* PartitionInfo::_internal_mutable_name() {
10025 _has_bits_[0] |= 0x00000001u;
10026 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
10027}
10028inline std::string* PartitionInfo::release_name() {
10029 // @@protoc_insertion_point(field_release:caffe2.PartitionInfo.name)
10030 if (!_internal_has_name()) {
10031 return nullptr;
10032 }
10033 _has_bits_[0] &= ~0x00000001u;
10034 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
10035}
10036inline void PartitionInfo::set_allocated_name(std::string* name) {
10037 if (name != nullptr) {
10038 _has_bits_[0] |= 0x00000001u;
10039 } else {
10040 _has_bits_[0] &= ~0x00000001u;
10041 }
10042 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
10043 GetArena());
10044 // @@protoc_insertion_point(field_set_allocated:caffe2.PartitionInfo.name)
10045}
10046
10047// repeated int32 device_id = 2;
10048inline int PartitionInfo::_internal_device_id_size() const {
10049 return device_id_.size();
10050}
10051inline int PartitionInfo::device_id_size() const {
10052 return _internal_device_id_size();
10053}
10054inline void PartitionInfo::clear_device_id() {
10055 device_id_.Clear();
10056}
10057inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionInfo::_internal_device_id(int index) const {
10058 return device_id_.Get(index);
10059}
10060inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionInfo::device_id(int index) const {
10061 // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.device_id)
10062 return _internal_device_id(index);
10063}
10064inline void PartitionInfo::set_device_id(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
10065 device_id_.Set(index, value);
10066 // @@protoc_insertion_point(field_set:caffe2.PartitionInfo.device_id)
10067}
10068inline void PartitionInfo::_internal_add_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
10069 device_id_.Add(value);
10070}
10071inline void PartitionInfo::add_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
10072 _internal_add_device_id(value);
10073 // @@protoc_insertion_point(field_add:caffe2.PartitionInfo.device_id)
10074}
10075inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
10076PartitionInfo::_internal_device_id() const {
10077 return device_id_;
10078}
10079inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
10080PartitionInfo::device_id() const {
10081 // @@protoc_insertion_point(field_list:caffe2.PartitionInfo.device_id)
10082 return _internal_device_id();
10083}
10084inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
10085PartitionInfo::_internal_mutable_device_id() {
10086 return &device_id_;
10087}
10088inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
10089PartitionInfo::mutable_device_id() {
10090 // @@protoc_insertion_point(field_mutable_list:caffe2.PartitionInfo.device_id)
10091 return _internal_mutable_device_id();
10092}
10093
10094// optional string extra_info = 3;
10095inline bool PartitionInfo::_internal_has_extra_info() const {
10096 bool value = (_has_bits_[0] & 0x00000002u) != 0;
10097 return value;
10098}
10099inline bool PartitionInfo::has_extra_info() const {
10100 return _internal_has_extra_info();
10101}
10102inline void PartitionInfo::clear_extra_info() {
10103 extra_info_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
10104 _has_bits_[0] &= ~0x00000002u;
10105}
10106inline const std::string& PartitionInfo::extra_info() const {
10107 // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.extra_info)
10108 return _internal_extra_info();
10109}
10110inline void PartitionInfo::set_extra_info(const std::string& value) {
10111 _internal_set_extra_info(value);
10112 // @@protoc_insertion_point(field_set:caffe2.PartitionInfo.extra_info)
10113}
10114inline std::string* PartitionInfo::mutable_extra_info() {
10115 // @@protoc_insertion_point(field_mutable:caffe2.PartitionInfo.extra_info)
10116 return _internal_mutable_extra_info();
10117}
10118inline const std::string& PartitionInfo::_internal_extra_info() const {
10119 return extra_info_.Get();
10120}
10121inline void PartitionInfo::_internal_set_extra_info(const std::string& value) {
10122 _has_bits_[0] |= 0x00000002u;
10123 extra_info_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
10124}
10125inline void PartitionInfo::set_extra_info(std::string&& value) {
10126 _has_bits_[0] |= 0x00000002u;
10127 extra_info_.Set(
10128 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
10129 // @@protoc_insertion_point(field_set_rvalue:caffe2.PartitionInfo.extra_info)
10130}
10131inline void PartitionInfo::set_extra_info(const char* value) {
10132 GOOGLE_DCHECK(value != nullptr);
10133 _has_bits_[0] |= 0x00000002u;
10134 extra_info_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
10135 GetArena());
10136 // @@protoc_insertion_point(field_set_char:caffe2.PartitionInfo.extra_info)
10137}
10138inline void PartitionInfo::set_extra_info(const char* value,
10139 size_t size) {
10140 _has_bits_[0] |= 0x00000002u;
10141 extra_info_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
10142 reinterpret_cast<const char*>(value), size), GetArena());
10143 // @@protoc_insertion_point(field_set_pointer:caffe2.PartitionInfo.extra_info)
10144}
10145inline std::string* PartitionInfo::_internal_mutable_extra_info() {
10146 _has_bits_[0] |= 0x00000002u;
10147 return extra_info_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
10148}
10149inline std::string* PartitionInfo::release_extra_info() {
10150 // @@protoc_insertion_point(field_release:caffe2.PartitionInfo.extra_info)
10151 if (!_internal_has_extra_info()) {
10152 return nullptr;
10153 }
10154 _has_bits_[0] &= ~0x00000002u;
10155 return extra_info_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
10156}
10157inline void PartitionInfo::set_allocated_extra_info(std::string* extra_info) {
10158 if (extra_info != nullptr) {
10159 _has_bits_[0] |= 0x00000002u;
10160 } else {
10161 _has_bits_[0] &= ~0x00000002u;
10162 }
10163 extra_info_.SetAllocated(&GetEmptyStringAlreadyInited(), extra_info,
10164 GetArena());
10165 // @@protoc_insertion_point(field_set_allocated:caffe2.PartitionInfo.extra_info)
10166}
10167
10168// repeated .caffe2.BackendOptions backend_options = 4;
10169inline int PartitionInfo::_internal_backend_options_size() const {
10170 return backend_options_.size();
10171}
10172inline int PartitionInfo::backend_options_size() const {
10173 return _internal_backend_options_size();
10174}
10175inline void PartitionInfo::clear_backend_options() {
10176 backend_options_.Clear();
10177}
10178inline ::caffe2::BackendOptions* PartitionInfo::mutable_backend_options(int index) {
10179 // @@protoc_insertion_point(field_mutable:caffe2.PartitionInfo.backend_options)
10180 return backend_options_.Mutable(index);
10181}
10182inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions >*
10183PartitionInfo::mutable_backend_options() {
10184 // @@protoc_insertion_point(field_mutable_list:caffe2.PartitionInfo.backend_options)
10185 return &backend_options_;
10186}
10187inline const ::caffe2::BackendOptions& PartitionInfo::_internal_backend_options(int index) const {
10188 return backend_options_.Get(index);
10189}
10190inline const ::caffe2::BackendOptions& PartitionInfo::backend_options(int index) const {
10191 // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.backend_options)
10192 return _internal_backend_options(index);
10193}
10194inline ::caffe2::BackendOptions* PartitionInfo::_internal_add_backend_options() {
10195 return backend_options_.Add();
10196}
10197inline ::caffe2::BackendOptions* PartitionInfo::add_backend_options() {
10198 // @@protoc_insertion_point(field_add:caffe2.PartitionInfo.backend_options)
10199 return _internal_add_backend_options();
10200}
10201inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions >&
10202PartitionInfo::backend_options() const {
10203 // @@protoc_insertion_point(field_list:caffe2.PartitionInfo.backend_options)
10204 return backend_options_;
10205}
10206
10207// -------------------------------------------------------------------
10208
10209// NetDef
10210
10211// optional string name = 1;
10212inline bool NetDef::_internal_has_name() const {
10213 bool value = (_has_bits_[0] & 0x00000001u) != 0;
10214 return value;
10215}
10216inline bool NetDef::has_name() const {
10217 return _internal_has_name();
10218}
10219inline void NetDef::clear_name() {
10220 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
10221 _has_bits_[0] &= ~0x00000001u;
10222}
10223inline const std::string& NetDef::name() const {
10224 // @@protoc_insertion_point(field_get:caffe2.NetDef.name)
10225 return _internal_name();
10226}
10227inline void NetDef::set_name(const std::string& value) {
10228 _internal_set_name(value);
10229 // @@protoc_insertion_point(field_set:caffe2.NetDef.name)
10230}
10231inline std::string* NetDef::mutable_name() {
10232 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.name)
10233 return _internal_mutable_name();
10234}
10235inline const std::string& NetDef::_internal_name() const {
10236 return name_.Get();
10237}
10238inline void NetDef::_internal_set_name(const std::string& value) {
10239 _has_bits_[0] |= 0x00000001u;
10240 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
10241}
10242inline void NetDef::set_name(std::string&& value) {
10243 _has_bits_[0] |= 0x00000001u;
10244 name_.Set(
10245 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
10246 // @@protoc_insertion_point(field_set_rvalue:caffe2.NetDef.name)
10247}
10248inline void NetDef::set_name(const char* value) {
10249 GOOGLE_DCHECK(value != nullptr);
10250 _has_bits_[0] |= 0x00000001u;
10251 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
10252 GetArena());
10253 // @@protoc_insertion_point(field_set_char:caffe2.NetDef.name)
10254}
10255inline void NetDef::set_name(const char* value,
10256 size_t size) {
10257 _has_bits_[0] |= 0x00000001u;
10258 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
10259 reinterpret_cast<const char*>(value), size), GetArena());
10260 // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.name)
10261}
10262inline std::string* NetDef::_internal_mutable_name() {
10263 _has_bits_[0] |= 0x00000001u;
10264 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
10265}
10266inline std::string* NetDef::release_name() {
10267 // @@protoc_insertion_point(field_release:caffe2.NetDef.name)
10268 if (!_internal_has_name()) {
10269 return nullptr;
10270 }
10271 _has_bits_[0] &= ~0x00000001u;
10272 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
10273}
10274inline void NetDef::set_allocated_name(std::string* name) {
10275 if (name != nullptr) {
10276 _has_bits_[0] |= 0x00000001u;
10277 } else {
10278 _has_bits_[0] &= ~0x00000001u;
10279 }
10280 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
10281 GetArena());
10282 // @@protoc_insertion_point(field_set_allocated:caffe2.NetDef.name)
10283}
10284
10285// repeated .caffe2.OperatorDef op = 2;
10286inline int NetDef::_internal_op_size() const {
10287 return op_.size();
10288}
10289inline int NetDef::op_size() const {
10290 return _internal_op_size();
10291}
10292inline void NetDef::clear_op() {
10293 op_.Clear();
10294}
10295inline ::caffe2::OperatorDef* NetDef::mutable_op(int index) {
10296 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.op)
10297 return op_.Mutable(index);
10298}
10299inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef >*
10300NetDef::mutable_op() {
10301 // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.op)
10302 return &op_;
10303}
10304inline const ::caffe2::OperatorDef& NetDef::_internal_op(int index) const {
10305 return op_.Get(index);
10306}
10307inline const ::caffe2::OperatorDef& NetDef::op(int index) const {
10308 // @@protoc_insertion_point(field_get:caffe2.NetDef.op)
10309 return _internal_op(index);
10310}
10311inline ::caffe2::OperatorDef* NetDef::_internal_add_op() {
10312 return op_.Add();
10313}
10314inline ::caffe2::OperatorDef* NetDef::add_op() {
10315 // @@protoc_insertion_point(field_add:caffe2.NetDef.op)
10316 return _internal_add_op();
10317}
10318inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef >&
10319NetDef::op() const {
10320 // @@protoc_insertion_point(field_list:caffe2.NetDef.op)
10321 return op_;
10322}
10323
10324// optional string type = 3;
10325inline bool NetDef::_internal_has_type() const {
10326 bool value = (_has_bits_[0] & 0x00000002u) != 0;
10327 return value;
10328}
10329inline bool NetDef::has_type() const {
10330 return _internal_has_type();
10331}
10332inline void NetDef::clear_type() {
10333 type_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
10334 _has_bits_[0] &= ~0x00000002u;
10335}
10336inline const std::string& NetDef::type() const {
10337 // @@protoc_insertion_point(field_get:caffe2.NetDef.type)
10338 return _internal_type();
10339}
10340inline void NetDef::set_type(const std::string& value) {
10341 _internal_set_type(value);
10342 // @@protoc_insertion_point(field_set:caffe2.NetDef.type)
10343}
10344inline std::string* NetDef::mutable_type() {
10345 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.type)
10346 return _internal_mutable_type();
10347}
10348inline const std::string& NetDef::_internal_type() const {
10349 return type_.Get();
10350}
10351inline void NetDef::_internal_set_type(const std::string& value) {
10352 _has_bits_[0] |= 0x00000002u;
10353 type_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
10354}
10355inline void NetDef::set_type(std::string&& value) {
10356 _has_bits_[0] |= 0x00000002u;
10357 type_.Set(
10358 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
10359 // @@protoc_insertion_point(field_set_rvalue:caffe2.NetDef.type)
10360}
10361inline void NetDef::set_type(const char* value) {
10362 GOOGLE_DCHECK(value != nullptr);
10363 _has_bits_[0] |= 0x00000002u;
10364 type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
10365 GetArena());
10366 // @@protoc_insertion_point(field_set_char:caffe2.NetDef.type)
10367}
10368inline void NetDef::set_type(const char* value,
10369 size_t size) {
10370 _has_bits_[0] |= 0x00000002u;
10371 type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
10372 reinterpret_cast<const char*>(value), size), GetArena());
10373 // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.type)
10374}
10375inline std::string* NetDef::_internal_mutable_type() {
10376 _has_bits_[0] |= 0x00000002u;
10377 return type_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
10378}
10379inline std::string* NetDef::release_type() {
10380 // @@protoc_insertion_point(field_release:caffe2.NetDef.type)
10381 if (!_internal_has_type()) {
10382 return nullptr;
10383 }
10384 _has_bits_[0] &= ~0x00000002u;
10385 return type_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
10386}
10387inline void NetDef::set_allocated_type(std::string* type) {
10388 if (type != nullptr) {
10389 _has_bits_[0] |= 0x00000002u;
10390 } else {
10391 _has_bits_[0] &= ~0x00000002u;
10392 }
10393 type_.SetAllocated(&GetEmptyStringAlreadyInited(), type,
10394 GetArena());
10395 // @@protoc_insertion_point(field_set_allocated:caffe2.NetDef.type)
10396}
10397
10398// optional int32 num_workers = 4;
10399inline bool NetDef::_internal_has_num_workers() const {
10400 bool value = (_has_bits_[0] & 0x00000008u) != 0;
10401 return value;
10402}
10403inline bool NetDef::has_num_workers() const {
10404 return _internal_has_num_workers();
10405}
10406inline void NetDef::clear_num_workers() {
10407 num_workers_ = 0;
10408 _has_bits_[0] &= ~0x00000008u;
10409}
10410inline ::PROTOBUF_NAMESPACE_ID::int32 NetDef::_internal_num_workers() const {
10411 return num_workers_;
10412}
10413inline ::PROTOBUF_NAMESPACE_ID::int32 NetDef::num_workers() const {
10414 // @@protoc_insertion_point(field_get:caffe2.NetDef.num_workers)
10415 return _internal_num_workers();
10416}
10417inline void NetDef::_internal_set_num_workers(::PROTOBUF_NAMESPACE_ID::int32 value) {
10418 _has_bits_[0] |= 0x00000008u;
10419 num_workers_ = value;
10420}
10421inline void NetDef::set_num_workers(::PROTOBUF_NAMESPACE_ID::int32 value) {
10422 _internal_set_num_workers(value);
10423 // @@protoc_insertion_point(field_set:caffe2.NetDef.num_workers)
10424}
10425
10426// optional .caffe2.DeviceOption device_option = 5;
10427inline bool NetDef::_internal_has_device_option() const {
10428 bool value = (_has_bits_[0] & 0x00000004u) != 0;
10429 PROTOBUF_ASSUME(!value || device_option_ != nullptr);
10430 return value;
10431}
10432inline bool NetDef::has_device_option() const {
10433 return _internal_has_device_option();
10434}
10435inline void NetDef::clear_device_option() {
10436 if (device_option_ != nullptr) device_option_->Clear();
10437 _has_bits_[0] &= ~0x00000004u;
10438}
10439inline const ::caffe2::DeviceOption& NetDef::_internal_device_option() const {
10440 const ::caffe2::DeviceOption* p = device_option_;
10441 return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::DeviceOption*>(
10442 &::caffe2::_DeviceOption_default_instance_);
10443}
10444inline const ::caffe2::DeviceOption& NetDef::device_option() const {
10445 // @@protoc_insertion_point(field_get:caffe2.NetDef.device_option)
10446 return _internal_device_option();
10447}
10448inline void NetDef::unsafe_arena_set_allocated_device_option(
10449 ::caffe2::DeviceOption* device_option) {
10450 if (GetArena() == nullptr) {
10451 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_option_);
10452 }
10453 device_option_ = device_option;
10454 if (device_option) {
10455 _has_bits_[0] |= 0x00000004u;
10456 } else {
10457 _has_bits_[0] &= ~0x00000004u;
10458 }
10459 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.NetDef.device_option)
10460}
10461inline ::caffe2::DeviceOption* NetDef::release_device_option() {
10462 _has_bits_[0] &= ~0x00000004u;
10463 ::caffe2::DeviceOption* temp = device_option_;
10464 device_option_ = nullptr;
10465 if (GetArena() != nullptr) {
10466 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
10467 }
10468 return temp;
10469}
10470inline ::caffe2::DeviceOption* NetDef::unsafe_arena_release_device_option() {
10471 // @@protoc_insertion_point(field_release:caffe2.NetDef.device_option)
10472 _has_bits_[0] &= ~0x00000004u;
10473 ::caffe2::DeviceOption* temp = device_option_;
10474 device_option_ = nullptr;
10475 return temp;
10476}
10477inline ::caffe2::DeviceOption* NetDef::_internal_mutable_device_option() {
10478 _has_bits_[0] |= 0x00000004u;
10479 if (device_option_ == nullptr) {
10480 auto* p = CreateMaybeMessage<::caffe2::DeviceOption>(GetArena());
10481 device_option_ = p;
10482 }
10483 return device_option_;
10484}
10485inline ::caffe2::DeviceOption* NetDef::mutable_device_option() {
10486 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.device_option)
10487 return _internal_mutable_device_option();
10488}
10489inline void NetDef::set_allocated_device_option(::caffe2::DeviceOption* device_option) {
10490 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
10491 if (message_arena == nullptr) {
10492 delete device_option_;
10493 }
10494 if (device_option) {
10495 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
10496 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(device_option);
10497 if (message_arena != submessage_arena) {
10498 device_option = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
10499 message_arena, device_option, submessage_arena);
10500 }
10501 _has_bits_[0] |= 0x00000004u;
10502 } else {
10503 _has_bits_[0] &= ~0x00000004u;
10504 }
10505 device_option_ = device_option;
10506 // @@protoc_insertion_point(field_set_allocated:caffe2.NetDef.device_option)
10507}
10508
10509// repeated .caffe2.Argument arg = 6;
10510inline int NetDef::_internal_arg_size() const {
10511 return arg_.size();
10512}
10513inline int NetDef::arg_size() const {
10514 return _internal_arg_size();
10515}
10516inline void NetDef::clear_arg() {
10517 arg_.Clear();
10518}
10519inline ::caffe2::Argument* NetDef::mutable_arg(int index) {
10520 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.arg)
10521 return arg_.Mutable(index);
10522}
10523inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >*
10524NetDef::mutable_arg() {
10525 // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.arg)
10526 return &arg_;
10527}
10528inline const ::caffe2::Argument& NetDef::_internal_arg(int index) const {
10529 return arg_.Get(index);
10530}
10531inline const ::caffe2::Argument& NetDef::arg(int index) const {
10532 // @@protoc_insertion_point(field_get:caffe2.NetDef.arg)
10533 return _internal_arg(index);
10534}
10535inline ::caffe2::Argument* NetDef::_internal_add_arg() {
10536 return arg_.Add();
10537}
10538inline ::caffe2::Argument* NetDef::add_arg() {
10539 // @@protoc_insertion_point(field_add:caffe2.NetDef.arg)
10540 return _internal_add_arg();
10541}
10542inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >&
10543NetDef::arg() const {
10544 // @@protoc_insertion_point(field_list:caffe2.NetDef.arg)
10545 return arg_;
10546}
10547
10548// repeated string external_input = 7;
10549inline int NetDef::_internal_external_input_size() const {
10550 return external_input_.size();
10551}
10552inline int NetDef::external_input_size() const {
10553 return _internal_external_input_size();
10554}
10555inline void NetDef::clear_external_input() {
10556 external_input_.Clear();
10557}
10558inline std::string* NetDef::add_external_input() {
10559 // @@protoc_insertion_point(field_add_mutable:caffe2.NetDef.external_input)
10560 return _internal_add_external_input();
10561}
10562inline const std::string& NetDef::_internal_external_input(int index) const {
10563 return external_input_.Get(index);
10564}
10565inline const std::string& NetDef::external_input(int index) const {
10566 // @@protoc_insertion_point(field_get:caffe2.NetDef.external_input)
10567 return _internal_external_input(index);
10568}
10569inline std::string* NetDef::mutable_external_input(int index) {
10570 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.external_input)
10571 return external_input_.Mutable(index);
10572}
10573inline void NetDef::set_external_input(int index, const std::string& value) {
10574 // @@protoc_insertion_point(field_set:caffe2.NetDef.external_input)
10575 external_input_.Mutable(index)->assign(value);
10576}
10577inline void NetDef::set_external_input(int index, std::string&& value) {
10578 // @@protoc_insertion_point(field_set:caffe2.NetDef.external_input)
10579 external_input_.Mutable(index)->assign(std::move(value));
10580}
10581inline void NetDef::set_external_input(int index, const char* value) {
10582 GOOGLE_DCHECK(value != nullptr);
10583 external_input_.Mutable(index)->assign(value);
10584 // @@protoc_insertion_point(field_set_char:caffe2.NetDef.external_input)
10585}
10586inline void NetDef::set_external_input(int index, const char* value, size_t size) {
10587 external_input_.Mutable(index)->assign(
10588 reinterpret_cast<const char*>(value), size);
10589 // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.external_input)
10590}
10591inline std::string* NetDef::_internal_add_external_input() {
10592 return external_input_.Add();
10593}
10594inline void NetDef::add_external_input(const std::string& value) {
10595 external_input_.Add()->assign(value);
10596 // @@protoc_insertion_point(field_add:caffe2.NetDef.external_input)
10597}
10598inline void NetDef::add_external_input(std::string&& value) {
10599 external_input_.Add(std::move(value));
10600 // @@protoc_insertion_point(field_add:caffe2.NetDef.external_input)
10601}
10602inline void NetDef::add_external_input(const char* value) {
10603 GOOGLE_DCHECK(value != nullptr);
10604 external_input_.Add()->assign(value);
10605 // @@protoc_insertion_point(field_add_char:caffe2.NetDef.external_input)
10606}
10607inline void NetDef::add_external_input(const char* value, size_t size) {
10608 external_input_.Add()->assign(reinterpret_cast<const char*>(value), size);
10609 // @@protoc_insertion_point(field_add_pointer:caffe2.NetDef.external_input)
10610}
10611inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
10612NetDef::external_input() const {
10613 // @@protoc_insertion_point(field_list:caffe2.NetDef.external_input)
10614 return external_input_;
10615}
10616inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
10617NetDef::mutable_external_input() {
10618 // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.external_input)
10619 return &external_input_;
10620}
10621
10622// repeated string external_output = 8;
10623inline int NetDef::_internal_external_output_size() const {
10624 return external_output_.size();
10625}
10626inline int NetDef::external_output_size() const {
10627 return _internal_external_output_size();
10628}
10629inline void NetDef::clear_external_output() {
10630 external_output_.Clear();
10631}
10632inline std::string* NetDef::add_external_output() {
10633 // @@protoc_insertion_point(field_add_mutable:caffe2.NetDef.external_output)
10634 return _internal_add_external_output();
10635}
10636inline const std::string& NetDef::_internal_external_output(int index) const {
10637 return external_output_.Get(index);
10638}
10639inline const std::string& NetDef::external_output(int index) const {
10640 // @@protoc_insertion_point(field_get:caffe2.NetDef.external_output)
10641 return _internal_external_output(index);
10642}
10643inline std::string* NetDef::mutable_external_output(int index) {
10644 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.external_output)
10645 return external_output_.Mutable(index);
10646}
10647inline void NetDef::set_external_output(int index, const std::string& value) {
10648 // @@protoc_insertion_point(field_set:caffe2.NetDef.external_output)
10649 external_output_.Mutable(index)->assign(value);
10650}
10651inline void NetDef::set_external_output(int index, std::string&& value) {
10652 // @@protoc_insertion_point(field_set:caffe2.NetDef.external_output)
10653 external_output_.Mutable(index)->assign(std::move(value));
10654}
10655inline void NetDef::set_external_output(int index, const char* value) {
10656 GOOGLE_DCHECK(value != nullptr);
10657 external_output_.Mutable(index)->assign(value);
10658 // @@protoc_insertion_point(field_set_char:caffe2.NetDef.external_output)
10659}
10660inline void NetDef::set_external_output(int index, const char* value, size_t size) {
10661 external_output_.Mutable(index)->assign(
10662 reinterpret_cast<const char*>(value), size);
10663 // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.external_output)
10664}
10665inline std::string* NetDef::_internal_add_external_output() {
10666 return external_output_.Add();
10667}
10668inline void NetDef::add_external_output(const std::string& value) {
10669 external_output_.Add()->assign(value);
10670 // @@protoc_insertion_point(field_add:caffe2.NetDef.external_output)
10671}
10672inline void NetDef::add_external_output(std::string&& value) {
10673 external_output_.Add(std::move(value));
10674 // @@protoc_insertion_point(field_add:caffe2.NetDef.external_output)
10675}
10676inline void NetDef::add_external_output(const char* value) {
10677 GOOGLE_DCHECK(value != nullptr);
10678 external_output_.Add()->assign(value);
10679 // @@protoc_insertion_point(field_add_char:caffe2.NetDef.external_output)
10680}
10681inline void NetDef::add_external_output(const char* value, size_t size) {
10682 external_output_.Add()->assign(reinterpret_cast<const char*>(value), size);
10683 // @@protoc_insertion_point(field_add_pointer:caffe2.NetDef.external_output)
10684}
10685inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
10686NetDef::external_output() const {
10687 // @@protoc_insertion_point(field_list:caffe2.NetDef.external_output)
10688 return external_output_;
10689}
10690inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
10691NetDef::mutable_external_output() {
10692 // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.external_output)
10693 return &external_output_;
10694}
10695
10696// repeated .caffe2.PartitionInfo partition_info = 9;
10697inline int NetDef::_internal_partition_info_size() const {
10698 return partition_info_.size();
10699}
10700inline int NetDef::partition_info_size() const {
10701 return _internal_partition_info_size();
10702}
10703inline void NetDef::clear_partition_info() {
10704 partition_info_.Clear();
10705}
10706inline ::caffe2::PartitionInfo* NetDef::mutable_partition_info(int index) {
10707 // @@protoc_insertion_point(field_mutable:caffe2.NetDef.partition_info)
10708 return partition_info_.Mutable(index);
10709}
10710inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo >*
10711NetDef::mutable_partition_info() {
10712 // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.partition_info)
10713 return &partition_info_;
10714}
10715inline const ::caffe2::PartitionInfo& NetDef::_internal_partition_info(int index) const {
10716 return partition_info_.Get(index);
10717}
10718inline const ::caffe2::PartitionInfo& NetDef::partition_info(int index) const {
10719 // @@protoc_insertion_point(field_get:caffe2.NetDef.partition_info)
10720 return _internal_partition_info(index);
10721}
10722inline ::caffe2::PartitionInfo* NetDef::_internal_add_partition_info() {
10723 return partition_info_.Add();
10724}
10725inline ::caffe2::PartitionInfo* NetDef::add_partition_info() {
10726 // @@protoc_insertion_point(field_add:caffe2.NetDef.partition_info)
10727 return _internal_add_partition_info();
10728}
10729inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo >&
10730NetDef::partition_info() const {
10731 // @@protoc_insertion_point(field_list:caffe2.NetDef.partition_info)
10732 return partition_info_;
10733}
10734
10735// -------------------------------------------------------------------
10736
10737// ExecutionStep
10738
10739// optional string name = 1;
10740inline bool ExecutionStep::_internal_has_name() const {
10741 bool value = (_has_bits_[0] & 0x00000001u) != 0;
10742 return value;
10743}
10744inline bool ExecutionStep::has_name() const {
10745 return _internal_has_name();
10746}
10747inline void ExecutionStep::clear_name() {
10748 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
10749 _has_bits_[0] &= ~0x00000001u;
10750}
10751inline const std::string& ExecutionStep::name() const {
10752 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.name)
10753 return _internal_name();
10754}
10755inline void ExecutionStep::set_name(const std::string& value) {
10756 _internal_set_name(value);
10757 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.name)
10758}
10759inline std::string* ExecutionStep::mutable_name() {
10760 // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.name)
10761 return _internal_mutable_name();
10762}
10763inline const std::string& ExecutionStep::_internal_name() const {
10764 return name_.Get();
10765}
10766inline void ExecutionStep::_internal_set_name(const std::string& value) {
10767 _has_bits_[0] |= 0x00000001u;
10768 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
10769}
10770inline void ExecutionStep::set_name(std::string&& value) {
10771 _has_bits_[0] |= 0x00000001u;
10772 name_.Set(
10773 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
10774 // @@protoc_insertion_point(field_set_rvalue:caffe2.ExecutionStep.name)
10775}
10776inline void ExecutionStep::set_name(const char* value) {
10777 GOOGLE_DCHECK(value != nullptr);
10778 _has_bits_[0] |= 0x00000001u;
10779 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
10780 GetArena());
10781 // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.name)
10782}
10783inline void ExecutionStep::set_name(const char* value,
10784 size_t size) {
10785 _has_bits_[0] |= 0x00000001u;
10786 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
10787 reinterpret_cast<const char*>(value), size), GetArena());
10788 // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.name)
10789}
10790inline std::string* ExecutionStep::_internal_mutable_name() {
10791 _has_bits_[0] |= 0x00000001u;
10792 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
10793}
10794inline std::string* ExecutionStep::release_name() {
10795 // @@protoc_insertion_point(field_release:caffe2.ExecutionStep.name)
10796 if (!_internal_has_name()) {
10797 return nullptr;
10798 }
10799 _has_bits_[0] &= ~0x00000001u;
10800 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
10801}
10802inline void ExecutionStep::set_allocated_name(std::string* name) {
10803 if (name != nullptr) {
10804 _has_bits_[0] |= 0x00000001u;
10805 } else {
10806 _has_bits_[0] &= ~0x00000001u;
10807 }
10808 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
10809 GetArena());
10810 // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.name)
10811}
10812
10813// repeated .caffe2.ExecutionStep substep = 2;
10814inline int ExecutionStep::_internal_substep_size() const {
10815 return substep_.size();
10816}
10817inline int ExecutionStep::substep_size() const {
10818 return _internal_substep_size();
10819}
10820inline void ExecutionStep::clear_substep() {
10821 substep_.Clear();
10822}
10823inline ::caffe2::ExecutionStep* ExecutionStep::mutable_substep(int index) {
10824 // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.substep)
10825 return substep_.Mutable(index);
10826}
10827inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >*
10828ExecutionStep::mutable_substep() {
10829 // @@protoc_insertion_point(field_mutable_list:caffe2.ExecutionStep.substep)
10830 return &substep_;
10831}
10832inline const ::caffe2::ExecutionStep& ExecutionStep::_internal_substep(int index) const {
10833 return substep_.Get(index);
10834}
10835inline const ::caffe2::ExecutionStep& ExecutionStep::substep(int index) const {
10836 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.substep)
10837 return _internal_substep(index);
10838}
10839inline ::caffe2::ExecutionStep* ExecutionStep::_internal_add_substep() {
10840 return substep_.Add();
10841}
10842inline ::caffe2::ExecutionStep* ExecutionStep::add_substep() {
10843 // @@protoc_insertion_point(field_add:caffe2.ExecutionStep.substep)
10844 return _internal_add_substep();
10845}
10846inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >&
10847ExecutionStep::substep() const {
10848 // @@protoc_insertion_point(field_list:caffe2.ExecutionStep.substep)
10849 return substep_;
10850}
10851
10852// repeated string network = 3;
10853inline int ExecutionStep::_internal_network_size() const {
10854 return network_.size();
10855}
10856inline int ExecutionStep::network_size() const {
10857 return _internal_network_size();
10858}
10859inline void ExecutionStep::clear_network() {
10860 network_.Clear();
10861}
10862inline std::string* ExecutionStep::add_network() {
10863 // @@protoc_insertion_point(field_add_mutable:caffe2.ExecutionStep.network)
10864 return _internal_add_network();
10865}
10866inline const std::string& ExecutionStep::_internal_network(int index) const {
10867 return network_.Get(index);
10868}
10869inline const std::string& ExecutionStep::network(int index) const {
10870 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.network)
10871 return _internal_network(index);
10872}
10873inline std::string* ExecutionStep::mutable_network(int index) {
10874 // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.network)
10875 return network_.Mutable(index);
10876}
10877inline void ExecutionStep::set_network(int index, const std::string& value) {
10878 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.network)
10879 network_.Mutable(index)->assign(value);
10880}
10881inline void ExecutionStep::set_network(int index, std::string&& value) {
10882 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.network)
10883 network_.Mutable(index)->assign(std::move(value));
10884}
10885inline void ExecutionStep::set_network(int index, const char* value) {
10886 GOOGLE_DCHECK(value != nullptr);
10887 network_.Mutable(index)->assign(value);
10888 // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.network)
10889}
10890inline void ExecutionStep::set_network(int index, const char* value, size_t size) {
10891 network_.Mutable(index)->assign(
10892 reinterpret_cast<const char*>(value), size);
10893 // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.network)
10894}
10895inline std::string* ExecutionStep::_internal_add_network() {
10896 return network_.Add();
10897}
10898inline void ExecutionStep::add_network(const std::string& value) {
10899 network_.Add()->assign(value);
10900 // @@protoc_insertion_point(field_add:caffe2.ExecutionStep.network)
10901}
10902inline void ExecutionStep::add_network(std::string&& value) {
10903 network_.Add(std::move(value));
10904 // @@protoc_insertion_point(field_add:caffe2.ExecutionStep.network)
10905}
10906inline void ExecutionStep::add_network(const char* value) {
10907 GOOGLE_DCHECK(value != nullptr);
10908 network_.Add()->assign(value);
10909 // @@protoc_insertion_point(field_add_char:caffe2.ExecutionStep.network)
10910}
10911inline void ExecutionStep::add_network(const char* value, size_t size) {
10912 network_.Add()->assign(reinterpret_cast<const char*>(value), size);
10913 // @@protoc_insertion_point(field_add_pointer:caffe2.ExecutionStep.network)
10914}
10915inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
10916ExecutionStep::network() const {
10917 // @@protoc_insertion_point(field_list:caffe2.ExecutionStep.network)
10918 return network_;
10919}
10920inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
10921ExecutionStep::mutable_network() {
10922 // @@protoc_insertion_point(field_mutable_list:caffe2.ExecutionStep.network)
10923 return &network_;
10924}
10925
10926// optional int64 num_iter = 4;
10927inline bool ExecutionStep::_internal_has_num_iter() const {
10928 bool value = (_has_bits_[0] & 0x00000010u) != 0;
10929 return value;
10930}
10931inline bool ExecutionStep::has_num_iter() const {
10932 return _internal_has_num_iter();
10933}
10934inline void ExecutionStep::clear_num_iter() {
10935 num_iter_ = PROTOBUF_LONGLONG(0);
10936 _has_bits_[0] &= ~0x00000010u;
10937}
10938inline ::PROTOBUF_NAMESPACE_ID::int64 ExecutionStep::_internal_num_iter() const {
10939 return num_iter_;
10940}
10941inline ::PROTOBUF_NAMESPACE_ID::int64 ExecutionStep::num_iter() const {
10942 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.num_iter)
10943 return _internal_num_iter();
10944}
10945inline void ExecutionStep::_internal_set_num_iter(::PROTOBUF_NAMESPACE_ID::int64 value) {
10946 _has_bits_[0] |= 0x00000010u;
10947 num_iter_ = value;
10948}
10949inline void ExecutionStep::set_num_iter(::PROTOBUF_NAMESPACE_ID::int64 value) {
10950 _internal_set_num_iter(value);
10951 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.num_iter)
10952}
10953
10954// optional string criteria_network = 5 [deprecated = true];
10955inline bool ExecutionStep::_internal_has_criteria_network() const {
10956 bool value = (_has_bits_[0] & 0x00000002u) != 0;
10957 return value;
10958}
10959inline bool ExecutionStep::has_criteria_network() const {
10960 return _internal_has_criteria_network();
10961}
10962inline void ExecutionStep::clear_criteria_network() {
10963 criteria_network_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
10964 _has_bits_[0] &= ~0x00000002u;
10965}
10966inline const std::string& ExecutionStep::criteria_network() const {
10967 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.criteria_network)
10968 return _internal_criteria_network();
10969}
10970inline void ExecutionStep::set_criteria_network(const std::string& value) {
10971 _internal_set_criteria_network(value);
10972 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.criteria_network)
10973}
10974inline std::string* ExecutionStep::mutable_criteria_network() {
10975 // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.criteria_network)
10976 return _internal_mutable_criteria_network();
10977}
10978inline const std::string& ExecutionStep::_internal_criteria_network() const {
10979 return criteria_network_.Get();
10980}
10981inline void ExecutionStep::_internal_set_criteria_network(const std::string& value) {
10982 _has_bits_[0] |= 0x00000002u;
10983 criteria_network_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
10984}
10985inline void ExecutionStep::set_criteria_network(std::string&& value) {
10986 _has_bits_[0] |= 0x00000002u;
10987 criteria_network_.Set(
10988 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
10989 // @@protoc_insertion_point(field_set_rvalue:caffe2.ExecutionStep.criteria_network)
10990}
10991inline void ExecutionStep::set_criteria_network(const char* value) {
10992 GOOGLE_DCHECK(value != nullptr);
10993 _has_bits_[0] |= 0x00000002u;
10994 criteria_network_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
10995 GetArena());
10996 // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.criteria_network)
10997}
10998inline void ExecutionStep::set_criteria_network(const char* value,
10999 size_t size) {
11000 _has_bits_[0] |= 0x00000002u;
11001 criteria_network_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
11002 reinterpret_cast<const char*>(value), size), GetArena());
11003 // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.criteria_network)
11004}
11005inline std::string* ExecutionStep::_internal_mutable_criteria_network() {
11006 _has_bits_[0] |= 0x00000002u;
11007 return criteria_network_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
11008}
11009inline std::string* ExecutionStep::release_criteria_network() {
11010 // @@protoc_insertion_point(field_release:caffe2.ExecutionStep.criteria_network)
11011 if (!_internal_has_criteria_network()) {
11012 return nullptr;
11013 }
11014 _has_bits_[0] &= ~0x00000002u;
11015 return criteria_network_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
11016}
11017inline void ExecutionStep::set_allocated_criteria_network(std::string* criteria_network) {
11018 if (criteria_network != nullptr) {
11019 _has_bits_[0] |= 0x00000002u;
11020 } else {
11021 _has_bits_[0] &= ~0x00000002u;
11022 }
11023 criteria_network_.SetAllocated(&GetEmptyStringAlreadyInited(), criteria_network,
11024 GetArena());
11025 // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.criteria_network)
11026}
11027
11028// optional string report_net = 7;
11029inline bool ExecutionStep::_internal_has_report_net() const {
11030 bool value = (_has_bits_[0] & 0x00000004u) != 0;
11031 return value;
11032}
11033inline bool ExecutionStep::has_report_net() const {
11034 return _internal_has_report_net();
11035}
11036inline void ExecutionStep::clear_report_net() {
11037 report_net_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
11038 _has_bits_[0] &= ~0x00000004u;
11039}
11040inline const std::string& ExecutionStep::report_net() const {
11041 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.report_net)
11042 return _internal_report_net();
11043}
11044inline void ExecutionStep::set_report_net(const std::string& value) {
11045 _internal_set_report_net(value);
11046 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.report_net)
11047}
11048inline std::string* ExecutionStep::mutable_report_net() {
11049 // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.report_net)
11050 return _internal_mutable_report_net();
11051}
11052inline const std::string& ExecutionStep::_internal_report_net() const {
11053 return report_net_.Get();
11054}
11055inline void ExecutionStep::_internal_set_report_net(const std::string& value) {
11056 _has_bits_[0] |= 0x00000004u;
11057 report_net_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
11058}
11059inline void ExecutionStep::set_report_net(std::string&& value) {
11060 _has_bits_[0] |= 0x00000004u;
11061 report_net_.Set(
11062 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
11063 // @@protoc_insertion_point(field_set_rvalue:caffe2.ExecutionStep.report_net)
11064}
11065inline void ExecutionStep::set_report_net(const char* value) {
11066 GOOGLE_DCHECK(value != nullptr);
11067 _has_bits_[0] |= 0x00000004u;
11068 report_net_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
11069 GetArena());
11070 // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.report_net)
11071}
11072inline void ExecutionStep::set_report_net(const char* value,
11073 size_t size) {
11074 _has_bits_[0] |= 0x00000004u;
11075 report_net_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
11076 reinterpret_cast<const char*>(value), size), GetArena());
11077 // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.report_net)
11078}
11079inline std::string* ExecutionStep::_internal_mutable_report_net() {
11080 _has_bits_[0] |= 0x00000004u;
11081 return report_net_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
11082}
11083inline std::string* ExecutionStep::release_report_net() {
11084 // @@protoc_insertion_point(field_release:caffe2.ExecutionStep.report_net)
11085 if (!_internal_has_report_net()) {
11086 return nullptr;
11087 }
11088 _has_bits_[0] &= ~0x00000004u;
11089 return report_net_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
11090}
11091inline void ExecutionStep::set_allocated_report_net(std::string* report_net) {
11092 if (report_net != nullptr) {
11093 _has_bits_[0] |= 0x00000004u;
11094 } else {
11095 _has_bits_[0] &= ~0x00000004u;
11096 }
11097 report_net_.SetAllocated(&GetEmptyStringAlreadyInited(), report_net,
11098 GetArena());
11099 // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.report_net)
11100}
11101
11102// optional int32 report_interval = 8;
11103inline bool ExecutionStep::_internal_has_report_interval() const {
11104 bool value = (_has_bits_[0] & 0x00000020u) != 0;
11105 return value;
11106}
11107inline bool ExecutionStep::has_report_interval() const {
11108 return _internal_has_report_interval();
11109}
11110inline void ExecutionStep::clear_report_interval() {
11111 report_interval_ = 0;
11112 _has_bits_[0] &= ~0x00000020u;
11113}
11114inline ::PROTOBUF_NAMESPACE_ID::int32 ExecutionStep::_internal_report_interval() const {
11115 return report_interval_;
11116}
11117inline ::PROTOBUF_NAMESPACE_ID::int32 ExecutionStep::report_interval() const {
11118 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.report_interval)
11119 return _internal_report_interval();
11120}
11121inline void ExecutionStep::_internal_set_report_interval(::PROTOBUF_NAMESPACE_ID::int32 value) {
11122 _has_bits_[0] |= 0x00000020u;
11123 report_interval_ = value;
11124}
11125inline void ExecutionStep::set_report_interval(::PROTOBUF_NAMESPACE_ID::int32 value) {
11126 _internal_set_report_interval(value);
11127 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.report_interval)
11128}
11129
11130// optional int64 run_every_ms = 11;
11131inline bool ExecutionStep::_internal_has_run_every_ms() const {
11132 bool value = (_has_bits_[0] & 0x00000200u) != 0;
11133 return value;
11134}
11135inline bool ExecutionStep::has_run_every_ms() const {
11136 return _internal_has_run_every_ms();
11137}
11138inline void ExecutionStep::clear_run_every_ms() {
11139 run_every_ms_ = PROTOBUF_LONGLONG(0);
11140 _has_bits_[0] &= ~0x00000200u;
11141}
11142inline ::PROTOBUF_NAMESPACE_ID::int64 ExecutionStep::_internal_run_every_ms() const {
11143 return run_every_ms_;
11144}
11145inline ::PROTOBUF_NAMESPACE_ID::int64 ExecutionStep::run_every_ms() const {
11146 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.run_every_ms)
11147 return _internal_run_every_ms();
11148}
11149inline void ExecutionStep::_internal_set_run_every_ms(::PROTOBUF_NAMESPACE_ID::int64 value) {
11150 _has_bits_[0] |= 0x00000200u;
11151 run_every_ms_ = value;
11152}
11153inline void ExecutionStep::set_run_every_ms(::PROTOBUF_NAMESPACE_ID::int64 value) {
11154 _internal_set_run_every_ms(value);
11155 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.run_every_ms)
11156}
11157
11158// optional bool concurrent_substeps = 6;
11159inline bool ExecutionStep::_internal_has_concurrent_substeps() const {
11160 bool value = (_has_bits_[0] & 0x00000040u) != 0;
11161 return value;
11162}
11163inline bool ExecutionStep::has_concurrent_substeps() const {
11164 return _internal_has_concurrent_substeps();
11165}
11166inline void ExecutionStep::clear_concurrent_substeps() {
11167 concurrent_substeps_ = false;
11168 _has_bits_[0] &= ~0x00000040u;
11169}
11170inline bool ExecutionStep::_internal_concurrent_substeps() const {
11171 return concurrent_substeps_;
11172}
11173inline bool ExecutionStep::concurrent_substeps() const {
11174 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.concurrent_substeps)
11175 return _internal_concurrent_substeps();
11176}
11177inline void ExecutionStep::_internal_set_concurrent_substeps(bool value) {
11178 _has_bits_[0] |= 0x00000040u;
11179 concurrent_substeps_ = value;
11180}
11181inline void ExecutionStep::set_concurrent_substeps(bool value) {
11182 _internal_set_concurrent_substeps(value);
11183 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.concurrent_substeps)
11184}
11185
11186// optional string should_stop_blob = 9;
11187inline bool ExecutionStep::_internal_has_should_stop_blob() const {
11188 bool value = (_has_bits_[0] & 0x00000008u) != 0;
11189 return value;
11190}
11191inline bool ExecutionStep::has_should_stop_blob() const {
11192 return _internal_has_should_stop_blob();
11193}
11194inline void ExecutionStep::clear_should_stop_blob() {
11195 should_stop_blob_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
11196 _has_bits_[0] &= ~0x00000008u;
11197}
11198inline const std::string& ExecutionStep::should_stop_blob() const {
11199 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.should_stop_blob)
11200 return _internal_should_stop_blob();
11201}
11202inline void ExecutionStep::set_should_stop_blob(const std::string& value) {
11203 _internal_set_should_stop_blob(value);
11204 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.should_stop_blob)
11205}
11206inline std::string* ExecutionStep::mutable_should_stop_blob() {
11207 // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.should_stop_blob)
11208 return _internal_mutable_should_stop_blob();
11209}
11210inline const std::string& ExecutionStep::_internal_should_stop_blob() const {
11211 return should_stop_blob_.Get();
11212}
11213inline void ExecutionStep::_internal_set_should_stop_blob(const std::string& value) {
11214 _has_bits_[0] |= 0x00000008u;
11215 should_stop_blob_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
11216}
11217inline void ExecutionStep::set_should_stop_blob(std::string&& value) {
11218 _has_bits_[0] |= 0x00000008u;
11219 should_stop_blob_.Set(
11220 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
11221 // @@protoc_insertion_point(field_set_rvalue:caffe2.ExecutionStep.should_stop_blob)
11222}
11223inline void ExecutionStep::set_should_stop_blob(const char* value) {
11224 GOOGLE_DCHECK(value != nullptr);
11225 _has_bits_[0] |= 0x00000008u;
11226 should_stop_blob_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
11227 GetArena());
11228 // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.should_stop_blob)
11229}
11230inline void ExecutionStep::set_should_stop_blob(const char* value,
11231 size_t size) {
11232 _has_bits_[0] |= 0x00000008u;
11233 should_stop_blob_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
11234 reinterpret_cast<const char*>(value), size), GetArena());
11235 // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.should_stop_blob)
11236}
11237inline std::string* ExecutionStep::_internal_mutable_should_stop_blob() {
11238 _has_bits_[0] |= 0x00000008u;
11239 return should_stop_blob_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
11240}
11241inline std::string* ExecutionStep::release_should_stop_blob() {
11242 // @@protoc_insertion_point(field_release:caffe2.ExecutionStep.should_stop_blob)
11243 if (!_internal_has_should_stop_blob()) {
11244 return nullptr;
11245 }
11246 _has_bits_[0] &= ~0x00000008u;
11247 return should_stop_blob_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
11248}
11249inline void ExecutionStep::set_allocated_should_stop_blob(std::string* should_stop_blob) {
11250 if (should_stop_blob != nullptr) {
11251 _has_bits_[0] |= 0x00000008u;
11252 } else {
11253 _has_bits_[0] &= ~0x00000008u;
11254 }
11255 should_stop_blob_.SetAllocated(&GetEmptyStringAlreadyInited(), should_stop_blob,
11256 GetArena());
11257 // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.should_stop_blob)
11258}
11259
11260// optional bool only_once = 10;
11261inline bool ExecutionStep::_internal_has_only_once() const {
11262 bool value = (_has_bits_[0] & 0x00000080u) != 0;
11263 return value;
11264}
11265inline bool ExecutionStep::has_only_once() const {
11266 return _internal_has_only_once();
11267}
11268inline void ExecutionStep::clear_only_once() {
11269 only_once_ = false;
11270 _has_bits_[0] &= ~0x00000080u;
11271}
11272inline bool ExecutionStep::_internal_only_once() const {
11273 return only_once_;
11274}
11275inline bool ExecutionStep::only_once() const {
11276 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.only_once)
11277 return _internal_only_once();
11278}
11279inline void ExecutionStep::_internal_set_only_once(bool value) {
11280 _has_bits_[0] |= 0x00000080u;
11281 only_once_ = value;
11282}
11283inline void ExecutionStep::set_only_once(bool value) {
11284 _internal_set_only_once(value);
11285 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.only_once)
11286}
11287
11288// optional bool create_workspace = 12;
11289inline bool ExecutionStep::_internal_has_create_workspace() const {
11290 bool value = (_has_bits_[0] & 0x00000100u) != 0;
11291 return value;
11292}
11293inline bool ExecutionStep::has_create_workspace() const {
11294 return _internal_has_create_workspace();
11295}
11296inline void ExecutionStep::clear_create_workspace() {
11297 create_workspace_ = false;
11298 _has_bits_[0] &= ~0x00000100u;
11299}
11300inline bool ExecutionStep::_internal_create_workspace() const {
11301 return create_workspace_;
11302}
11303inline bool ExecutionStep::create_workspace() const {
11304 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.create_workspace)
11305 return _internal_create_workspace();
11306}
11307inline void ExecutionStep::_internal_set_create_workspace(bool value) {
11308 _has_bits_[0] |= 0x00000100u;
11309 create_workspace_ = value;
11310}
11311inline void ExecutionStep::set_create_workspace(bool value) {
11312 _internal_set_create_workspace(value);
11313 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.create_workspace)
11314}
11315
11316// optional int32 num_concurrent_instances = 13;
11317inline bool ExecutionStep::_internal_has_num_concurrent_instances() const {
11318 bool value = (_has_bits_[0] & 0x00000400u) != 0;
11319 return value;
11320}
11321inline bool ExecutionStep::has_num_concurrent_instances() const {
11322 return _internal_has_num_concurrent_instances();
11323}
11324inline void ExecutionStep::clear_num_concurrent_instances() {
11325 num_concurrent_instances_ = 0;
11326 _has_bits_[0] &= ~0x00000400u;
11327}
11328inline ::PROTOBUF_NAMESPACE_ID::int32 ExecutionStep::_internal_num_concurrent_instances() const {
11329 return num_concurrent_instances_;
11330}
11331inline ::PROTOBUF_NAMESPACE_ID::int32 ExecutionStep::num_concurrent_instances() const {
11332 // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.num_concurrent_instances)
11333 return _internal_num_concurrent_instances();
11334}
11335inline void ExecutionStep::_internal_set_num_concurrent_instances(::PROTOBUF_NAMESPACE_ID::int32 value) {
11336 _has_bits_[0] |= 0x00000400u;
11337 num_concurrent_instances_ = value;
11338}
11339inline void ExecutionStep::set_num_concurrent_instances(::PROTOBUF_NAMESPACE_ID::int32 value) {
11340 _internal_set_num_concurrent_instances(value);
11341 // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.num_concurrent_instances)
11342}
11343
11344// -------------------------------------------------------------------
11345
11346// PlanDef
11347
11348// optional string name = 1;
11349inline bool PlanDef::_internal_has_name() const {
11350 bool value = (_has_bits_[0] & 0x00000001u) != 0;
11351 return value;
11352}
11353inline bool PlanDef::has_name() const {
11354 return _internal_has_name();
11355}
11356inline void PlanDef::clear_name() {
11357 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
11358 _has_bits_[0] &= ~0x00000001u;
11359}
11360inline const std::string& PlanDef::name() const {
11361 // @@protoc_insertion_point(field_get:caffe2.PlanDef.name)
11362 return _internal_name();
11363}
11364inline void PlanDef::set_name(const std::string& value) {
11365 _internal_set_name(value);
11366 // @@protoc_insertion_point(field_set:caffe2.PlanDef.name)
11367}
11368inline std::string* PlanDef::mutable_name() {
11369 // @@protoc_insertion_point(field_mutable:caffe2.PlanDef.name)
11370 return _internal_mutable_name();
11371}
11372inline const std::string& PlanDef::_internal_name() const {
11373 return name_.Get();
11374}
11375inline void PlanDef::_internal_set_name(const std::string& value) {
11376 _has_bits_[0] |= 0x00000001u;
11377 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
11378}
11379inline void PlanDef::set_name(std::string&& value) {
11380 _has_bits_[0] |= 0x00000001u;
11381 name_.Set(
11382 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
11383 // @@protoc_insertion_point(field_set_rvalue:caffe2.PlanDef.name)
11384}
11385inline void PlanDef::set_name(const char* value) {
11386 GOOGLE_DCHECK(value != nullptr);
11387 _has_bits_[0] |= 0x00000001u;
11388 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
11389 GetArena());
11390 // @@protoc_insertion_point(field_set_char:caffe2.PlanDef.name)
11391}
11392inline void PlanDef::set_name(const char* value,
11393 size_t size) {
11394 _has_bits_[0] |= 0x00000001u;
11395 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
11396 reinterpret_cast<const char*>(value), size), GetArena());
11397 // @@protoc_insertion_point(field_set_pointer:caffe2.PlanDef.name)
11398}
11399inline std::string* PlanDef::_internal_mutable_name() {
11400 _has_bits_[0] |= 0x00000001u;
11401 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
11402}
11403inline std::string* PlanDef::release_name() {
11404 // @@protoc_insertion_point(field_release:caffe2.PlanDef.name)
11405 if (!_internal_has_name()) {
11406 return nullptr;
11407 }
11408 _has_bits_[0] &= ~0x00000001u;
11409 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
11410}
11411inline void PlanDef::set_allocated_name(std::string* name) {
11412 if (name != nullptr) {
11413 _has_bits_[0] |= 0x00000001u;
11414 } else {
11415 _has_bits_[0] &= ~0x00000001u;
11416 }
11417 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
11418 GetArena());
11419 // @@protoc_insertion_point(field_set_allocated:caffe2.PlanDef.name)
11420}
11421
11422// repeated .caffe2.NetDef network = 2;
11423inline int PlanDef::_internal_network_size() const {
11424 return network_.size();
11425}
11426inline int PlanDef::network_size() const {
11427 return _internal_network_size();
11428}
11429inline void PlanDef::clear_network() {
11430 network_.Clear();
11431}
11432inline ::caffe2::NetDef* PlanDef::mutable_network(int index) {
11433 // @@protoc_insertion_point(field_mutable:caffe2.PlanDef.network)
11434 return network_.Mutable(index);
11435}
11436inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >*
11437PlanDef::mutable_network() {
11438 // @@protoc_insertion_point(field_mutable_list:caffe2.PlanDef.network)
11439 return &network_;
11440}
11441inline const ::caffe2::NetDef& PlanDef::_internal_network(int index) const {
11442 return network_.Get(index);
11443}
11444inline const ::caffe2::NetDef& PlanDef::network(int index) const {
11445 // @@protoc_insertion_point(field_get:caffe2.PlanDef.network)
11446 return _internal_network(index);
11447}
11448inline ::caffe2::NetDef* PlanDef::_internal_add_network() {
11449 return network_.Add();
11450}
11451inline ::caffe2::NetDef* PlanDef::add_network() {
11452 // @@protoc_insertion_point(field_add:caffe2.PlanDef.network)
11453 return _internal_add_network();
11454}
11455inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >&
11456PlanDef::network() const {
11457 // @@protoc_insertion_point(field_list:caffe2.PlanDef.network)
11458 return network_;
11459}
11460
11461// repeated .caffe2.ExecutionStep execution_step = 3;
11462inline int PlanDef::_internal_execution_step_size() const {
11463 return execution_step_.size();
11464}
11465inline int PlanDef::execution_step_size() const {
11466 return _internal_execution_step_size();
11467}
11468inline void PlanDef::clear_execution_step() {
11469 execution_step_.Clear();
11470}
11471inline ::caffe2::ExecutionStep* PlanDef::mutable_execution_step(int index) {
11472 // @@protoc_insertion_point(field_mutable:caffe2.PlanDef.execution_step)
11473 return execution_step_.Mutable(index);
11474}
11475inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >*
11476PlanDef::mutable_execution_step() {
11477 // @@protoc_insertion_point(field_mutable_list:caffe2.PlanDef.execution_step)
11478 return &execution_step_;
11479}
11480inline const ::caffe2::ExecutionStep& PlanDef::_internal_execution_step(int index) const {
11481 return execution_step_.Get(index);
11482}
11483inline const ::caffe2::ExecutionStep& PlanDef::execution_step(int index) const {
11484 // @@protoc_insertion_point(field_get:caffe2.PlanDef.execution_step)
11485 return _internal_execution_step(index);
11486}
11487inline ::caffe2::ExecutionStep* PlanDef::_internal_add_execution_step() {
11488 return execution_step_.Add();
11489}
11490inline ::caffe2::ExecutionStep* PlanDef::add_execution_step() {
11491 // @@protoc_insertion_point(field_add:caffe2.PlanDef.execution_step)
11492 return _internal_add_execution_step();
11493}
11494inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >&
11495PlanDef::execution_step() const {
11496 // @@protoc_insertion_point(field_list:caffe2.PlanDef.execution_step)
11497 return execution_step_;
11498}
11499
11500// -------------------------------------------------------------------
11501
11502// BlobProto
11503
11504// optional string name = 1;
11505inline bool BlobProto::_internal_has_name() const {
11506 bool value = (_has_bits_[0] & 0x00000001u) != 0;
11507 return value;
11508}
11509inline bool BlobProto::has_name() const {
11510 return _internal_has_name();
11511}
11512inline void BlobProto::clear_name() {
11513 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
11514 _has_bits_[0] &= ~0x00000001u;
11515}
11516inline const std::string& BlobProto::name() const {
11517 // @@protoc_insertion_point(field_get:caffe2.BlobProto.name)
11518 return _internal_name();
11519}
11520inline void BlobProto::set_name(const std::string& value) {
11521 _internal_set_name(value);
11522 // @@protoc_insertion_point(field_set:caffe2.BlobProto.name)
11523}
11524inline std::string* BlobProto::mutable_name() {
11525 // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.name)
11526 return _internal_mutable_name();
11527}
11528inline const std::string& BlobProto::_internal_name() const {
11529 return name_.Get();
11530}
11531inline void BlobProto::_internal_set_name(const std::string& value) {
11532 _has_bits_[0] |= 0x00000001u;
11533 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
11534}
11535inline void BlobProto::set_name(std::string&& value) {
11536 _has_bits_[0] |= 0x00000001u;
11537 name_.Set(
11538 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
11539 // @@protoc_insertion_point(field_set_rvalue:caffe2.BlobProto.name)
11540}
11541inline void BlobProto::set_name(const char* value) {
11542 GOOGLE_DCHECK(value != nullptr);
11543 _has_bits_[0] |= 0x00000001u;
11544 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
11545 GetArena());
11546 // @@protoc_insertion_point(field_set_char:caffe2.BlobProto.name)
11547}
11548inline void BlobProto::set_name(const char* value,
11549 size_t size) {
11550 _has_bits_[0] |= 0x00000001u;
11551 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
11552 reinterpret_cast<const char*>(value), size), GetArena());
11553 // @@protoc_insertion_point(field_set_pointer:caffe2.BlobProto.name)
11554}
11555inline std::string* BlobProto::_internal_mutable_name() {
11556 _has_bits_[0] |= 0x00000001u;
11557 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
11558}
11559inline std::string* BlobProto::release_name() {
11560 // @@protoc_insertion_point(field_release:caffe2.BlobProto.name)
11561 if (!_internal_has_name()) {
11562 return nullptr;
11563 }
11564 _has_bits_[0] &= ~0x00000001u;
11565 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
11566}
11567inline void BlobProto::set_allocated_name(std::string* name) {
11568 if (name != nullptr) {
11569 _has_bits_[0] |= 0x00000001u;
11570 } else {
11571 _has_bits_[0] &= ~0x00000001u;
11572 }
11573 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
11574 GetArena());
11575 // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.name)
11576}
11577
11578// optional string type = 2;
11579inline bool BlobProto::_internal_has_type() const {
11580 bool value = (_has_bits_[0] & 0x00000002u) != 0;
11581 return value;
11582}
11583inline bool BlobProto::has_type() const {
11584 return _internal_has_type();
11585}
11586inline void BlobProto::clear_type() {
11587 type_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
11588 _has_bits_[0] &= ~0x00000002u;
11589}
11590inline const std::string& BlobProto::type() const {
11591 // @@protoc_insertion_point(field_get:caffe2.BlobProto.type)
11592 return _internal_type();
11593}
11594inline void BlobProto::set_type(const std::string& value) {
11595 _internal_set_type(value);
11596 // @@protoc_insertion_point(field_set:caffe2.BlobProto.type)
11597}
11598inline std::string* BlobProto::mutable_type() {
11599 // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.type)
11600 return _internal_mutable_type();
11601}
11602inline const std::string& BlobProto::_internal_type() const {
11603 return type_.Get();
11604}
11605inline void BlobProto::_internal_set_type(const std::string& value) {
11606 _has_bits_[0] |= 0x00000002u;
11607 type_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
11608}
11609inline void BlobProto::set_type(std::string&& value) {
11610 _has_bits_[0] |= 0x00000002u;
11611 type_.Set(
11612 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
11613 // @@protoc_insertion_point(field_set_rvalue:caffe2.BlobProto.type)
11614}
11615inline void BlobProto::set_type(const char* value) {
11616 GOOGLE_DCHECK(value != nullptr);
11617 _has_bits_[0] |= 0x00000002u;
11618 type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
11619 GetArena());
11620 // @@protoc_insertion_point(field_set_char:caffe2.BlobProto.type)
11621}
11622inline void BlobProto::set_type(const char* value,
11623 size_t size) {
11624 _has_bits_[0] |= 0x00000002u;
11625 type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
11626 reinterpret_cast<const char*>(value), size), GetArena());
11627 // @@protoc_insertion_point(field_set_pointer:caffe2.BlobProto.type)
11628}
11629inline std::string* BlobProto::_internal_mutable_type() {
11630 _has_bits_[0] |= 0x00000002u;
11631 return type_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
11632}
11633inline std::string* BlobProto::release_type() {
11634 // @@protoc_insertion_point(field_release:caffe2.BlobProto.type)
11635 if (!_internal_has_type()) {
11636 return nullptr;
11637 }
11638 _has_bits_[0] &= ~0x00000002u;
11639 return type_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
11640}
11641inline void BlobProto::set_allocated_type(std::string* type) {
11642 if (type != nullptr) {
11643 _has_bits_[0] |= 0x00000002u;
11644 } else {
11645 _has_bits_[0] &= ~0x00000002u;
11646 }
11647 type_.SetAllocated(&GetEmptyStringAlreadyInited(), type,
11648 GetArena());
11649 // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.type)
11650}
11651
11652// optional .caffe2.TensorProto tensor = 3;
11653inline bool BlobProto::_internal_has_tensor() const {
11654 bool value = (_has_bits_[0] & 0x00000008u) != 0;
11655 PROTOBUF_ASSUME(!value || tensor_ != nullptr);
11656 return value;
11657}
11658inline bool BlobProto::has_tensor() const {
11659 return _internal_has_tensor();
11660}
11661inline void BlobProto::clear_tensor() {
11662 if (tensor_ != nullptr) tensor_->Clear();
11663 _has_bits_[0] &= ~0x00000008u;
11664}
11665inline const ::caffe2::TensorProto& BlobProto::_internal_tensor() const {
11666 const ::caffe2::TensorProto* p = tensor_;
11667 return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::TensorProto*>(
11668 &::caffe2::_TensorProto_default_instance_);
11669}
11670inline const ::caffe2::TensorProto& BlobProto::tensor() const {
11671 // @@protoc_insertion_point(field_get:caffe2.BlobProto.tensor)
11672 return _internal_tensor();
11673}
11674inline void BlobProto::unsafe_arena_set_allocated_tensor(
11675 ::caffe2::TensorProto* tensor) {
11676 if (GetArena() == nullptr) {
11677 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor_);
11678 }
11679 tensor_ = tensor;
11680 if (tensor) {
11681 _has_bits_[0] |= 0x00000008u;
11682 } else {
11683 _has_bits_[0] &= ~0x00000008u;
11684 }
11685 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.BlobProto.tensor)
11686}
11687inline ::caffe2::TensorProto* BlobProto::release_tensor() {
11688 _has_bits_[0] &= ~0x00000008u;
11689 ::caffe2::TensorProto* temp = tensor_;
11690 tensor_ = nullptr;
11691 if (GetArena() != nullptr) {
11692 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
11693 }
11694 return temp;
11695}
11696inline ::caffe2::TensorProto* BlobProto::unsafe_arena_release_tensor() {
11697 // @@protoc_insertion_point(field_release:caffe2.BlobProto.tensor)
11698 _has_bits_[0] &= ~0x00000008u;
11699 ::caffe2::TensorProto* temp = tensor_;
11700 tensor_ = nullptr;
11701 return temp;
11702}
11703inline ::caffe2::TensorProto* BlobProto::_internal_mutable_tensor() {
11704 _has_bits_[0] |= 0x00000008u;
11705 if (tensor_ == nullptr) {
11706 auto* p = CreateMaybeMessage<::caffe2::TensorProto>(GetArena());
11707 tensor_ = p;
11708 }
11709 return tensor_;
11710}
11711inline ::caffe2::TensorProto* BlobProto::mutable_tensor() {
11712 // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.tensor)
11713 return _internal_mutable_tensor();
11714}
11715inline void BlobProto::set_allocated_tensor(::caffe2::TensorProto* tensor) {
11716 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
11717 if (message_arena == nullptr) {
11718 delete tensor_;
11719 }
11720 if (tensor) {
11721 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
11722 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tensor);
11723 if (message_arena != submessage_arena) {
11724 tensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
11725 message_arena, tensor, submessage_arena);
11726 }
11727 _has_bits_[0] |= 0x00000008u;
11728 } else {
11729 _has_bits_[0] &= ~0x00000008u;
11730 }
11731 tensor_ = tensor;
11732 // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.tensor)
11733}
11734
11735// optional bytes content = 4;
11736inline bool BlobProto::_internal_has_content() const {
11737 bool value = (_has_bits_[0] & 0x00000004u) != 0;
11738 return value;
11739}
11740inline bool BlobProto::has_content() const {
11741 return _internal_has_content();
11742}
11743inline void BlobProto::clear_content() {
11744 content_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
11745 _has_bits_[0] &= ~0x00000004u;
11746}
11747inline const std::string& BlobProto::content() const {
11748 // @@protoc_insertion_point(field_get:caffe2.BlobProto.content)
11749 return _internal_content();
11750}
11751inline void BlobProto::set_content(const std::string& value) {
11752 _internal_set_content(value);
11753 // @@protoc_insertion_point(field_set:caffe2.BlobProto.content)
11754}
11755inline std::string* BlobProto::mutable_content() {
11756 // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.content)
11757 return _internal_mutable_content();
11758}
11759inline const std::string& BlobProto::_internal_content() const {
11760 return content_.Get();
11761}
11762inline void BlobProto::_internal_set_content(const std::string& value) {
11763 _has_bits_[0] |= 0x00000004u;
11764 content_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
11765}
11766inline void BlobProto::set_content(std::string&& value) {
11767 _has_bits_[0] |= 0x00000004u;
11768 content_.Set(
11769 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
11770 // @@protoc_insertion_point(field_set_rvalue:caffe2.BlobProto.content)
11771}
11772inline void BlobProto::set_content(const char* value) {
11773 GOOGLE_DCHECK(value != nullptr);
11774 _has_bits_[0] |= 0x00000004u;
11775 content_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
11776 GetArena());
11777 // @@protoc_insertion_point(field_set_char:caffe2.BlobProto.content)
11778}
11779inline void BlobProto::set_content(const void* value,
11780 size_t size) {
11781 _has_bits_[0] |= 0x00000004u;
11782 content_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
11783 reinterpret_cast<const char*>(value), size), GetArena());
11784 // @@protoc_insertion_point(field_set_pointer:caffe2.BlobProto.content)
11785}
11786inline std::string* BlobProto::_internal_mutable_content() {
11787 _has_bits_[0] |= 0x00000004u;
11788 return content_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
11789}
11790inline std::string* BlobProto::release_content() {
11791 // @@protoc_insertion_point(field_release:caffe2.BlobProto.content)
11792 if (!_internal_has_content()) {
11793 return nullptr;
11794 }
11795 _has_bits_[0] &= ~0x00000004u;
11796 return content_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
11797}
11798inline void BlobProto::set_allocated_content(std::string* content) {
11799 if (content != nullptr) {
11800 _has_bits_[0] |= 0x00000004u;
11801 } else {
11802 _has_bits_[0] &= ~0x00000004u;
11803 }
11804 content_.SetAllocated(&GetEmptyStringAlreadyInited(), content,
11805 GetArena());
11806 // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.content)
11807}
11808
11809// optional .caffe2.QTensorProto qtensor = 5;
11810inline bool BlobProto::_internal_has_qtensor() const {
11811 bool value = (_has_bits_[0] & 0x00000010u) != 0;
11812 PROTOBUF_ASSUME(!value || qtensor_ != nullptr);
11813 return value;
11814}
11815inline bool BlobProto::has_qtensor() const {
11816 return _internal_has_qtensor();
11817}
11818inline void BlobProto::clear_qtensor() {
11819 if (qtensor_ != nullptr) qtensor_->Clear();
11820 _has_bits_[0] &= ~0x00000010u;
11821}
11822inline const ::caffe2::QTensorProto& BlobProto::_internal_qtensor() const {
11823 const ::caffe2::QTensorProto* p = qtensor_;
11824 return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::QTensorProto*>(
11825 &::caffe2::_QTensorProto_default_instance_);
11826}
11827inline const ::caffe2::QTensorProto& BlobProto::qtensor() const {
11828 // @@protoc_insertion_point(field_get:caffe2.BlobProto.qtensor)
11829 return _internal_qtensor();
11830}
11831inline void BlobProto::unsafe_arena_set_allocated_qtensor(
11832 ::caffe2::QTensorProto* qtensor) {
11833 if (GetArena() == nullptr) {
11834 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(qtensor_);
11835 }
11836 qtensor_ = qtensor;
11837 if (qtensor) {
11838 _has_bits_[0] |= 0x00000010u;
11839 } else {
11840 _has_bits_[0] &= ~0x00000010u;
11841 }
11842 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.BlobProto.qtensor)
11843}
11844inline ::caffe2::QTensorProto* BlobProto::release_qtensor() {
11845 _has_bits_[0] &= ~0x00000010u;
11846 ::caffe2::QTensorProto* temp = qtensor_;
11847 qtensor_ = nullptr;
11848 if (GetArena() != nullptr) {
11849 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
11850 }
11851 return temp;
11852}
11853inline ::caffe2::QTensorProto* BlobProto::unsafe_arena_release_qtensor() {
11854 // @@protoc_insertion_point(field_release:caffe2.BlobProto.qtensor)
11855 _has_bits_[0] &= ~0x00000010u;
11856 ::caffe2::QTensorProto* temp = qtensor_;
11857 qtensor_ = nullptr;
11858 return temp;
11859}
11860inline ::caffe2::QTensorProto* BlobProto::_internal_mutable_qtensor() {
11861 _has_bits_[0] |= 0x00000010u;
11862 if (qtensor_ == nullptr) {
11863 auto* p = CreateMaybeMessage<::caffe2::QTensorProto>(GetArena());
11864 qtensor_ = p;
11865 }
11866 return qtensor_;
11867}
11868inline ::caffe2::QTensorProto* BlobProto::mutable_qtensor() {
11869 // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.qtensor)
11870 return _internal_mutable_qtensor();
11871}
11872inline void BlobProto::set_allocated_qtensor(::caffe2::QTensorProto* qtensor) {
11873 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
11874 if (message_arena == nullptr) {
11875 delete qtensor_;
11876 }
11877 if (qtensor) {
11878 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
11879 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(qtensor);
11880 if (message_arena != submessage_arena) {
11881 qtensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
11882 message_arena, qtensor, submessage_arena);
11883 }
11884 _has_bits_[0] |= 0x00000010u;
11885 } else {
11886 _has_bits_[0] &= ~0x00000010u;
11887 }
11888 qtensor_ = qtensor;
11889 // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.qtensor)
11890}
11891
11892// optional int32 content_num_chunks = 6;
11893inline bool BlobProto::_internal_has_content_num_chunks() const {
11894 bool value = (_has_bits_[0] & 0x00000020u) != 0;
11895 return value;
11896}
11897inline bool BlobProto::has_content_num_chunks() const {
11898 return _internal_has_content_num_chunks();
11899}
11900inline void BlobProto::clear_content_num_chunks() {
11901 content_num_chunks_ = 0;
11902 _has_bits_[0] &= ~0x00000020u;
11903}
11904inline ::PROTOBUF_NAMESPACE_ID::int32 BlobProto::_internal_content_num_chunks() const {
11905 return content_num_chunks_;
11906}
11907inline ::PROTOBUF_NAMESPACE_ID::int32 BlobProto::content_num_chunks() const {
11908 // @@protoc_insertion_point(field_get:caffe2.BlobProto.content_num_chunks)
11909 return _internal_content_num_chunks();
11910}
11911inline void BlobProto::_internal_set_content_num_chunks(::PROTOBUF_NAMESPACE_ID::int32 value) {
11912 _has_bits_[0] |= 0x00000020u;
11913 content_num_chunks_ = value;
11914}
11915inline void BlobProto::set_content_num_chunks(::PROTOBUF_NAMESPACE_ID::int32 value) {
11916 _internal_set_content_num_chunks(value);
11917 // @@protoc_insertion_point(field_set:caffe2.BlobProto.content_num_chunks)
11918}
11919
11920// optional int32 content_chunk_id = 7;
11921inline bool BlobProto::_internal_has_content_chunk_id() const {
11922 bool value = (_has_bits_[0] & 0x00000040u) != 0;
11923 return value;
11924}
11925inline bool BlobProto::has_content_chunk_id() const {
11926 return _internal_has_content_chunk_id();
11927}
11928inline void BlobProto::clear_content_chunk_id() {
11929 content_chunk_id_ = 0;
11930 _has_bits_[0] &= ~0x00000040u;
11931}
11932inline ::PROTOBUF_NAMESPACE_ID::int32 BlobProto::_internal_content_chunk_id() const {
11933 return content_chunk_id_;
11934}
11935inline ::PROTOBUF_NAMESPACE_ID::int32 BlobProto::content_chunk_id() const {
11936 // @@protoc_insertion_point(field_get:caffe2.BlobProto.content_chunk_id)
11937 return _internal_content_chunk_id();
11938}
11939inline void BlobProto::_internal_set_content_chunk_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
11940 _has_bits_[0] |= 0x00000040u;
11941 content_chunk_id_ = value;
11942}
11943inline void BlobProto::set_content_chunk_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
11944 _internal_set_content_chunk_id(value);
11945 // @@protoc_insertion_point(field_set:caffe2.BlobProto.content_chunk_id)
11946}
11947
11948// -------------------------------------------------------------------
11949
11950// DBReaderProto
11951
11952// optional string name = 1;
11953inline bool DBReaderProto::_internal_has_name() const {
11954 bool value = (_has_bits_[0] & 0x00000001u) != 0;
11955 return value;
11956}
11957inline bool DBReaderProto::has_name() const {
11958 return _internal_has_name();
11959}
11960inline void DBReaderProto::clear_name() {
11961 name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
11962 _has_bits_[0] &= ~0x00000001u;
11963}
11964inline const std::string& DBReaderProto::name() const {
11965 // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.name)
11966 return _internal_name();
11967}
11968inline void DBReaderProto::set_name(const std::string& value) {
11969 _internal_set_name(value);
11970 // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.name)
11971}
11972inline std::string* DBReaderProto::mutable_name() {
11973 // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.name)
11974 return _internal_mutable_name();
11975}
11976inline const std::string& DBReaderProto::_internal_name() const {
11977 return name_.Get();
11978}
11979inline void DBReaderProto::_internal_set_name(const std::string& value) {
11980 _has_bits_[0] |= 0x00000001u;
11981 name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
11982}
11983inline void DBReaderProto::set_name(std::string&& value) {
11984 _has_bits_[0] |= 0x00000001u;
11985 name_.Set(
11986 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
11987 // @@protoc_insertion_point(field_set_rvalue:caffe2.DBReaderProto.name)
11988}
11989inline void DBReaderProto::set_name(const char* value) {
11990 GOOGLE_DCHECK(value != nullptr);
11991 _has_bits_[0] |= 0x00000001u;
11992 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
11993 GetArena());
11994 // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.name)
11995}
11996inline void DBReaderProto::set_name(const char* value,
11997 size_t size) {
11998 _has_bits_[0] |= 0x00000001u;
11999 name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
12000 reinterpret_cast<const char*>(value), size), GetArena());
12001 // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.name)
12002}
12003inline std::string* DBReaderProto::_internal_mutable_name() {
12004 _has_bits_[0] |= 0x00000001u;
12005 return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
12006}
12007inline std::string* DBReaderProto::release_name() {
12008 // @@protoc_insertion_point(field_release:caffe2.DBReaderProto.name)
12009 if (!_internal_has_name()) {
12010 return nullptr;
12011 }
12012 _has_bits_[0] &= ~0x00000001u;
12013 return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
12014}
12015inline void DBReaderProto::set_allocated_name(std::string* name) {
12016 if (name != nullptr) {
12017 _has_bits_[0] |= 0x00000001u;
12018 } else {
12019 _has_bits_[0] &= ~0x00000001u;
12020 }
12021 name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
12022 GetArena());
12023 // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.name)
12024}
12025
12026// optional string source = 2;
12027inline bool DBReaderProto::_internal_has_source() const {
12028 bool value = (_has_bits_[0] & 0x00000002u) != 0;
12029 return value;
12030}
12031inline bool DBReaderProto::has_source() const {
12032 return _internal_has_source();
12033}
12034inline void DBReaderProto::clear_source() {
12035 source_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
12036 _has_bits_[0] &= ~0x00000002u;
12037}
12038inline const std::string& DBReaderProto::source() const {
12039 // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.source)
12040 return _internal_source();
12041}
12042inline void DBReaderProto::set_source(const std::string& value) {
12043 _internal_set_source(value);
12044 // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.source)
12045}
12046inline std::string* DBReaderProto::mutable_source() {
12047 // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.source)
12048 return _internal_mutable_source();
12049}
12050inline const std::string& DBReaderProto::_internal_source() const {
12051 return source_.Get();
12052}
12053inline void DBReaderProto::_internal_set_source(const std::string& value) {
12054 _has_bits_[0] |= 0x00000002u;
12055 source_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
12056}
12057inline void DBReaderProto::set_source(std::string&& value) {
12058 _has_bits_[0] |= 0x00000002u;
12059 source_.Set(
12060 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
12061 // @@protoc_insertion_point(field_set_rvalue:caffe2.DBReaderProto.source)
12062}
12063inline void DBReaderProto::set_source(const char* value) {
12064 GOOGLE_DCHECK(value != nullptr);
12065 _has_bits_[0] |= 0x00000002u;
12066 source_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
12067 GetArena());
12068 // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.source)
12069}
12070inline void DBReaderProto::set_source(const char* value,
12071 size_t size) {
12072 _has_bits_[0] |= 0x00000002u;
12073 source_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
12074 reinterpret_cast<const char*>(value), size), GetArena());
12075 // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.source)
12076}
12077inline std::string* DBReaderProto::_internal_mutable_source() {
12078 _has_bits_[0] |= 0x00000002u;
12079 return source_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
12080}
12081inline std::string* DBReaderProto::release_source() {
12082 // @@protoc_insertion_point(field_release:caffe2.DBReaderProto.source)
12083 if (!_internal_has_source()) {
12084 return nullptr;
12085 }
12086 _has_bits_[0] &= ~0x00000002u;
12087 return source_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
12088}
12089inline void DBReaderProto::set_allocated_source(std::string* source) {
12090 if (source != nullptr) {
12091 _has_bits_[0] |= 0x00000002u;
12092 } else {
12093 _has_bits_[0] &= ~0x00000002u;
12094 }
12095 source_.SetAllocated(&GetEmptyStringAlreadyInited(), source,
12096 GetArena());
12097 // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.source)
12098}
12099
12100// optional string db_type = 3;
12101inline bool DBReaderProto::_internal_has_db_type() const {
12102 bool value = (_has_bits_[0] & 0x00000004u) != 0;
12103 return value;
12104}
12105inline bool DBReaderProto::has_db_type() const {
12106 return _internal_has_db_type();
12107}
12108inline void DBReaderProto::clear_db_type() {
12109 db_type_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
12110 _has_bits_[0] &= ~0x00000004u;
12111}
12112inline const std::string& DBReaderProto::db_type() const {
12113 // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.db_type)
12114 return _internal_db_type();
12115}
12116inline void DBReaderProto::set_db_type(const std::string& value) {
12117 _internal_set_db_type(value);
12118 // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.db_type)
12119}
12120inline std::string* DBReaderProto::mutable_db_type() {
12121 // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.db_type)
12122 return _internal_mutable_db_type();
12123}
12124inline const std::string& DBReaderProto::_internal_db_type() const {
12125 return db_type_.Get();
12126}
12127inline void DBReaderProto::_internal_set_db_type(const std::string& value) {
12128 _has_bits_[0] |= 0x00000004u;
12129 db_type_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
12130}
12131inline void DBReaderProto::set_db_type(std::string&& value) {
12132 _has_bits_[0] |= 0x00000004u;
12133 db_type_.Set(
12134 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
12135 // @@protoc_insertion_point(field_set_rvalue:caffe2.DBReaderProto.db_type)
12136}
12137inline void DBReaderProto::set_db_type(const char* value) {
12138 GOOGLE_DCHECK(value != nullptr);
12139 _has_bits_[0] |= 0x00000004u;
12140 db_type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
12141 GetArena());
12142 // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.db_type)
12143}
12144inline void DBReaderProto::set_db_type(const char* value,
12145 size_t size) {
12146 _has_bits_[0] |= 0x00000004u;
12147 db_type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
12148 reinterpret_cast<const char*>(value), size), GetArena());
12149 // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.db_type)
12150}
12151inline std::string* DBReaderProto::_internal_mutable_db_type() {
12152 _has_bits_[0] |= 0x00000004u;
12153 return db_type_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
12154}
12155inline std::string* DBReaderProto::release_db_type() {
12156 // @@protoc_insertion_point(field_release:caffe2.DBReaderProto.db_type)
12157 if (!_internal_has_db_type()) {
12158 return nullptr;
12159 }
12160 _has_bits_[0] &= ~0x00000004u;
12161 return db_type_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
12162}
12163inline void DBReaderProto::set_allocated_db_type(std::string* db_type) {
12164 if (db_type != nullptr) {
12165 _has_bits_[0] |= 0x00000004u;
12166 } else {
12167 _has_bits_[0] &= ~0x00000004u;
12168 }
12169 db_type_.SetAllocated(&GetEmptyStringAlreadyInited(), db_type,
12170 GetArena());
12171 // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.db_type)
12172}
12173
12174// optional string key = 4;
12175inline bool DBReaderProto::_internal_has_key() const {
12176 bool value = (_has_bits_[0] & 0x00000008u) != 0;
12177 return value;
12178}
12179inline bool DBReaderProto::has_key() const {
12180 return _internal_has_key();
12181}
12182inline void DBReaderProto::clear_key() {
12183 key_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
12184 _has_bits_[0] &= ~0x00000008u;
12185}
12186inline const std::string& DBReaderProto::key() const {
12187 // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.key)
12188 return _internal_key();
12189}
12190inline void DBReaderProto::set_key(const std::string& value) {
12191 _internal_set_key(value);
12192 // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.key)
12193}
12194inline std::string* DBReaderProto::mutable_key() {
12195 // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.key)
12196 return _internal_mutable_key();
12197}
12198inline const std::string& DBReaderProto::_internal_key() const {
12199 return key_.Get();
12200}
12201inline void DBReaderProto::_internal_set_key(const std::string& value) {
12202 _has_bits_[0] |= 0x00000008u;
12203 key_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
12204}
12205inline void DBReaderProto::set_key(std::string&& value) {
12206 _has_bits_[0] |= 0x00000008u;
12207 key_.Set(
12208 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
12209 // @@protoc_insertion_point(field_set_rvalue:caffe2.DBReaderProto.key)
12210}
12211inline void DBReaderProto::set_key(const char* value) {
12212 GOOGLE_DCHECK(value != nullptr);
12213 _has_bits_[0] |= 0x00000008u;
12214 key_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
12215 GetArena());
12216 // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.key)
12217}
12218inline void DBReaderProto::set_key(const char* value,
12219 size_t size) {
12220 _has_bits_[0] |= 0x00000008u;
12221 key_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
12222 reinterpret_cast<const char*>(value), size), GetArena());
12223 // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.key)
12224}
12225inline std::string* DBReaderProto::_internal_mutable_key() {
12226 _has_bits_[0] |= 0x00000008u;
12227 return key_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
12228}
12229inline std::string* DBReaderProto::release_key() {
12230 // @@protoc_insertion_point(field_release:caffe2.DBReaderProto.key)
12231 if (!_internal_has_key()) {
12232 return nullptr;
12233 }
12234 _has_bits_[0] &= ~0x00000008u;
12235 return key_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
12236}
12237inline void DBReaderProto::set_allocated_key(std::string* key) {
12238 if (key != nullptr) {
12239 _has_bits_[0] |= 0x00000008u;
12240 } else {
12241 _has_bits_[0] &= ~0x00000008u;
12242 }
12243 key_.SetAllocated(&GetEmptyStringAlreadyInited(), key,
12244 GetArena());
12245 // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.key)
12246}
12247
12248// -------------------------------------------------------------------
12249
12250// BlobSerializationOptions
12251
12252// optional string blob_name_regex = 1;
12253inline bool BlobSerializationOptions::_internal_has_blob_name_regex() const {
12254 bool value = (_has_bits_[0] & 0x00000001u) != 0;
12255 return value;
12256}
12257inline bool BlobSerializationOptions::has_blob_name_regex() const {
12258 return _internal_has_blob_name_regex();
12259}
12260inline void BlobSerializationOptions::clear_blob_name_regex() {
12261 blob_name_regex_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
12262 _has_bits_[0] &= ~0x00000001u;
12263}
12264inline const std::string& BlobSerializationOptions::blob_name_regex() const {
12265 // @@protoc_insertion_point(field_get:caffe2.BlobSerializationOptions.blob_name_regex)
12266 return _internal_blob_name_regex();
12267}
12268inline void BlobSerializationOptions::set_blob_name_regex(const std::string& value) {
12269 _internal_set_blob_name_regex(value);
12270 // @@protoc_insertion_point(field_set:caffe2.BlobSerializationOptions.blob_name_regex)
12271}
12272inline std::string* BlobSerializationOptions::mutable_blob_name_regex() {
12273 // @@protoc_insertion_point(field_mutable:caffe2.BlobSerializationOptions.blob_name_regex)
12274 return _internal_mutable_blob_name_regex();
12275}
12276inline const std::string& BlobSerializationOptions::_internal_blob_name_regex() const {
12277 return blob_name_regex_.Get();
12278}
12279inline void BlobSerializationOptions::_internal_set_blob_name_regex(const std::string& value) {
12280 _has_bits_[0] |= 0x00000001u;
12281 blob_name_regex_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
12282}
12283inline void BlobSerializationOptions::set_blob_name_regex(std::string&& value) {
12284 _has_bits_[0] |= 0x00000001u;
12285 blob_name_regex_.Set(
12286 &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
12287 // @@protoc_insertion_point(field_set_rvalue:caffe2.BlobSerializationOptions.blob_name_regex)
12288}
12289inline void BlobSerializationOptions::set_blob_name_regex(const char* value) {
12290 GOOGLE_DCHECK(value != nullptr);
12291 _has_bits_[0] |= 0x00000001u;
12292 blob_name_regex_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
12293 GetArena());
12294 // @@protoc_insertion_point(field_set_char:caffe2.BlobSerializationOptions.blob_name_regex)
12295}
12296inline void BlobSerializationOptions::set_blob_name_regex(const char* value,
12297 size_t size) {
12298 _has_bits_[0] |= 0x00000001u;
12299 blob_name_regex_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
12300 reinterpret_cast<const char*>(value), size), GetArena());
12301 // @@protoc_insertion_point(field_set_pointer:caffe2.BlobSerializationOptions.blob_name_regex)
12302}
12303inline std::string* BlobSerializationOptions::_internal_mutable_blob_name_regex() {
12304 _has_bits_[0] |= 0x00000001u;
12305 return blob_name_regex_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
12306}
12307inline std::string* BlobSerializationOptions::release_blob_name_regex() {
12308 // @@protoc_insertion_point(field_release:caffe2.BlobSerializationOptions.blob_name_regex)
12309 if (!_internal_has_blob_name_regex()) {
12310 return nullptr;
12311 }
12312 _has_bits_[0] &= ~0x00000001u;
12313 return blob_name_regex_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
12314}
12315inline void BlobSerializationOptions::set_allocated_blob_name_regex(std::string* blob_name_regex) {
12316 if (blob_name_regex != nullptr) {
12317 _has_bits_[0] |= 0x00000001u;
12318 } else {
12319 _has_bits_[0] &= ~0x00000001u;
12320 }
12321 blob_name_regex_.SetAllocated(&GetEmptyStringAlreadyInited(), blob_name_regex,
12322 GetArena());
12323 // @@protoc_insertion_point(field_set_allocated:caffe2.BlobSerializationOptions.blob_name_regex)
12324}
12325
12326// optional int64 chunk_size = 2;
12327inline bool BlobSerializationOptions::_internal_has_chunk_size() const {
12328 bool value = (_has_bits_[0] & 0x00000002u) != 0;
12329 return value;
12330}
12331inline bool BlobSerializationOptions::has_chunk_size() const {
12332 return _internal_has_chunk_size();
12333}
12334inline void BlobSerializationOptions::clear_chunk_size() {
12335 chunk_size_ = PROTOBUF_LONGLONG(0);
12336 _has_bits_[0] &= ~0x00000002u;
12337}
12338inline ::PROTOBUF_NAMESPACE_ID::int64 BlobSerializationOptions::_internal_chunk_size() const {
12339 return chunk_size_;
12340}
12341inline ::PROTOBUF_NAMESPACE_ID::int64 BlobSerializationOptions::chunk_size() const {
12342 // @@protoc_insertion_point(field_get:caffe2.BlobSerializationOptions.chunk_size)
12343 return _internal_chunk_size();
12344}
12345inline void BlobSerializationOptions::_internal_set_chunk_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
12346 _has_bits_[0] |= 0x00000002u;
12347 chunk_size_ = value;
12348}
12349inline void BlobSerializationOptions::set_chunk_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
12350 _internal_set_chunk_size(value);
12351 // @@protoc_insertion_point(field_set:caffe2.BlobSerializationOptions.chunk_size)
12352}
12353
12354// optional .caffe2.BlobSerializationOptions.FloatFormat float_format = 3;
12355inline bool BlobSerializationOptions::_internal_has_float_format() const {
12356 bool value = (_has_bits_[0] & 0x00000004u) != 0;
12357 return value;
12358}
12359inline bool BlobSerializationOptions::has_float_format() const {
12360 return _internal_has_float_format();
12361}
12362inline void BlobSerializationOptions::clear_float_format() {
12363 float_format_ = 0;
12364 _has_bits_[0] &= ~0x00000004u;
12365}
12366inline ::caffe2::BlobSerializationOptions_FloatFormat BlobSerializationOptions::_internal_float_format() const {
12367 return static_cast< ::caffe2::BlobSerializationOptions_FloatFormat >(float_format_);
12368}
12369inline ::caffe2::BlobSerializationOptions_FloatFormat BlobSerializationOptions::float_format() const {
12370 // @@protoc_insertion_point(field_get:caffe2.BlobSerializationOptions.float_format)
12371 return _internal_float_format();
12372}
12373inline void BlobSerializationOptions::_internal_set_float_format(::caffe2::BlobSerializationOptions_FloatFormat value) {
12374 assert(::caffe2::BlobSerializationOptions_FloatFormat_IsValid(value));
12375 _has_bits_[0] |= 0x00000004u;
12376 float_format_ = value;
12377}
12378inline void BlobSerializationOptions::set_float_format(::caffe2::BlobSerializationOptions_FloatFormat value) {
12379 _internal_set_float_format(value);
12380 // @@protoc_insertion_point(field_set:caffe2.BlobSerializationOptions.float_format)
12381}
12382
12383// -------------------------------------------------------------------
12384
12385// SerializationOptions
12386
12387// repeated .caffe2.BlobSerializationOptions options = 1;
12388inline int SerializationOptions::_internal_options_size() const {
12389 return options_.size();
12390}
12391inline int SerializationOptions::options_size() const {
12392 return _internal_options_size();
12393}
12394inline void SerializationOptions::clear_options() {
12395 options_.Clear();
12396}
12397inline ::caffe2::BlobSerializationOptions* SerializationOptions::mutable_options(int index) {
12398 // @@protoc_insertion_point(field_mutable:caffe2.SerializationOptions.options)
12399 return options_.Mutable(index);
12400}
12401inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions >*
12402SerializationOptions::mutable_options() {
12403 // @@protoc_insertion_point(field_mutable_list:caffe2.SerializationOptions.options)
12404 return &options_;
12405}
12406inline const ::caffe2::BlobSerializationOptions& SerializationOptions::_internal_options(int index) const {
12407 return options_.Get(index);
12408}
12409inline const ::caffe2::BlobSerializationOptions& SerializationOptions::options(int index) const {
12410 // @@protoc_insertion_point(field_get:caffe2.SerializationOptions.options)
12411 return _internal_options(index);
12412}
12413inline ::caffe2::BlobSerializationOptions* SerializationOptions::_internal_add_options() {
12414 return options_.Add();
12415}
12416inline ::caffe2::BlobSerializationOptions* SerializationOptions::add_options() {
12417 // @@protoc_insertion_point(field_add:caffe2.SerializationOptions.options)
12418 return _internal_add_options();
12419}
12420inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions >&
12421SerializationOptions::options() const {
12422 // @@protoc_insertion_point(field_list:caffe2.SerializationOptions.options)
12423 return options_;
12424}
12425
12426#ifdef __GNUC__
12427 #pragma GCC diagnostic pop
12428#endif // __GNUC__
12429// -------------------------------------------------------------------
12430
12431// -------------------------------------------------------------------
12432
12433// -------------------------------------------------------------------
12434
12435// -------------------------------------------------------------------
12436
12437// -------------------------------------------------------------------
12438
12439// -------------------------------------------------------------------
12440
12441// -------------------------------------------------------------------
12442
12443// -------------------------------------------------------------------
12444
12445// -------------------------------------------------------------------
12446
12447// -------------------------------------------------------------------
12448
12449// -------------------------------------------------------------------
12450
12451// -------------------------------------------------------------------
12452
12453// -------------------------------------------------------------------
12454
12455// -------------------------------------------------------------------
12456
12457// -------------------------------------------------------------------
12458
12459// -------------------------------------------------------------------
12460
12461// -------------------------------------------------------------------
12462
12463// -------------------------------------------------------------------
12464
12465// -------------------------------------------------------------------
12466
12467// -------------------------------------------------------------------
12468
12469// -------------------------------------------------------------------
12470
12471
12472// @@protoc_insertion_point(namespace_scope)
12473
12474} // namespace caffe2
12475
12476PROTOBUF_NAMESPACE_OPEN
12477
12478template <> struct is_proto_enum< ::caffe2::TensorProto_DataType> : ::std::true_type {};
12479template <>
12480inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::TensorProto_DataType>() {
12481 return ::caffe2::TensorProto_DataType_descriptor();
12482}
12483template <> struct is_proto_enum< ::caffe2::TensorProto_SerializationFormat> : ::std::true_type {};
12484template <>
12485inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::TensorProto_SerializationFormat>() {
12486 return ::caffe2::TensorProto_SerializationFormat_descriptor();
12487}
12488template <> struct is_proto_enum< ::caffe2::TensorBoundShape_DimType> : ::std::true_type {};
12489template <>
12490inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::TensorBoundShape_DimType>() {
12491 return ::caffe2::TensorBoundShape_DimType_descriptor();
12492}
12493template <> struct is_proto_enum< ::caffe2::BlobSerializationOptions_FloatFormat> : ::std::true_type {};
12494template <>
12495inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::BlobSerializationOptions_FloatFormat>() {
12496 return ::caffe2::BlobSerializationOptions_FloatFormat_descriptor();
12497}
12498template <> struct is_proto_enum< ::caffe2::DeviceTypeProto> : ::std::true_type {};
12499template <>
12500inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::DeviceTypeProto>() {
12501 return ::caffe2::DeviceTypeProto_descriptor();
12502}
12503
12504PROTOBUF_NAMESPACE_CLOSE
12505
12506// @@protoc_insertion_point(global_scope)
12507
12508#include <google/protobuf/port_undef.inc>
12509#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_caffe2_2fproto_2fcaffe2_2eproto
12510