FM / proto

/usr/local/lib64/python3.6/site-packages/torch/include/caffe2/proto/

/usr/local/lib64/python3.6/site-packages/torch/include/caffe2/proto

Name	Size	Mode	Actions
caffe2.pb.h	465301	0644	edit dl rm
caffe2_legacy.pb.h	22203	0644	edit dl rm
caffe2_pb.h	4273	0644	edit dl rm
hsm.pb.h	56051	0644	edit dl rm
metanet.pb.h	113680	0644	edit dl rm
predictor_consts.pb.h	78949	0644	edit dl rm
prof_dag.pb.h	77224	0644	edit dl rm
torch.pb.h	128847	0644	edit dl rm
torch_pb.h	206	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/torch/include/caffe2/proto/caffe2.pb.h (465301B)

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: caffe2/proto/caffe2.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_caffe2_2fproto_2fcaffe2_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_caffe2_2fproto_2fcaffe2_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3013000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3013000 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_caffe2_2fproto_2fcaffe2_2eproto TORCH_API
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TORCH_API TableStruct_caffe2_2fproto_2fcaffe2_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[22]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern TORCH_API const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_caffe2_2fproto_2fcaffe2_2eproto;
namespace caffe2 { const ::std::string& GetEmptyStringAlreadyInited(); 
class AOTConfig;
class AOTConfigDefaultTypeInternal;
TORCH_API extern AOTConfigDefaultTypeInternal _AOTConfig_default_instance_;
class Argument;
class ArgumentDefaultTypeInternal;
TORCH_API extern ArgumentDefaultTypeInternal _Argument_default_instance_;
class BackendOptions;
class BackendOptionsDefaultTypeInternal;
TORCH_API extern BackendOptionsDefaultTypeInternal _BackendOptions_default_instance_;
class BlobProto;
class BlobProtoDefaultTypeInternal;
TORCH_API extern BlobProtoDefaultTypeInternal _BlobProto_default_instance_;
class BlobSerializationOptions;
class BlobSerializationOptionsDefaultTypeInternal;
TORCH_API extern BlobSerializationOptionsDefaultTypeInternal _BlobSerializationOptions_default_instance_;
class DBReaderProto;
class DBReaderProtoDefaultTypeInternal;
TORCH_API extern DBReaderProtoDefaultTypeInternal _DBReaderProto_default_instance_;
class DeviceOption;
class DeviceOptionDefaultTypeInternal;
TORCH_API extern DeviceOptionDefaultTypeInternal _DeviceOption_default_instance_;
class ExecutionStep;
class ExecutionStepDefaultTypeInternal;
TORCH_API extern ExecutionStepDefaultTypeInternal _ExecutionStep_default_instance_;
class MapFieldEntry;
class MapFieldEntryDefaultTypeInternal;
TORCH_API extern MapFieldEntryDefaultTypeInternal _MapFieldEntry_default_instance_;
class NetDef;
class NetDefDefaultTypeInternal;
TORCH_API extern NetDefDefaultTypeInternal _NetDef_default_instance_;
class OperatorDef;
class OperatorDefDefaultTypeInternal;
TORCH_API extern OperatorDefDefaultTypeInternal _OperatorDef_default_instance_;
class PartitionInfo;
class PartitionInfoDefaultTypeInternal;
TORCH_API extern PartitionInfoDefaultTypeInternal _PartitionInfo_default_instance_;
class PlanDef;
class PlanDefDefaultTypeInternal;
TORCH_API extern PlanDefDefaultTypeInternal _PlanDef_default_instance_;
class QTensorProto;
class QTensorProtoDefaultTypeInternal;
TORCH_API extern QTensorProtoDefaultTypeInternal _QTensorProto_default_instance_;
class SerializationOptions;
class SerializationOptionsDefaultTypeInternal;
TORCH_API extern SerializationOptionsDefaultTypeInternal _SerializationOptions_default_instance_;
class TensorBoundShape;
class TensorBoundShapeDefaultTypeInternal;
TORCH_API extern TensorBoundShapeDefaultTypeInternal _TensorBoundShape_default_instance_;
class TensorBoundShapes;
class TensorBoundShapesDefaultTypeInternal;
TORCH_API extern TensorBoundShapesDefaultTypeInternal _TensorBoundShapes_default_instance_;
class TensorProto;
class TensorProtoDefaultTypeInternal;
TORCH_API extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
class TensorProto_Segment;
class TensorProto_SegmentDefaultTypeInternal;
TORCH_API extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_;
class TensorProtos;
class TensorProtosDefaultTypeInternal;
TORCH_API extern TensorProtosDefaultTypeInternal _TensorProtos_default_instance_;
class TensorShape;
class TensorShapeDefaultTypeInternal;
TORCH_API extern TensorShapeDefaultTypeInternal _TensorShape_default_instance_;
class TensorShapes;
class TensorShapesDefaultTypeInternal;
TORCH_API extern TensorShapesDefaultTypeInternal _TensorShapes_default_instance_;
}  // namespace caffe2
PROTOBUF_NAMESPACE_OPEN
template<> TORCH_API ::caffe2::AOTConfig* Arena::CreateMaybeMessage<::caffe2::AOTConfig>(Arena*);
template<> TORCH_API ::caffe2::Argument* Arena::CreateMaybeMessage<::caffe2::Argument>(Arena*);
template<> TORCH_API ::caffe2::BackendOptions* Arena::CreateMaybeMessage<::caffe2::BackendOptions>(Arena*);
template<> TORCH_API ::caffe2::BlobProto* Arena::CreateMaybeMessage<::caffe2::BlobProto>(Arena*);
template<> TORCH_API ::caffe2::BlobSerializationOptions* Arena::CreateMaybeMessage<::caffe2::BlobSerializationOptions>(Arena*);
template<> TORCH_API ::caffe2::DBReaderProto* Arena::CreateMaybeMessage<::caffe2::DBReaderProto>(Arena*);
template<> TORCH_API ::caffe2::DeviceOption* Arena::CreateMaybeMessage<::caffe2::DeviceOption>(Arena*);
template<> TORCH_API ::caffe2::ExecutionStep* Arena::CreateMaybeMessage<::caffe2::ExecutionStep>(Arena*);
template<> TORCH_API ::caffe2::MapFieldEntry* Arena::CreateMaybeMessage<::caffe2::MapFieldEntry>(Arena*);
template<> TORCH_API ::caffe2::NetDef* Arena::CreateMaybeMessage<::caffe2::NetDef>(Arena*);
template<> TORCH_API ::caffe2::OperatorDef* Arena::CreateMaybeMessage<::caffe2::OperatorDef>(Arena*);
template<> TORCH_API ::caffe2::PartitionInfo* Arena::CreateMaybeMessage<::caffe2::PartitionInfo>(Arena*);
template<> TORCH_API ::caffe2::PlanDef* Arena::CreateMaybeMessage<::caffe2::PlanDef>(Arena*);
template<> TORCH_API ::caffe2::QTensorProto* Arena::CreateMaybeMessage<::caffe2::QTensorProto>(Arena*);
template<> TORCH_API ::caffe2::SerializationOptions* Arena::CreateMaybeMessage<::caffe2::SerializationOptions>(Arena*);
template<> TORCH_API ::caffe2::TensorBoundShape* Arena::CreateMaybeMessage<::caffe2::TensorBoundShape>(Arena*);
template<> TORCH_API ::caffe2::TensorBoundShapes* Arena::CreateMaybeMessage<::caffe2::TensorBoundShapes>(Arena*);
template<> TORCH_API ::caffe2::TensorProto* Arena::CreateMaybeMessage<::caffe2::TensorProto>(Arena*);
template<> TORCH_API ::caffe2::TensorProto_Segment* Arena::CreateMaybeMessage<::caffe2::TensorProto_Segment>(Arena*);
template<> TORCH_API ::caffe2::TensorProtos* Arena::CreateMaybeMessage<::caffe2::TensorProtos>(Arena*);
template<> TORCH_API ::caffe2::TensorShape* Arena::CreateMaybeMessage<::caffe2::TensorShape>(Arena*);
template<> TORCH_API ::caffe2::TensorShapes* Arena::CreateMaybeMessage<::caffe2::TensorShapes>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace caffe2 {

enum TensorProto_DataType : int {
  TensorProto_DataType_UNDEFINED = 0,
  TensorProto_DataType_FLOAT = 1,
  TensorProto_DataType_INT32 = 2,
  TensorProto_DataType_BYTE = 3,
  TensorProto_DataType_STRING = 4,
  TensorProto_DataType_BOOL = 5,
  TensorProto_DataType_UINT8 = 6,
  TensorProto_DataType_INT8 = 7,
  TensorProto_DataType_UINT16 = 8,
  TensorProto_DataType_INT16 = 9,
  TensorProto_DataType_INT64 = 10,
  TensorProto_DataType_FLOAT16 = 12,
  TensorProto_DataType_DOUBLE = 13,
  TensorProto_DataType_ZERO_COLLISION_HASH = 14,
  TensorProto_DataType_REBATCHING_BUFFER = 15
};
TORCH_API bool TensorProto_DataType_IsValid(int value);
constexpr TensorProto_DataType TensorProto_DataType_DataType_MIN = TensorProto_DataType_UNDEFINED;
constexpr TensorProto_DataType TensorProto_DataType_DataType_MAX = TensorProto_DataType_REBATCHING_BUFFER;
constexpr int TensorProto_DataType_DataType_ARRAYSIZE = static_cast<int>(TensorProto_DataType_DataType_MAX) + 1;

TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TensorProto_DataType_descriptor();
template<typename T>
inline const std::string& TensorProto_DataType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TensorProto_DataType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TensorProto_DataType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TensorProto_DataType_descriptor(), enum_t_value);
}
inline bool TensorProto_DataType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TensorProto_DataType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TensorProto_DataType>(
    TensorProto_DataType_descriptor(), name, value);
}
enum TensorProto_SerializationFormat : int {
  TensorProto_SerializationFormat_FMT_PROTOBUF = 0,
  TensorProto_SerializationFormat_FMT_BFLOAT16 = 1
};
TORCH_API bool TensorProto_SerializationFormat_IsValid(int value);
constexpr TensorProto_SerializationFormat TensorProto_SerializationFormat_SerializationFormat_MIN = TensorProto_SerializationFormat_FMT_PROTOBUF;
constexpr TensorProto_SerializationFormat TensorProto_SerializationFormat_SerializationFormat_MAX = TensorProto_SerializationFormat_FMT_BFLOAT16;
constexpr int TensorProto_SerializationFormat_SerializationFormat_ARRAYSIZE = static_cast<int>(TensorProto_SerializationFormat_SerializationFormat_MAX) + 1;

TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TensorProto_SerializationFormat_descriptor();
template<typename T>
inline const std::string& TensorProto_SerializationFormat_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TensorProto_SerializationFormat>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TensorProto_SerializationFormat_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TensorProto_SerializationFormat_descriptor(), enum_t_value);
}
inline bool TensorProto_SerializationFormat_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TensorProto_SerializationFormat* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TensorProto_SerializationFormat>(
    TensorProto_SerializationFormat_descriptor(), name, value);
}
enum TensorBoundShape_DimType : int {
  TensorBoundShape_DimType_UNKNOWN = 0,
  TensorBoundShape_DimType_CONSTANT = 1,
  TensorBoundShape_DimType_BATCH = 2,
  TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX = 3,
  TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX_DEFAULT = 4,
  TensorBoundShape_DimType_FEATURE_MAX = 5,
  TensorBoundShape_DimType_FEATURE_MAX_DEFAULT = 6
};
TORCH_API bool TensorBoundShape_DimType_IsValid(int value);
constexpr TensorBoundShape_DimType TensorBoundShape_DimType_DimType_MIN = TensorBoundShape_DimType_UNKNOWN;
constexpr TensorBoundShape_DimType TensorBoundShape_DimType_DimType_MAX = TensorBoundShape_DimType_FEATURE_MAX_DEFAULT;
constexpr int TensorBoundShape_DimType_DimType_ARRAYSIZE = static_cast<int>(TensorBoundShape_DimType_DimType_MAX) + 1;

TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TensorBoundShape_DimType_descriptor();
template<typename T>
inline const std::string& TensorBoundShape_DimType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TensorBoundShape_DimType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TensorBoundShape_DimType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TensorBoundShape_DimType_descriptor(), enum_t_value);
}
inline bool TensorBoundShape_DimType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TensorBoundShape_DimType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TensorBoundShape_DimType>(
    TensorBoundShape_DimType_descriptor(), name, value);
}
enum BlobSerializationOptions_FloatFormat : int {
  BlobSerializationOptions_FloatFormat_FLOAT_DEFAULT = 0,
  BlobSerializationOptions_FloatFormat_FLOAT_PROTOBUF = 1,
  BlobSerializationOptions_FloatFormat_FLOAT_BFLOAT16 = 2
};
TORCH_API bool BlobSerializationOptions_FloatFormat_IsValid(int value);
constexpr BlobSerializationOptions_FloatFormat BlobSerializationOptions_FloatFormat_FloatFormat_MIN = BlobSerializationOptions_FloatFormat_FLOAT_DEFAULT;
constexpr BlobSerializationOptions_FloatFormat BlobSerializationOptions_FloatFormat_FloatFormat_MAX = BlobSerializationOptions_FloatFormat_FLOAT_BFLOAT16;
constexpr int BlobSerializationOptions_FloatFormat_FloatFormat_ARRAYSIZE = static_cast<int>(BlobSerializationOptions_FloatFormat_FloatFormat_MAX) + 1;

TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BlobSerializationOptions_FloatFormat_descriptor();
template<typename T>
inline const std::string& BlobSerializationOptions_FloatFormat_Name(T enum_t_value) {
  static_assert(::std::is_same<T, BlobSerializationOptions_FloatFormat>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function BlobSerializationOptions_FloatFormat_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    BlobSerializationOptions_FloatFormat_descriptor(), enum_t_value);
}
inline bool BlobSerializationOptions_FloatFormat_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BlobSerializationOptions_FloatFormat* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BlobSerializationOptions_FloatFormat>(
    BlobSerializationOptions_FloatFormat_descriptor(), name, value);
}
enum DeviceTypeProto : int {
  PROTO_CPU = 0,
  PROTO_CUDA = 1,
  PROTO_MKLDNN = 2,
  PROTO_OPENGL = 3,
  PROTO_OPENCL = 4,
  PROTO_IDEEP = 5,
  PROTO_HIP = 6,
  PROTO_FPGA = 7,
  PROTO_ORT = 8,
  PROTO_XLA = 9,
  PROTO_MLC = 10,
  PROTO_COMPILE_TIME_MAX_DEVICE_TYPES = 11
};
TORCH_API bool DeviceTypeProto_IsValid(int value);
constexpr DeviceTypeProto DeviceTypeProto_MIN = PROTO_CPU;
constexpr DeviceTypeProto DeviceTypeProto_MAX = PROTO_COMPILE_TIME_MAX_DEVICE_TYPES;
constexpr int DeviceTypeProto_ARRAYSIZE = static_cast<int>(DeviceTypeProto_MAX) + 1;

TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceTypeProto_descriptor();
template<typename T>
inline const std::string& DeviceTypeProto_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DeviceTypeProto>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DeviceTypeProto_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DeviceTypeProto_descriptor(), enum_t_value);
}
inline bool DeviceTypeProto_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceTypeProto* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceTypeProto>(
    DeviceTypeProto_descriptor(), name, value);
}
// ===================================================================

class TORCH_API TensorProto_Segment PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorProto.Segment) */ {
 public:
  inline TensorProto_Segment() : TensorProto_Segment(nullptr) {}
  virtual ~TensorProto_Segment();

TensorProto_Segment(const TensorProto_Segment& from);
  TensorProto_Segment(TensorProto_Segment&& from) noexcept
    : TensorProto_Segment() {
    *this = ::std::move(from);
  }

inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
    CopyFrom(from);
    return *this;
  }
  inline TensorProto_Segment& operator=(TensorProto_Segment&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TensorProto_Segment& default_instance();

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TensorProto_Segment* internal_default_instance() {
    return reinterpret_cast<const TensorProto_Segment*>(
               &_TensorProto_Segment_default_instance_);
  }
  static int const kIndexInFileMessages =
    0;

friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) {
    a.Swap(&b);
  }
  inline void Swap(TensorProto_Segment* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TensorProto_Segment* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline TensorProto_Segment* New() const final {
    return CreateMaybeMessage<TensorProto_Segment>(nullptr);
  }

TensorProto_Segment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TensorProto_Segment>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TensorProto_Segment& from);
  void MergeFrom(const TensorProto_Segment& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TensorProto_Segment* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.TensorProto.Segment";
  }
  protected:
  explicit TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto);
    return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages];
  }

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kBeginFieldNumber = 1,
    kEndFieldNumber = 2,
  };
  // required int64 begin = 1;
  bool has_begin() const;
  private:
  bool _internal_has_begin() const;
  public:
  void clear_begin();
  ::PROTOBUF_NAMESPACE_ID::int64 begin() const;
  void set_begin(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_begin() const;
  void _internal_set_begin(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

// required int64 end = 2;
  bool has_end() const;
  private:
  bool _internal_has_end() const;
  public:
  void clear_end();
  ::PROTOBUF_NAMESPACE_ID::int64 end() const;
  void set_end(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_end() const;
  void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.TensorProto.Segment)
 private:
  class _Internal;

// helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

class TORCH_API TensorProto PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorProto) */ {
 public:
  inline TensorProto() : TensorProto(nullptr) {}
  virtual ~TensorProto();

TensorProto(const TensorProto& from);
  TensorProto(TensorProto&& from) noexcept
    : TensorProto() {
    *this = ::std::move(from);
  }

inline TensorProto& operator=(const TensorProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline TensorProto& operator=(TensorProto&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TensorProto* internal_default_instance() {
    return reinterpret_cast<const TensorProto*>(
               &_TensorProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    1;

friend void swap(TensorProto& a, TensorProto& b) {
    a.Swap(&b);
  }
  inline void Swap(TensorProto* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TensorProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline TensorProto* New() const final {
    return CreateMaybeMessage<TensorProto>(nullptr);
  }

TensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TensorProto>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TensorProto& from);
  void MergeFrom(const TensorProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TensorProto* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.TensorProto";
  }
  protected:
  explicit TensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

typedef TensorProto_Segment Segment;

typedef TensorProto_DataType DataType;
  static DataType const UNDEFINED =
    TensorProto_DataType_UNDEFINED;
  static DataType const FLOAT =
    TensorProto_DataType_FLOAT;
  static DataType const INT32 =
    TensorProto_DataType_INT32;
  static DataType const BYTE =
    TensorProto_DataType_BYTE;
  static DataType const STRING =
    TensorProto_DataType_STRING;
  static DataType const BOOL =
    TensorProto_DataType_BOOL;
  static DataType const UINT8 =
    TensorProto_DataType_UINT8;
  static DataType const INT8 =
    TensorProto_DataType_INT8;
  static DataType const UINT16 =
    TensorProto_DataType_UINT16;
  static DataType const INT16 =
    TensorProto_DataType_INT16;
  static DataType const INT64 =
    TensorProto_DataType_INT64;
  static DataType const FLOAT16 =
    TensorProto_DataType_FLOAT16;
  static DataType const DOUBLE =
    TensorProto_DataType_DOUBLE;
  static DataType const ZERO_COLLISION_HASH =
    TensorProto_DataType_ZERO_COLLISION_HASH;
  static DataType const REBATCHING_BUFFER =
    TensorProto_DataType_REBATCHING_BUFFER;
  static inline bool DataType_IsValid(int value) {
    return TensorProto_DataType_IsValid(value);
  }
  static DataType const DataType_MIN =
    TensorProto_DataType_DataType_MIN;
  static DataType const DataType_MAX =
    TensorProto_DataType_DataType_MAX;
  static int const DataType_ARRAYSIZE =
    TensorProto_DataType_DataType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DataType_descriptor() {
    return TensorProto_DataType_descriptor();
  }
  template<typename T>
  static inline const std::string& DataType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DataType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DataType_Name.");
    return TensorProto_DataType_Name(enum_t_value);
  }
  static inline bool DataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DataType* value) {
    return TensorProto_DataType_Parse(name, value);
  }

typedef TensorProto_SerializationFormat SerializationFormat;
  static SerializationFormat const FMT_PROTOBUF =
    TensorProto_SerializationFormat_FMT_PROTOBUF;
  static SerializationFormat const FMT_BFLOAT16 =
    TensorProto_SerializationFormat_FMT_BFLOAT16;
  static inline bool SerializationFormat_IsValid(int value) {
    return TensorProto_SerializationFormat_IsValid(value);
  }
  static SerializationFormat const SerializationFormat_MIN =
    TensorProto_SerializationFormat_SerializationFormat_MIN;
  static SerializationFormat const SerializationFormat_MAX =
    TensorProto_SerializationFormat_SerializationFormat_MAX;
  static int const SerializationFormat_ARRAYSIZE =
    TensorProto_SerializationFormat_SerializationFormat_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  SerializationFormat_descriptor() {
    return TensorProto_SerializationFormat_descriptor();
  }
  template<typename T>
  static inline const std::string& SerializationFormat_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SerializationFormat>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SerializationFormat_Name.");
    return TensorProto_SerializationFormat_Name(enum_t_value);
  }
  static inline bool SerializationFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      SerializationFormat* value) {
    return TensorProto_SerializationFormat_Parse(name, value);
  }

// accessors -------------------------------------------------------

enum : int {
    kDimsFieldNumber = 1,
    kFloatDataFieldNumber = 3,
    kInt32DataFieldNumber = 4,
    kStringDataFieldNumber = 6,
    kDoubleDataFieldNumber = 9,
    kInt64DataFieldNumber = 10,
    kByteDataFieldNumber = 5,
    kNameFieldNumber = 7,
    kRawDataFieldNumber = 13,
    kDeviceDetailFieldNumber = 8,
    kSegmentFieldNumber = 11,
    kDataFormatFieldNumber = 15,
    kDataTypeFieldNumber = 2,
  };
  // repeated int64 dims = 1;
  int dims_size() const;
  private:
  int _internal_dims_size() const;
  public:
  void clear_dims();
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_dims(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      _internal_dims() const;
  void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      _internal_mutable_dims();
  public:
  ::PROTOBUF_NAMESPACE_ID::int64 dims(int index) const;
  void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      dims() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_dims();

// repeated float float_data = 3 [packed = true];
  int float_data_size() const;
  private:
  int _internal_float_data_size() const;
  public:
  void clear_float_data();
  private:
  float _internal_float_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_float_data() const;
  void _internal_add_float_data(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_float_data();
  public:
  float float_data(int index) const;
  void set_float_data(int index, float value);
  void add_float_data(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      float_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_float_data();

// repeated int32 int32_data = 4 [packed = true];
  int int32_data_size() const;
  private:
  int _internal_int32_data_size() const;
  public:
  void clear_int32_data();
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_int32_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      _internal_int32_data() const;
  void _internal_add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      _internal_mutable_int32_data();
  public:
  ::PROTOBUF_NAMESPACE_ID::int32 int32_data(int index) const;
  void set_int32_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
  void add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      int32_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      mutable_int32_data();

// repeated bytes string_data = 6;
  int string_data_size() const;
  private:
  int _internal_string_data_size() const;
  public:
  void clear_string_data();
  const std::string& string_data(int index) const;
  std::string* mutable_string_data(int index);
  void set_string_data(int index, const std::string& value);
  void set_string_data(int index, std::string&& value);
  void set_string_data(int index, const char* value);
  void set_string_data(int index, const void* value, size_t size);
  std::string* add_string_data();
  void add_string_data(const std::string& value);
  void add_string_data(std::string&& value);
  void add_string_data(const char* value);
  void add_string_data(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_data();
  private:
  const std::string& _internal_string_data(int index) const;
  std::string* _internal_add_string_data();
  public:

// repeated double double_data = 9 [packed = true];
  int double_data_size() const;
  private:
  int _internal_double_data_size() const;
  public:
  void clear_double_data();
  private:
  double _internal_double_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_double_data() const;
  void _internal_add_double_data(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_double_data();
  public:
  double double_data(int index) const;
  void set_double_data(int index, double value);
  void add_double_data(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      double_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_double_data();

// repeated int64 int64_data = 10 [packed = true];
  int int64_data_size() const;
  private:
  int _internal_int64_data_size() const;
  public:
  void clear_int64_data();
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_int64_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      _internal_int64_data() const;
  void _internal_add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      _internal_mutable_int64_data();
  public:
  ::PROTOBUF_NAMESPACE_ID::int64 int64_data(int index) const;
  void set_int64_data(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      int64_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_int64_data();

// optional bytes byte_data = 5;
  bool has_byte_data() const;
  private:
  bool _internal_has_byte_data() const;
  public:
  void clear_byte_data();
  const std::string& byte_data() const;
  void set_byte_data(const std::string& value);
  void set_byte_data(std::string&& value);
  void set_byte_data(const char* value);
  void set_byte_data(const void* value, size_t size);
  std::string* mutable_byte_data();
  std::string* release_byte_data();
  void set_allocated_byte_data(std::string* byte_data);
  private:
  const std::string& _internal_byte_data() const;
  void _internal_set_byte_data(const std::string& value);
  std::string* _internal_mutable_byte_data();
  public:

// optional string name = 7;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

// optional bytes raw_data = 13;
  bool has_raw_data() const;
  private:
  bool _internal_has_raw_data() const;
  public:
  void clear_raw_data();
  const std::string& raw_data() const;
  void set_raw_data(const std::string& value);
  void set_raw_data(std::string&& value);
  void set_raw_data(const char* value);
  void set_raw_data(const void* value, size_t size);
  std::string* mutable_raw_data();
  std::string* release_raw_data();
  void set_allocated_raw_data(std::string* raw_data);
  private:
  const std::string& _internal_raw_data() const;
  void _internal_set_raw_data(const std::string& value);
  std::string* _internal_mutable_raw_data();
  public:

// optional .caffe2.DeviceOption device_detail = 8;
  bool has_device_detail() const;
  private:
  bool _internal_has_device_detail() const;
  public:
  void clear_device_detail();
  const ::caffe2::DeviceOption& device_detail() const;
  ::caffe2::DeviceOption* release_device_detail();
  ::caffe2::DeviceOption* mutable_device_detail();
  void set_allocated_device_detail(::caffe2::DeviceOption* device_detail);
  private:
  const ::caffe2::DeviceOption& _internal_device_detail() const;
  ::caffe2::DeviceOption* _internal_mutable_device_detail();
  public:
  void unsafe_arena_set_allocated_device_detail(
      ::caffe2::DeviceOption* device_detail);
  ::caffe2::DeviceOption* unsafe_arena_release_device_detail();

// optional .caffe2.TensorProto.Segment segment = 11;
  bool has_segment() const;
  private:
  bool _internal_has_segment() const;
  public:
  void clear_segment();
  const ::caffe2::TensorProto_Segment& segment() const;
  ::caffe2::TensorProto_Segment* release_segment();
  ::caffe2::TensorProto_Segment* mutable_segment();
  void set_allocated_segment(::caffe2::TensorProto_Segment* segment);
  private:
  const ::caffe2::TensorProto_Segment& _internal_segment() const;
  ::caffe2::TensorProto_Segment* _internal_mutable_segment();
  public:
  void unsafe_arena_set_allocated_segment(
      ::caffe2::TensorProto_Segment* segment);
  ::caffe2::TensorProto_Segment* unsafe_arena_release_segment();

// optional uint32 data_format = 15 [default = 0];
  bool has_data_format() const;
  private:
  bool _internal_has_data_format() const;
  public:
  void clear_data_format();
  ::PROTOBUF_NAMESPACE_ID::uint32 data_format() const;
  void set_data_format(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_data_format() const;
  void _internal_set_data_format(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

// optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT];
  bool has_data_type() const;
  private:
  bool _internal_has_data_type() const;
  public:
  void clear_data_type();
  ::caffe2::TensorProto_DataType data_type() const;
  void set_data_type(::caffe2::TensorProto_DataType value);
  private:
  ::caffe2::TensorProto_DataType _internal_data_type() const;
  void _internal_set_data_type(::caffe2::TensorProto_DataType value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.TensorProto)
 private:
  class _Internal;

template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > dims_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_data_;
  mutable std::atomic<int> _float_data_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > int32_data_;
  mutable std::atomic<int> _int32_data_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_data_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_data_;
  mutable std::atomic<int> _double_data_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > int64_data_;
  mutable std::atomic<int> _int64_data_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr byte_data_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_data_;
  ::caffe2::DeviceOption* device_detail_;
  ::caffe2::TensorProto_Segment* segment_;
  ::PROTOBUF_NAMESPACE_ID::uint32 data_format_;
  int data_type_;
  friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
};
// -------------------------------------------------------------------

class TORCH_API QTensorProto PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.QTensorProto) */ {
 public:
  inline QTensorProto() : QTensorProto(nullptr) {}
  virtual ~QTensorProto();

QTensorProto(const QTensorProto& from);
  QTensorProto(QTensorProto&& from) noexcept
    : QTensorProto() {
    *this = ::std::move(from);
  }

inline QTensorProto& operator=(const QTensorProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline QTensorProto& operator=(QTensorProto&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const QTensorProto* internal_default_instance() {
    return reinterpret_cast<const QTensorProto*>(
               &_QTensorProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    2;

friend void swap(QTensorProto& a, QTensorProto& b) {
    a.Swap(&b);
  }
  inline void Swap(QTensorProto* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(QTensorProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline QTensorProto* New() const final {
    return CreateMaybeMessage<QTensorProto>(nullptr);
  }

QTensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<QTensorProto>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const QTensorProto& from);
  void MergeFrom(const QTensorProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(QTensorProto* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.QTensorProto";
  }
  protected:
  explicit QTensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kDimsFieldNumber = 1,
    kDataFieldNumber = 6,
    kScalesFieldNumber = 9,
    kBiasesFieldNumber = 10,
    kNameFieldNumber = 7,
    kScaleFieldNumber = 3,
    kBiasFieldNumber = 4,
    kPrecisionFieldNumber = 2,
    kIsSignedFieldNumber = 5,
    kIsMultiparamFieldNumber = 12,
    kAxisFieldNumber = 11,
    kDataTypeFieldNumber = 8,
  };
  // repeated int64 dims = 1;
  int dims_size() const;
  private:
  int _internal_dims_size() const;
  public:
  void clear_dims();
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_dims(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      _internal_dims() const;
  void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      _internal_mutable_dims();
  public:
  ::PROTOBUF_NAMESPACE_ID::int64 dims(int index) const;
  void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      dims() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_dims();

// repeated int32 data = 6 [packed = true];
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_data(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      _internal_data() const;
  void _internal_add_data(::PROTOBUF_NAMESPACE_ID::int32 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      _internal_mutable_data();
  public:
  ::PROTOBUF_NAMESPACE_ID::int32 data(int index) const;
  void set_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
  void add_data(::PROTOBUF_NAMESPACE_ID::int32 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      mutable_data();

// repeated double scales = 9;
  int scales_size() const;
  private:
  int _internal_scales_size() const;
  public:
  void clear_scales();
  private:
  double _internal_scales(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_scales() const;
  void _internal_add_scales(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_scales();
  public:
  double scales(int index) const;
  void set_scales(int index, double value);
  void add_scales(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      scales() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_scales();

// repeated double biases = 10;
  int biases_size() const;
  private:
  int _internal_biases_size() const;
  public:
  void clear_biases();
  private:
  double _internal_biases(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_biases() const;
  void _internal_add_biases(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_biases();
  public:
  double biases(int index) const;
  void set_biases(int index, double value);
  void add_biases(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      biases() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_biases();

// required double scale = 3;
  bool has_scale() const;
  private:
  bool _internal_has_scale() const;
  public:
  void clear_scale();
  double scale() const;
  void set_scale(double value);
  private:
  double _internal_scale() const;
  void _internal_set_scale(double value);
  public:

// required double bias = 4;
  bool has_bias() const;
  private:
  bool _internal_has_bias() const;
  public:
  void clear_bias();
  double bias() const;
  void set_bias(double value);
  private:
  double _internal_bias() const;
  void _internal_set_bias(double value);
  public:

// required int32 precision = 2;
  bool has_precision() const;
  private:
  bool _internal_has_precision() const;
  public:
  void clear_precision();
  ::PROTOBUF_NAMESPACE_ID::int32 precision() const;
  void set_precision(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_precision() const;
  void _internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

// required bool is_signed = 5;
  bool has_is_signed() const;
  private:
  bool _internal_has_is_signed() const;
  public:
  void clear_is_signed();
  bool is_signed() const;
  void set_is_signed(bool value);
  private:
  bool _internal_is_signed() const;
  void _internal_set_is_signed(bool value);
  public:

// optional bool is_multiparam = 12 [default = false];
  bool has_is_multiparam() const;
  private:
  bool _internal_has_is_multiparam() const;
  public:
  void clear_is_multiparam();
  bool is_multiparam() const;
  void set_is_multiparam(bool value);
  private:
  bool _internal_is_multiparam() const;
  void _internal_set_is_multiparam(bool value);
  public:

// optional int32 axis = 11;
  bool has_axis() const;
  private:
  bool _internal_has_axis() const;
  public:
  void clear_axis();
  ::PROTOBUF_NAMESPACE_ID::int32 axis() const;
  void set_axis(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_axis() const;
  void _internal_set_axis(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

// optional .caffe2.TensorProto.DataType data_type = 8 [default = INT32];
  bool has_data_type() const;
  private:
  bool _internal_has_data_type() const;
  public:
  void clear_data_type();
  ::caffe2::TensorProto_DataType data_type() const;
  void set_data_type(::caffe2::TensorProto_DataType value);
  private:
  ::caffe2::TensorProto_DataType _internal_data_type() const;
  void _internal_set_data_type(::caffe2::TensorProto_DataType value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.QTensorProto)
 private:
  class _Internal;

// helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

class TORCH_API TensorProtos PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorProtos) */ {
 public:
  inline TensorProtos() : TensorProtos(nullptr) {}
  virtual ~TensorProtos();

TensorProtos(const TensorProtos& from);
  TensorProtos(TensorProtos&& from) noexcept
    : TensorProtos() {
    *this = ::std::move(from);
  }

inline TensorProtos& operator=(const TensorProtos& from) {
    CopyFrom(from);
    return *this;
  }
  inline TensorProtos& operator=(TensorProtos&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TensorProtos* internal_default_instance() {
    return reinterpret_cast<const TensorProtos*>(
               &_TensorProtos_default_instance_);
  }
  static int const kIndexInFileMessages =
    3;

friend void swap(TensorProtos& a, TensorProtos& b) {
    a.Swap(&b);
  }
  inline void Swap(TensorProtos* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TensorProtos* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline TensorProtos* New() const final {
    return CreateMaybeMessage<TensorProtos>(nullptr);
  }

TensorProtos* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TensorProtos>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TensorProtos& from);
  void MergeFrom(const TensorProtos& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TensorProtos* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.TensorProtos";
  }
  protected:
  explicit TensorProtos(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kProtosFieldNumber = 1,
  };
  // repeated .caffe2.TensorProto protos = 1;
  int protos_size() const;
  private:
  int _internal_protos_size() const;
  public:
  void clear_protos();
  ::caffe2::TensorProto* mutable_protos(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >*
      mutable_protos();
  private:
  const ::caffe2::TensorProto& _internal_protos(int index) const;
  ::caffe2::TensorProto* _internal_add_protos();
  public:
  const ::caffe2::TensorProto& protos(int index) const;
  ::caffe2::TensorProto* add_protos();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >&
      protos() const;

// @@protoc_insertion_point(class_scope:caffe2.TensorProtos)
 private:
  class _Internal;

class TORCH_API TensorShape PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorShape) */ {
 public:
  inline TensorShape() : TensorShape(nullptr) {}
  virtual ~TensorShape();

TensorShape(const TensorShape& from);
  TensorShape(TensorShape&& from) noexcept
    : TensorShape() {
    *this = ::std::move(from);
  }

inline TensorShape& operator=(const TensorShape& from) {
    CopyFrom(from);
    return *this;
  }
  inline TensorShape& operator=(TensorShape&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TensorShape* internal_default_instance() {
    return reinterpret_cast<const TensorShape*>(
               &_TensorShape_default_instance_);
  }
  static int const kIndexInFileMessages =
    4;

friend void swap(TensorShape& a, TensorShape& b) {
    a.Swap(&b);
  }
  inline void Swap(TensorShape* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TensorShape* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline TensorShape* New() const final {
    return CreateMaybeMessage<TensorShape>(nullptr);
  }

TensorShape* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TensorShape>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TensorShape& from);
  void MergeFrom(const TensorShape& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TensorShape* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.TensorShape";
  }
  protected:
  explicit TensorShape(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kDimsFieldNumber = 1,
    kUnknownDimsFieldNumber = 3,
    kNameFieldNumber = 5,
    kUnknownShapeFieldNumber = 4,
    kDataTypeFieldNumber = 2,
  };
  // repeated int64 dims = 1;
  int dims_size() const;
  private:
  int _internal_dims_size() const;
  public:
  void clear_dims();
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_dims(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      _internal_dims() const;
  void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      _internal_mutable_dims();
  public:
  ::PROTOBUF_NAMESPACE_ID::int64 dims(int index) const;
  void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_dims(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      dims() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_dims();

// repeated int32 unknown_dims = 3;
  int unknown_dims_size() const;
  private:
  int _internal_unknown_dims_size() const;
  public:
  void clear_unknown_dims();
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_unknown_dims(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      _internal_unknown_dims() const;
  void _internal_add_unknown_dims(::PROTOBUF_NAMESPACE_ID::int32 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      _internal_mutable_unknown_dims();
  public:
  ::PROTOBUF_NAMESPACE_ID::int32 unknown_dims(int index) const;
  void set_unknown_dims(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
  void add_unknown_dims(::PROTOBUF_NAMESPACE_ID::int32 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      unknown_dims() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      mutable_unknown_dims();

// optional string name = 5;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

// optional bool unknown_shape = 4 [default = false];
  bool has_unknown_shape() const;
  private:
  bool _internal_has_unknown_shape() const;
  public:
  void clear_unknown_shape();
  bool unknown_shape() const;
  void set_unknown_shape(bool value);
  private:
  bool _internal_unknown_shape() const;
  void _internal_set_unknown_shape(bool value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.TensorShape)
 private:
  class _Internal;

class TORCH_API TensorShapes PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorShapes) */ {
 public:
  inline TensorShapes() : TensorShapes(nullptr) {}
  virtual ~TensorShapes();

TensorShapes(const TensorShapes& from);
  TensorShapes(TensorShapes&& from) noexcept
    : TensorShapes() {
    *this = ::std::move(from);
  }

inline TensorShapes& operator=(const TensorShapes& from) {
    CopyFrom(from);
    return *this;
  }
  inline TensorShapes& operator=(TensorShapes&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TensorShapes* internal_default_instance() {
    return reinterpret_cast<const TensorShapes*>(
               &_TensorShapes_default_instance_);
  }
  static int const kIndexInFileMessages =
    5;

friend void swap(TensorShapes& a, TensorShapes& b) {
    a.Swap(&b);
  }
  inline void Swap(TensorShapes* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TensorShapes* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline TensorShapes* New() const final {
    return CreateMaybeMessage<TensorShapes>(nullptr);
  }

TensorShapes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TensorShapes>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TensorShapes& from);
  void MergeFrom(const TensorShapes& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TensorShapes* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.TensorShapes";
  }
  protected:
  explicit TensorShapes(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kShapesFieldNumber = 1,
  };
  // repeated .caffe2.TensorShape shapes = 1;
  int shapes_size() const;
  private:
  int _internal_shapes_size() const;
  public:
  void clear_shapes();
  ::caffe2::TensorShape* mutable_shapes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape >*
      mutable_shapes();
  private:
  const ::caffe2::TensorShape& _internal_shapes(int index) const;
  ::caffe2::TensorShape* _internal_add_shapes();
  public:
  const ::caffe2::TensorShape& shapes(int index) const;
  ::caffe2::TensorShape* add_shapes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape >&
      shapes() const;

// @@protoc_insertion_point(class_scope:caffe2.TensorShapes)
 private:
  class _Internal;

class TORCH_API TensorBoundShape PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorBoundShape) */ {
 public:
  inline TensorBoundShape() : TensorBoundShape(nullptr) {}
  virtual ~TensorBoundShape();

TensorBoundShape(const TensorBoundShape& from);
  TensorBoundShape(TensorBoundShape&& from) noexcept
    : TensorBoundShape() {
    *this = ::std::move(from);
  }

inline TensorBoundShape& operator=(const TensorBoundShape& from) {
    CopyFrom(from);
    return *this;
  }
  inline TensorBoundShape& operator=(TensorBoundShape&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TensorBoundShape* internal_default_instance() {
    return reinterpret_cast<const TensorBoundShape*>(
               &_TensorBoundShape_default_instance_);
  }
  static int const kIndexInFileMessages =
    6;

friend void swap(TensorBoundShape& a, TensorBoundShape& b) {
    a.Swap(&b);
  }
  inline void Swap(TensorBoundShape* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TensorBoundShape* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline TensorBoundShape* New() const final {
    return CreateMaybeMessage<TensorBoundShape>(nullptr);
  }

TensorBoundShape* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TensorBoundShape>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TensorBoundShape& from);
  void MergeFrom(const TensorBoundShape& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TensorBoundShape* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.TensorBoundShape";
  }
  protected:
  explicit TensorBoundShape(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

typedef TensorBoundShape_DimType DimType;
  static DimType const UNKNOWN =
    TensorBoundShape_DimType_UNKNOWN;
  static DimType const CONSTANT =
    TensorBoundShape_DimType_CONSTANT;
  static DimType const BATCH =
    TensorBoundShape_DimType_BATCH;
  static DimType const BATCH_OF_FEATURE_MAX =
    TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX;
  static DimType const BATCH_OF_FEATURE_MAX_DEFAULT =
    TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX_DEFAULT;
  static DimType const FEATURE_MAX =
    TensorBoundShape_DimType_FEATURE_MAX;
  static DimType const FEATURE_MAX_DEFAULT =
    TensorBoundShape_DimType_FEATURE_MAX_DEFAULT;
  static inline bool DimType_IsValid(int value) {
    return TensorBoundShape_DimType_IsValid(value);
  }
  static DimType const DimType_MIN =
    TensorBoundShape_DimType_DimType_MIN;
  static DimType const DimType_MAX =
    TensorBoundShape_DimType_DimType_MAX;
  static int const DimType_ARRAYSIZE =
    TensorBoundShape_DimType_DimType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DimType_descriptor() {
    return TensorBoundShape_DimType_descriptor();
  }
  template<typename T>
  static inline const std::string& DimType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DimType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DimType_Name.");
    return TensorBoundShape_DimType_Name(enum_t_value);
  }
  static inline bool DimType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DimType* value) {
    return TensorBoundShape_DimType_Parse(name, value);
  }

// accessors -------------------------------------------------------

enum : int {
    kDimTypeFieldNumber = 2,
    kNameFieldNumber = 3,
    kShapeFieldNumber = 1,
    kShapeIsFinalFieldNumber = 4,
  };
  // repeated .caffe2.TensorBoundShape.DimType dim_type = 2;
  int dim_type_size() const;
  private:
  int _internal_dim_type_size() const;
  public:
  void clear_dim_type();
  private:
  ::caffe2::TensorBoundShape_DimType _internal_dim_type(int index) const;
  void _internal_add_dim_type(::caffe2::TensorBoundShape_DimType value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_dim_type();
  public:
  ::caffe2::TensorBoundShape_DimType dim_type(int index) const;
  void set_dim_type(int index, ::caffe2::TensorBoundShape_DimType value);
  void add_dim_type(::caffe2::TensorBoundShape_DimType value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& dim_type() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_dim_type();

// optional string name = 3;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

// optional .caffe2.TensorShape shape = 1;
  bool has_shape() const;
  private:
  bool _internal_has_shape() const;
  public:
  void clear_shape();
  const ::caffe2::TensorShape& shape() const;
  ::caffe2::TensorShape* release_shape();
  ::caffe2::TensorShape* mutable_shape();
  void set_allocated_shape(::caffe2::TensorShape* shape);
  private:
  const ::caffe2::TensorShape& _internal_shape() const;
  ::caffe2::TensorShape* _internal_mutable_shape();
  public:
  void unsafe_arena_set_allocated_shape(
      ::caffe2::TensorShape* shape);
  ::caffe2::TensorShape* unsafe_arena_release_shape();

// optional bool shape_is_final = 4;
  bool has_shape_is_final() const;
  private:
  bool _internal_has_shape_is_final() const;
  public:
  void clear_shape_is_final();
  bool shape_is_final() const;
  void set_shape_is_final(bool value);
  private:
  bool _internal_shape_is_final() const;
  void _internal_set_shape_is_final(bool value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.TensorBoundShape)
 private:
  class _Internal;

class TORCH_API TensorBoundShapes PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorBoundShapes) */ {
 public:
  inline TensorBoundShapes() : TensorBoundShapes(nullptr) {}
  virtual ~TensorBoundShapes();

TensorBoundShapes(const TensorBoundShapes& from);
  TensorBoundShapes(TensorBoundShapes&& from) noexcept
    : TensorBoundShapes() {
    *this = ::std::move(from);
  }

inline TensorBoundShapes& operator=(const TensorBoundShapes& from) {
    CopyFrom(from);
    return *this;
  }
  inline TensorBoundShapes& operator=(TensorBoundShapes&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TensorBoundShapes* internal_default_instance() {
    return reinterpret_cast<const TensorBoundShapes*>(
               &_TensorBoundShapes_default_instance_);
  }
  static int const kIndexInFileMessages =
    7;

friend void swap(TensorBoundShapes& a, TensorBoundShapes& b) {
    a.Swap(&b);
  }
  inline void Swap(TensorBoundShapes* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TensorBoundShapes* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline TensorBoundShapes* New() const final {
    return CreateMaybeMessage<TensorBoundShapes>(nullptr);
  }

TensorBoundShapes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TensorBoundShapes>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TensorBoundShapes& from);
  void MergeFrom(const TensorBoundShapes& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TensorBoundShapes* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.TensorBoundShapes";
  }
  protected:
  explicit TensorBoundShapes(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kShapesFieldNumber = 1,
    kMaxBatchSizeFieldNumber = 2,
    kMaxFeatureLenFieldNumber = 3,
  };
  // repeated .caffe2.TensorBoundShape shapes = 1;
  int shapes_size() const;
  private:
  int _internal_shapes_size() const;
  public:
  void clear_shapes();
  ::caffe2::TensorBoundShape* mutable_shapes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape >*
      mutable_shapes();
  private:
  const ::caffe2::TensorBoundShape& _internal_shapes(int index) const;
  ::caffe2::TensorBoundShape* _internal_add_shapes();
  public:
  const ::caffe2::TensorBoundShape& shapes(int index) const;
  ::caffe2::TensorBoundShape* add_shapes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape >&
      shapes() const;

// optional int64 max_batch_size = 2;
  bool has_max_batch_size() const;
  private:
  bool _internal_has_max_batch_size() const;
  public:
  void clear_max_batch_size();
  ::PROTOBUF_NAMESPACE_ID::int64 max_batch_size() const;
  void set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_batch_size() const;
  void _internal_set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

// optional int64 max_feature_len = 3;
  bool has_max_feature_len() const;
  private:
  bool _internal_has_max_feature_len() const;
  public:
  void clear_max_feature_len();
  ::PROTOBUF_NAMESPACE_ID::int64 max_feature_len() const;
  void set_max_feature_len(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_feature_len() const;
  void _internal_set_max_feature_len(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.TensorBoundShapes)
 private:
  class _Internal;

class TORCH_API AOTConfig PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.AOTConfig) */ {
 public:
  inline AOTConfig() : AOTConfig(nullptr) {}
  virtual ~AOTConfig();

AOTConfig(const AOTConfig& from);
  AOTConfig(AOTConfig&& from) noexcept
    : AOTConfig() {
    *this = ::std::move(from);
  }

inline AOTConfig& operator=(const AOTConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline AOTConfig& operator=(AOTConfig&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const AOTConfig* internal_default_instance() {
    return reinterpret_cast<const AOTConfig*>(
               &_AOTConfig_default_instance_);
  }
  static int const kIndexInFileMessages =
    8;

friend void swap(AOTConfig& a, AOTConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(AOTConfig* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AOTConfig* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline AOTConfig* New() const final {
    return CreateMaybeMessage<AOTConfig>(nullptr);
  }

AOTConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AOTConfig>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AOTConfig& from);
  void MergeFrom(const AOTConfig& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AOTConfig* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.AOTConfig";
  }
  protected:
  explicit AOTConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kOnnxifiBlacklistOpsFieldNumber = 4,
    kMaxBatchSizeFieldNumber = 1,
    kMaxSeqSizeFieldNumber = 2,
    kInBatchBroadcastFieldNumber = 3,
    kOnnxifiMinOpsFieldNumber = 5,
  };
  // optional string onnxifi_blacklist_ops = 4;
  bool has_onnxifi_blacklist_ops() const;
  private:
  bool _internal_has_onnxifi_blacklist_ops() const;
  public:
  void clear_onnxifi_blacklist_ops();
  const std::string& onnxifi_blacklist_ops() const;
  void set_onnxifi_blacklist_ops(const std::string& value);
  void set_onnxifi_blacklist_ops(std::string&& value);
  void set_onnxifi_blacklist_ops(const char* value);
  void set_onnxifi_blacklist_ops(const char* value, size_t size);
  std::string* mutable_onnxifi_blacklist_ops();
  std::string* release_onnxifi_blacklist_ops();
  void set_allocated_onnxifi_blacklist_ops(std::string* onnxifi_blacklist_ops);
  private:
  const std::string& _internal_onnxifi_blacklist_ops() const;
  void _internal_set_onnxifi_blacklist_ops(const std::string& value);
  std::string* _internal_mutable_onnxifi_blacklist_ops();
  public:

// required int64 max_batch_size = 1;
  bool has_max_batch_size() const;
  private:
  bool _internal_has_max_batch_size() const;
  public:
  void clear_max_batch_size();
  ::PROTOBUF_NAMESPACE_ID::int64 max_batch_size() const;
  void set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_batch_size() const;
  void _internal_set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

// required int64 max_seq_size = 2;
  bool has_max_seq_size() const;
  private:
  bool _internal_has_max_seq_size() const;
  public:
  void clear_max_seq_size();
  ::PROTOBUF_NAMESPACE_ID::int64 max_seq_size() const;
  void set_max_seq_size(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_seq_size() const;
  void _internal_set_max_seq_size(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

// required bool in_batch_broadcast = 3;
  bool has_in_batch_broadcast() const;
  private:
  bool _internal_has_in_batch_broadcast() const;
  public:
  void clear_in_batch_broadcast();
  bool in_batch_broadcast() const;
  void set_in_batch_broadcast(bool value);
  private:
  bool _internal_in_batch_broadcast() const;
  void _internal_set_in_batch_broadcast(bool value);
  public:

// optional int32 onnxifi_min_ops = 5;
  bool has_onnxifi_min_ops() const;
  private:
  bool _internal_has_onnxifi_min_ops() const;
  public:
  void clear_onnxifi_min_ops();
  ::PROTOBUF_NAMESPACE_ID::int32 onnxifi_min_ops() const;
  void set_onnxifi_min_ops(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_onnxifi_min_ops() const;
  void _internal_set_onnxifi_min_ops(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.AOTConfig)
 private:
  class _Internal;

// helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

class TORCH_API Argument PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.Argument) */ {
 public:
  inline Argument() : Argument(nullptr) {}
  virtual ~Argument();

Argument(const Argument& from);
  Argument(Argument&& from) noexcept
    : Argument() {
    *this = ::std::move(from);
  }

inline Argument& operator=(const Argument& from) {
    CopyFrom(from);
    return *this;
  }
  inline Argument& operator=(Argument&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Argument* internal_default_instance() {
    return reinterpret_cast<const Argument*>(
               &_Argument_default_instance_);
  }
  static int const kIndexInFileMessages =
    9;

friend void swap(Argument& a, Argument& b) {
    a.Swap(&b);
  }
  inline void Swap(Argument* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Argument* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline Argument* New() const final {
    return CreateMaybeMessage<Argument>(nullptr);
  }

Argument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Argument>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Argument& from);
  void MergeFrom(const Argument& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Argument* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.Argument";
  }
  protected:
  explicit Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kFloatsFieldNumber = 5,
    kIntsFieldNumber = 6,
    kStringsFieldNumber = 7,
    kNetsFieldNumber = 9,
    kTensorsFieldNumber = 11,
    kQtensorsFieldNumber = 12,
    kNameFieldNumber = 1,
    kSFieldNumber = 4,
    kNFieldNumber = 8,
    kTFieldNumber = 10,
    kIFieldNumber = 3,
    kFFieldNumber = 2,
  };
  // repeated float floats = 5;
  int floats_size() const;
  private:
  int _internal_floats_size() const;
  public:
  void clear_floats();
  private:
  float _internal_floats(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_floats() const;
  void _internal_add_floats(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_floats();
  public:
  float floats(int index) const;
  void set_floats(int index, float value);
  void add_floats(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      floats() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_floats();

// repeated int64 ints = 6;
  int ints_size() const;
  private:
  int _internal_ints_size() const;
  public:
  void clear_ints();
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_ints(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      _internal_ints() const;
  void _internal_add_ints(::PROTOBUF_NAMESPACE_ID::int64 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      _internal_mutable_ints();
  public:
  ::PROTOBUF_NAMESPACE_ID::int64 ints(int index) const;
  void set_ints(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_ints(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      ints() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_ints();

// repeated bytes strings = 7;
  int strings_size() const;
  private:
  int _internal_strings_size() const;
  public:
  void clear_strings();
  const std::string& strings(int index) const;
  std::string* mutable_strings(int index);
  void set_strings(int index, const std::string& value);
  void set_strings(int index, std::string&& value);
  void set_strings(int index, const char* value);
  void set_strings(int index, const void* value, size_t size);
  std::string* add_strings();
  void add_strings(const std::string& value);
  void add_strings(std::string&& value);
  void add_strings(const char* value);
  void add_strings(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& strings() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_strings();
  private:
  const std::string& _internal_strings(int index) const;
  std::string* _internal_add_strings();
  public:

// repeated .caffe2.NetDef nets = 9;
  int nets_size() const;
  private:
  int _internal_nets_size() const;
  public:
  void clear_nets();
  ::caffe2::NetDef* mutable_nets(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >*
      mutable_nets();
  private:
  const ::caffe2::NetDef& _internal_nets(int index) const;
  ::caffe2::NetDef* _internal_add_nets();
  public:
  const ::caffe2::NetDef& nets(int index) const;
  ::caffe2::NetDef* add_nets();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >&
      nets() const;

// repeated .caffe2.TensorProto tensors = 11;
  int tensors_size() const;
  private:
  int _internal_tensors_size() const;
  public:
  void clear_tensors();
  ::caffe2::TensorProto* mutable_tensors(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >*
      mutable_tensors();
  private:
  const ::caffe2::TensorProto& _internal_tensors(int index) const;
  ::caffe2::TensorProto* _internal_add_tensors();
  public:
  const ::caffe2::TensorProto& tensors(int index) const;
  ::caffe2::TensorProto* add_tensors();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >&
      tensors() const;

// repeated .caffe2.QTensorProto qtensors = 12;
  int qtensors_size() const;
  private:
  int _internal_qtensors_size() const;
  public:
  void clear_qtensors();
  ::caffe2::QTensorProto* mutable_qtensors(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto >*
      mutable_qtensors();
  private:
  const ::caffe2::QTensorProto& _internal_qtensors(int index) const;
  ::caffe2::QTensorProto* _internal_add_qtensors();
  public:
  const ::caffe2::QTensorProto& qtensors(int index) const;
  ::caffe2::QTensorProto* add_qtensors();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto >&
      qtensors() const;

// optional string name = 1;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

// optional bytes s = 4;
  bool has_s() const;
  private:
  bool _internal_has_s() const;
  public:
  void clear_s();
  const std::string& s() const;
  void set_s(const std::string& value);
  void set_s(std::string&& value);
  void set_s(const char* value);
  void set_s(const void* value, size_t size);
  std::string* mutable_s();
  std::string* release_s();
  void set_allocated_s(std::string* s);
  private:
  const std::string& _internal_s() const;
  void _internal_set_s(const std::string& value);
  std::string* _internal_mutable_s();
  public:

// optional .caffe2.NetDef n = 8;
  bool has_n() const;
  private:
  bool _internal_has_n() const;
  public:
  void clear_n();
  const ::caffe2::NetDef& n() const;
  ::caffe2::NetDef* release_n();
  ::caffe2::NetDef* mutable_n();
  void set_allocated_n(::caffe2::NetDef* n);
  private:
  const ::caffe2::NetDef& _internal_n() const;
  ::caffe2::NetDef* _internal_mutable_n();
  public:
  void unsafe_arena_set_allocated_n(
      ::caffe2::NetDef* n);
  ::caffe2::NetDef* unsafe_arena_release_n();

// optional .caffe2.TensorProto t = 10;
  bool has_t() const;
  private:
  bool _internal_has_t() const;
  public:
  void clear_t();
  const ::caffe2::TensorProto& t() const;
  ::caffe2::TensorProto* release_t();
  ::caffe2::TensorProto* mutable_t();
  void set_allocated_t(::caffe2::TensorProto* t);
  private:
  const ::caffe2::TensorProto& _internal_t() const;
  ::caffe2::TensorProto* _internal_mutable_t();
  public:
  void unsafe_arena_set_allocated_t(
      ::caffe2::TensorProto* t);
  ::caffe2::TensorProto* unsafe_arena_release_t();

// optional int64 i = 3;
  bool has_i() const;
  private:
  bool _internal_has_i() const;
  public:
  void clear_i();
  ::PROTOBUF_NAMESPACE_ID::int64 i() const;
  void set_i(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_i() const;
  void _internal_set_i(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

// optional float f = 2;
  bool has_f() const;
  private:
  bool _internal_has_f() const;
  public:
  void clear_f();
  float f() const;
  void set_f(float value);
  private:
  float _internal_f() const;
  void _internal_set_f(float value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.Argument)
 private:
  class _Internal;

template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > floats_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > ints_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> strings_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef > nets_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto > tensors_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto > qtensors_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr s_;
  ::caffe2::NetDef* n_;
  ::caffe2::TensorProto* t_;
  ::PROTOBUF_NAMESPACE_ID::int64 i_;
  float f_;
  friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
};
// -------------------------------------------------------------------

class TORCH_API DeviceOption PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.DeviceOption) */ {
 public:
  inline DeviceOption() : DeviceOption(nullptr) {}
  virtual ~DeviceOption();

DeviceOption(const DeviceOption& from);
  DeviceOption(DeviceOption&& from) noexcept
    : DeviceOption() {
    *this = ::std::move(from);
  }

inline DeviceOption& operator=(const DeviceOption& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeviceOption& operator=(DeviceOption&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const DeviceOption* internal_default_instance() {
    return reinterpret_cast<const DeviceOption*>(
               &_DeviceOption_default_instance_);
  }
  static int const kIndexInFileMessages =
    10;

friend void swap(DeviceOption& a, DeviceOption& b) {
    a.Swap(&b);
  }
  inline void Swap(DeviceOption* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DeviceOption* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline DeviceOption* New() const final {
    return CreateMaybeMessage<DeviceOption>(nullptr);
  }

DeviceOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeviceOption>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DeviceOption& from);
  void MergeFrom(const DeviceOption& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DeviceOption* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.DeviceOption";
  }
  protected:
  explicit DeviceOption(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kExtraInfoFieldNumber = 6,
    kNodeNameFieldNumber = 4,
    kDeviceTypeFieldNumber = 1,
    kDeviceIdFieldNumber = 2,
    kRandomSeedFieldNumber = 3,
    kNumaNodeIdFieldNumber = 5,
  };
  // repeated string extra_info = 6;
  int extra_info_size() const;
  private:
  int _internal_extra_info_size() const;
  public:
  void clear_extra_info();
  const std::string& extra_info(int index) const;
  std::string* mutable_extra_info(int index);
  void set_extra_info(int index, const std::string& value);
  void set_extra_info(int index, std::string&& value);
  void set_extra_info(int index, const char* value);
  void set_extra_info(int index, const char* value, size_t size);
  std::string* add_extra_info();
  void add_extra_info(const std::string& value);
  void add_extra_info(std::string&& value);
  void add_extra_info(const char* value);
  void add_extra_info(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& extra_info() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_extra_info();
  private:
  const std::string& _internal_extra_info(int index) const;
  std::string* _internal_add_extra_info();
  public:

// optional string node_name = 4;
  bool has_node_name() const;
  private:
  bool _internal_has_node_name() const;
  public:
  void clear_node_name();
  const std::string& node_name() const;
  void set_node_name(const std::string& value);
  void set_node_name(std::string&& value);
  void set_node_name(const char* value);
  void set_node_name(const char* value, size_t size);
  std::string* mutable_node_name();
  std::string* release_node_name();
  void set_allocated_node_name(std::string* node_name);
  private:
  const std::string& _internal_node_name() const;
  void _internal_set_node_name(const std::string& value);
  std::string* _internal_mutable_node_name();
  public:

// optional int32 device_type = 1 [default = 0];
  bool has_device_type() const;
  private:
  bool _internal_has_device_type() const;
  public:
  void clear_device_type();
  ::PROTOBUF_NAMESPACE_ID::int32 device_type() const;
  void set_device_type(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_device_type() const;
  void _internal_set_device_type(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

// optional int32 device_id = 2;
  bool has_device_id() const;
  private:
  bool _internal_has_device_id() const;
  public:
  void clear_device_id();
  ::PROTOBUF_NAMESPACE_ID::int32 device_id() const;
  void set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_device_id() const;
  void _internal_set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

// optional uint32 random_seed = 3;
  bool has_random_seed() const;
  private:
  bool _internal_has_random_seed() const;
  public:
  void clear_random_seed();
  ::PROTOBUF_NAMESPACE_ID::uint32 random_seed() const;
  void set_random_seed(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_random_seed() const;
  void _internal_set_random_seed(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

// optional int32 numa_node_id = 5;
  bool has_numa_node_id() const;
  private:
  bool _internal_has_numa_node_id() const;
  public:
  void clear_numa_node_id();
  ::PROTOBUF_NAMESPACE_ID::int32 numa_node_id() const;
  void set_numa_node_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_numa_node_id() const;
  void _internal_set_numa_node_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.DeviceOption)
 private:
  class _Internal;

class TORCH_API OperatorDef PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.OperatorDef) */ {
 public:
  inline OperatorDef() : OperatorDef(nullptr) {}
  virtual ~OperatorDef();

OperatorDef(const OperatorDef& from);
  OperatorDef(OperatorDef&& from) noexcept
    : OperatorDef() {
    *this = ::std::move(from);
  }

inline OperatorDef& operator=(const OperatorDef& from) {
    CopyFrom(from);
    return *this;
  }
  inline OperatorDef& operator=(OperatorDef&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const OperatorDef* internal_default_instance() {
    return reinterpret_cast<const OperatorDef*>(
               &_OperatorDef_default_instance_);
  }
  static int const kIndexInFileMessages =
    11;

friend void swap(OperatorDef& a, OperatorDef& b) {
    a.Swap(&b);
  }
  inline void Swap(OperatorDef* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OperatorDef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline OperatorDef* New() const final {
    return CreateMaybeMessage<OperatorDef>(nullptr);
  }

OperatorDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<OperatorDef>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const OperatorDef& from);
  void MergeFrom(const OperatorDef& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OperatorDef* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.OperatorDef";
  }
  protected:
  explicit OperatorDef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kInputFieldNumber = 1,
    kOutputFieldNumber = 2,
    kArgFieldNumber = 5,
    kControlInputFieldNumber = 8,
    kNameFieldNumber = 3,
    kTypeFieldNumber = 4,
    kEngineFieldNumber = 7,
    kDebugInfoFieldNumber = 10,
    kDomainFieldNumber = 11,
    kDeviceOptionFieldNumber = 6,
    kOpVersionFieldNumber = 12,
    kIsGradientOpFieldNumber = 9,
  };
  // repeated string input = 1;
  int input_size() const;
  private:
  int _internal_input_size() const;
  public:
  void clear_input();
  const std::string& input(int index) const;
  std::string* mutable_input(int index);
  void set_input(int index, const std::string& value);
  void set_input(int index, std::string&& value);
  void set_input(int index, const char* value);
  void set_input(int index, const char* value, size_t size);
  std::string* add_input();
  void add_input(const std::string& value);
  void add_input(std::string&& value);
  void add_input(const char* value);
  void add_input(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input();
  private:
  const std::string& _internal_input(int index) const;
  std::string* _internal_add_input();
  public:

// repeated string output = 2;
  int output_size() const;
  private:
  int _internal_output_size() const;
  public:
  void clear_output();
  const std::string& output(int index) const;
  std::string* mutable_output(int index);
  void set_output(int index, const std::string& value);
  void set_output(int index, std::string&& value);
  void set_output(int index, const char* value);
  void set_output(int index, const char* value, size_t size);
  std::string* add_output();
  void add_output(const std::string& value);
  void add_output(std::string&& value);
  void add_output(const char* value);
  void add_output(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& output() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_output();
  private:
  const std::string& _internal_output(int index) const;
  std::string* _internal_add_output();
  public:

// repeated .caffe2.Argument arg = 5;
  int arg_size() const;
  private:
  int _internal_arg_size() const;
  public:
  void clear_arg();
  ::caffe2::Argument* mutable_arg(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >*
      mutable_arg();
  private:
  const ::caffe2::Argument& _internal_arg(int index) const;
  ::caffe2::Argument* _internal_add_arg();
  public:
  const ::caffe2::Argument& arg(int index) const;
  ::caffe2::Argument* add_arg();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >&
      arg() const;

// repeated string control_input = 8;
  int control_input_size() const;
  private:
  int _internal_control_input_size() const;
  public:
  void clear_control_input();
  const std::string& control_input(int index) const;
  std::string* mutable_control_input(int index);
  void set_control_input(int index, const std::string& value);
  void set_control_input(int index, std::string&& value);
  void set_control_input(int index, const char* value);
  void set_control_input(int index, const char* value, size_t size);
  std::string* add_control_input();
  void add_control_input(const std::string& value);
  void add_control_input(std::string&& value);
  void add_control_input(const char* value);
  void add_control_input(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& control_input() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_control_input();
  private:
  const std::string& _internal_control_input(int index) const;
  std::string* _internal_add_control_input();
  public:

// optional string type = 4;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  const std::string& type() const;
  void set_type(const std::string& value);
  void set_type(std::string&& value);
  void set_type(const char* value);
  void set_type(const char* value, size_t size);
  std::string* mutable_type();
  std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

// optional string engine = 7;
  bool has_engine() const;
  private:
  bool _internal_has_engine() const;
  public:
  void clear_engine();
  const std::string& engine() const;
  void set_engine(const std::string& value);
  void set_engine(std::string&& value);
  void set_engine(const char* value);
  void set_engine(const char* value, size_t size);
  std::string* mutable_engine();
  std::string* release_engine();
  void set_allocated_engine(std::string* engine);
  private:
  const std::string& _internal_engine() const;
  void _internal_set_engine(const std::string& value);
  std::string* _internal_mutable_engine();
  public:

// optional string debug_info = 10;
  bool has_debug_info() const;
  private:
  bool _internal_has_debug_info() const;
  public:
  void clear_debug_info();
  const std::string& debug_info() const;
  void set_debug_info(const std::string& value);
  void set_debug_info(std::string&& value);
  void set_debug_info(const char* value);
  void set_debug_info(const char* value, size_t size);
  std::string* mutable_debug_info();
  std::string* release_debug_info();
  void set_allocated_debug_info(std::string* debug_info);
  private:
  const std::string& _internal_debug_info() const;
  void _internal_set_debug_info(const std::string& value);
  std::string* _internal_mutable_debug_info();
  public:

// optional string domain = 11;
  bool has_domain() const;
  private:
  bool _internal_has_domain() const;
  public:
  void clear_domain();
  const std::string& domain() const;
  void set_domain(const std::string& value);
  void set_domain(std::string&& value);
  void set_domain(const char* value);
  void set_domain(const char* value, size_t size);
  std::string* mutable_domain();
  std::string* release_domain();
  void set_allocated_domain(std::string* domain);
  private:
  const std::string& _internal_domain() const;
  void _internal_set_domain(const std::string& value);
  std::string* _internal_mutable_domain();
  public:

// optional .caffe2.DeviceOption device_option = 6;
  bool has_device_option() const;
  private:
  bool _internal_has_device_option() const;
  public:
  void clear_device_option();
  const ::caffe2::DeviceOption& device_option() const;
  ::caffe2::DeviceOption* release_device_option();
  ::caffe2::DeviceOption* mutable_device_option();
  void set_allocated_device_option(::caffe2::DeviceOption* device_option);
  private:
  const ::caffe2::DeviceOption& _internal_device_option() const;
  ::caffe2::DeviceOption* _internal_mutable_device_option();
  public:
  void unsafe_arena_set_allocated_device_option(
      ::caffe2::DeviceOption* device_option);
  ::caffe2::DeviceOption* unsafe_arena_release_device_option();

// optional int64 op_version = 12;
  bool has_op_version() const;
  private:
  bool _internal_has_op_version() const;
  public:
  void clear_op_version();
  ::PROTOBUF_NAMESPACE_ID::int64 op_version() const;
  void set_op_version(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_op_version() const;
  void _internal_set_op_version(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

// optional bool is_gradient_op = 9 [default = false];
  bool has_is_gradient_op() const;
  private:
  bool _internal_has_is_gradient_op() const;
  public:
  void clear_is_gradient_op();
  bool is_gradient_op() const;
  void set_is_gradient_op(bool value);
  private:
  bool _internal_is_gradient_op() const;
  void _internal_set_is_gradient_op(bool value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.OperatorDef)
 private:
  class _Internal;

template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> output_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument > arg_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> control_input_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr engine_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr debug_info_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_;
  ::caffe2::DeviceOption* device_option_;
  ::PROTOBUF_NAMESPACE_ID::int64 op_version_;
  bool is_gradient_op_;
  friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
};
// -------------------------------------------------------------------

class TORCH_API MapFieldEntry PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.MapFieldEntry) */ {
 public:
  inline MapFieldEntry() : MapFieldEntry(nullptr) {}
  virtual ~MapFieldEntry();

MapFieldEntry(const MapFieldEntry& from);
  MapFieldEntry(MapFieldEntry&& from) noexcept
    : MapFieldEntry() {
    *this = ::std::move(from);
  }

inline MapFieldEntry& operator=(const MapFieldEntry& from) {
    CopyFrom(from);
    return *this;
  }
  inline MapFieldEntry& operator=(MapFieldEntry&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MapFieldEntry* internal_default_instance() {
    return reinterpret_cast<const MapFieldEntry*>(
               &_MapFieldEntry_default_instance_);
  }
  static int const kIndexInFileMessages =
    12;

friend void swap(MapFieldEntry& a, MapFieldEntry& b) {
    a.Swap(&b);
  }
  inline void Swap(MapFieldEntry* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MapFieldEntry* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline MapFieldEntry* New() const final {
    return CreateMaybeMessage<MapFieldEntry>(nullptr);
  }

MapFieldEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MapFieldEntry>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const MapFieldEntry& from);
  void MergeFrom(const MapFieldEntry& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MapFieldEntry* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.MapFieldEntry";
  }
  protected:
  explicit MapFieldEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kKeyFieldNumber = 1,
    kValFieldNumber = 2,
  };
  // required string key = 1;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const std::string& key() const;
  void set_key(const std::string& value);
  void set_key(std::string&& value);
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  std::string* mutable_key();
  std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

// required string val = 2;
  bool has_val() const;
  private:
  bool _internal_has_val() const;
  public:
  void clear_val();
  const std::string& val() const;
  void set_val(const std::string& value);
  void set_val(std::string&& value);
  void set_val(const char* value);
  void set_val(const char* value, size_t size);
  std::string* mutable_val();
  std::string* release_val();
  void set_allocated_val(std::string* val);
  private:
  const std::string& _internal_val() const;
  void _internal_set_val(const std::string& value);
  std::string* _internal_mutable_val();
  public:

// @@protoc_insertion_point(class_scope:caffe2.MapFieldEntry)
 private:
  class _Internal;

// helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

class TORCH_API BackendOptions PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.BackendOptions) */ {
 public:
  inline BackendOptions() : BackendOptions(nullptr) {}
  virtual ~BackendOptions();

BackendOptions(const BackendOptions& from);
  BackendOptions(BackendOptions&& from) noexcept
    : BackendOptions() {
    *this = ::std::move(from);
  }

inline BackendOptions& operator=(const BackendOptions& from) {
    CopyFrom(from);
    return *this;
  }
  inline BackendOptions& operator=(BackendOptions&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BackendOptions* internal_default_instance() {
    return reinterpret_cast<const BackendOptions*>(
               &_BackendOptions_default_instance_);
  }
  static int const kIndexInFileMessages =
    13;

friend void swap(BackendOptions& a, BackendOptions& b) {
    a.Swap(&b);
  }
  inline void Swap(BackendOptions* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BackendOptions* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline BackendOptions* New() const final {
    return CreateMaybeMessage<BackendOptions>(nullptr);
  }

BackendOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BackendOptions>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BackendOptions& from);
  void MergeFrom(const BackendOptions& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BackendOptions* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.BackendOptions";
  }
  protected:
  explicit BackendOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kOptionFieldNumber = 2,
    kBackendNameFieldNumber = 1,
  };
  // repeated .caffe2.MapFieldEntry option = 2;
  int option_size() const;
  private:
  int _internal_option_size() const;
  public:
  void clear_option();
  ::caffe2::MapFieldEntry* mutable_option(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry >*
      mutable_option();
  private:
  const ::caffe2::MapFieldEntry& _internal_option(int index) const;
  ::caffe2::MapFieldEntry* _internal_add_option();
  public:
  const ::caffe2::MapFieldEntry& option(int index) const;
  ::caffe2::MapFieldEntry* add_option();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry >&
      option() const;

// required string backend_name = 1;
  bool has_backend_name() const;
  private:
  bool _internal_has_backend_name() const;
  public:
  void clear_backend_name();
  const std::string& backend_name() const;
  void set_backend_name(const std::string& value);
  void set_backend_name(std::string&& value);
  void set_backend_name(const char* value);
  void set_backend_name(const char* value, size_t size);
  std::string* mutable_backend_name();
  std::string* release_backend_name();
  void set_allocated_backend_name(std::string* backend_name);
  private:
  const std::string& _internal_backend_name() const;
  void _internal_set_backend_name(const std::string& value);
  std::string* _internal_mutable_backend_name();
  public:

// @@protoc_insertion_point(class_scope:caffe2.BackendOptions)
 private:
  class _Internal;

class TORCH_API PartitionInfo PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.PartitionInfo) */ {
 public:
  inline PartitionInfo() : PartitionInfo(nullptr) {}
  virtual ~PartitionInfo();

PartitionInfo(const PartitionInfo& from);
  PartitionInfo(PartitionInfo&& from) noexcept
    : PartitionInfo() {
    *this = ::std::move(from);
  }

inline PartitionInfo& operator=(const PartitionInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline PartitionInfo& operator=(PartitionInfo&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PartitionInfo* internal_default_instance() {
    return reinterpret_cast<const PartitionInfo*>(
               &_PartitionInfo_default_instance_);
  }
  static int const kIndexInFileMessages =
    14;

friend void swap(PartitionInfo& a, PartitionInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(PartitionInfo* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PartitionInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline PartitionInfo* New() const final {
    return CreateMaybeMessage<PartitionInfo>(nullptr);
  }

PartitionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PartitionInfo>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PartitionInfo& from);
  void MergeFrom(const PartitionInfo& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PartitionInfo* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.PartitionInfo";
  }
  protected:
  explicit PartitionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kDeviceIdFieldNumber = 2,
    kBackendOptionsFieldNumber = 4,
    kNameFieldNumber = 1,
    kExtraInfoFieldNumber = 3,
  };
  // repeated int32 device_id = 2;
  int device_id_size() const;
  private:
  int _internal_device_id_size() const;
  public:
  void clear_device_id();
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_device_id(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      _internal_device_id() const;
  void _internal_add_device_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      _internal_mutable_device_id();
  public:
  ::PROTOBUF_NAMESPACE_ID::int32 device_id(int index) const;
  void set_device_id(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
  void add_device_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      device_id() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      mutable_device_id();

// repeated .caffe2.BackendOptions backend_options = 4;
  int backend_options_size() const;
  private:
  int _internal_backend_options_size() const;
  public:
  void clear_backend_options();
  ::caffe2::BackendOptions* mutable_backend_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions >*
      mutable_backend_options();
  private:
  const ::caffe2::BackendOptions& _internal_backend_options(int index) const;
  ::caffe2::BackendOptions* _internal_add_backend_options();
  public:
  const ::caffe2::BackendOptions& backend_options(int index) const;
  ::caffe2::BackendOptions* add_backend_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions >&
      backend_options() const;

// required string name = 1;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

// optional string extra_info = 3;
  bool has_extra_info() const;
  private:
  bool _internal_has_extra_info() const;
  public:
  void clear_extra_info();
  const std::string& extra_info() const;
  void set_extra_info(const std::string& value);
  void set_extra_info(std::string&& value);
  void set_extra_info(const char* value);
  void set_extra_info(const char* value, size_t size);
  std::string* mutable_extra_info();
  std::string* release_extra_info();
  void set_allocated_extra_info(std::string* extra_info);
  private:
  const std::string& _internal_extra_info() const;
  void _internal_set_extra_info(const std::string& value);
  std::string* _internal_mutable_extra_info();
  public:

// @@protoc_insertion_point(class_scope:caffe2.PartitionInfo)
 private:
  class _Internal;

class TORCH_API NetDef PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.NetDef) */ {
 public:
  inline NetDef() : NetDef(nullptr) {}
  virtual ~NetDef();

NetDef(const NetDef& from);
  NetDef(NetDef&& from) noexcept
    : NetDef() {
    *this = ::std::move(from);
  }

inline NetDef& operator=(const NetDef& from) {
    CopyFrom(from);
    return *this;
  }
  inline NetDef& operator=(NetDef&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NetDef* internal_default_instance() {
    return reinterpret_cast<const NetDef*>(
               &_NetDef_default_instance_);
  }
  static int const kIndexInFileMessages =
    15;

friend void swap(NetDef& a, NetDef& b) {
    a.Swap(&b);
  }
  inline void Swap(NetDef* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NetDef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline NetDef* New() const final {
    return CreateMaybeMessage<NetDef>(nullptr);
  }

NetDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<NetDef>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const NetDef& from);
  void MergeFrom(const NetDef& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NetDef* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.NetDef";
  }
  protected:
  explicit NetDef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kOpFieldNumber = 2,
    kArgFieldNumber = 6,
    kExternalInputFieldNumber = 7,
    kExternalOutputFieldNumber = 8,
    kPartitionInfoFieldNumber = 9,
    kNameFieldNumber = 1,
    kTypeFieldNumber = 3,
    kDeviceOptionFieldNumber = 5,
    kNumWorkersFieldNumber = 4,
  };
  // repeated .caffe2.OperatorDef op = 2;
  int op_size() const;
  private:
  int _internal_op_size() const;
  public:
  void clear_op();
  ::caffe2::OperatorDef* mutable_op(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef >*
      mutable_op();
  private:
  const ::caffe2::OperatorDef& _internal_op(int index) const;
  ::caffe2::OperatorDef* _internal_add_op();
  public:
  const ::caffe2::OperatorDef& op(int index) const;
  ::caffe2::OperatorDef* add_op();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef >&
      op() const;

// repeated .caffe2.Argument arg = 6;
  int arg_size() const;
  private:
  int _internal_arg_size() const;
  public:
  void clear_arg();
  ::caffe2::Argument* mutable_arg(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >*
      mutable_arg();
  private:
  const ::caffe2::Argument& _internal_arg(int index) const;
  ::caffe2::Argument* _internal_add_arg();
  public:
  const ::caffe2::Argument& arg(int index) const;
  ::caffe2::Argument* add_arg();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >&
      arg() const;

// repeated string external_input = 7;
  int external_input_size() const;
  private:
  int _internal_external_input_size() const;
  public:
  void clear_external_input();
  const std::string& external_input(int index) const;
  std::string* mutable_external_input(int index);
  void set_external_input(int index, const std::string& value);
  void set_external_input(int index, std::string&& value);
  void set_external_input(int index, const char* value);
  void set_external_input(int index, const char* value, size_t size);
  std::string* add_external_input();
  void add_external_input(const std::string& value);
  void add_external_input(std::string&& value);
  void add_external_input(const char* value);
  void add_external_input(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& external_input() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_external_input();
  private:
  const std::string& _internal_external_input(int index) const;
  std::string* _internal_add_external_input();
  public:

// repeated string external_output = 8;
  int external_output_size() const;
  private:
  int _internal_external_output_size() const;
  public:
  void clear_external_output();
  const std::string& external_output(int index) const;
  std::string* mutable_external_output(int index);
  void set_external_output(int index, const std::string& value);
  void set_external_output(int index, std::string&& value);
  void set_external_output(int index, const char* value);
  void set_external_output(int index, const char* value, size_t size);
  std::string* add_external_output();
  void add_external_output(const std::string& value);
  void add_external_output(std::string&& value);
  void add_external_output(const char* value);
  void add_external_output(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& external_output() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_external_output();
  private:
  const std::string& _internal_external_output(int index) const;
  std::string* _internal_add_external_output();
  public:

// repeated .caffe2.PartitionInfo partition_info = 9;
  int partition_info_size() const;
  private:
  int _internal_partition_info_size() const;
  public:
  void clear_partition_info();
  ::caffe2::PartitionInfo* mutable_partition_info(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo >*
      mutable_partition_info();
  private:
  const ::caffe2::PartitionInfo& _internal_partition_info(int index) const;
  ::caffe2::PartitionInfo* _internal_add_partition_info();
  public:
  const ::caffe2::PartitionInfo& partition_info(int index) const;
  ::caffe2::PartitionInfo* add_partition_info();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo >&
      partition_info() const;

// optional string type = 3;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  const std::string& type() const;
  void set_type(const std::string& value);
  void set_type(std::string&& value);
  void set_type(const char* value);
  void set_type(const char* value, size_t size);
  std::string* mutable_type();
  std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

// optional .caffe2.DeviceOption device_option = 5;
  bool has_device_option() const;
  private:
  bool _internal_has_device_option() const;
  public:
  void clear_device_option();
  const ::caffe2::DeviceOption& device_option() const;
  ::caffe2::DeviceOption* release_device_option();
  ::caffe2::DeviceOption* mutable_device_option();
  void set_allocated_device_option(::caffe2::DeviceOption* device_option);
  private:
  const ::caffe2::DeviceOption& _internal_device_option() const;
  ::caffe2::DeviceOption* _internal_mutable_device_option();
  public:
  void unsafe_arena_set_allocated_device_option(
      ::caffe2::DeviceOption* device_option);
  ::caffe2::DeviceOption* unsafe_arena_release_device_option();

// optional int32 num_workers = 4;
  bool has_num_workers() const;
  private:
  bool _internal_has_num_workers() const;
  public:
  void clear_num_workers();
  ::PROTOBUF_NAMESPACE_ID::int32 num_workers() const;
  void set_num_workers(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_workers() const;
  void _internal_set_num_workers(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.NetDef)
 private:
  class _Internal;

template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef > op_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument > arg_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> external_input_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> external_output_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo > partition_info_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
  ::caffe2::DeviceOption* device_option_;
  ::PROTOBUF_NAMESPACE_ID::int32 num_workers_;
  friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
};
// -------------------------------------------------------------------

class TORCH_API ExecutionStep PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.ExecutionStep) */ {
 public:
  inline ExecutionStep() : ExecutionStep(nullptr) {}
  virtual ~ExecutionStep();

ExecutionStep(const ExecutionStep& from);
  ExecutionStep(ExecutionStep&& from) noexcept
    : ExecutionStep() {
    *this = ::std::move(from);
  }

inline ExecutionStep& operator=(const ExecutionStep& from) {
    CopyFrom(from);
    return *this;
  }
  inline ExecutionStep& operator=(ExecutionStep&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ExecutionStep* internal_default_instance() {
    return reinterpret_cast<const ExecutionStep*>(
               &_ExecutionStep_default_instance_);
  }
  static int const kIndexInFileMessages =
    16;

friend void swap(ExecutionStep& a, ExecutionStep& b) {
    a.Swap(&b);
  }
  inline void Swap(ExecutionStep* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ExecutionStep* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline ExecutionStep* New() const final {
    return CreateMaybeMessage<ExecutionStep>(nullptr);
  }

ExecutionStep* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ExecutionStep>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ExecutionStep& from);
  void MergeFrom(const ExecutionStep& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ExecutionStep* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.ExecutionStep";
  }
  protected:
  explicit ExecutionStep(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kSubstepFieldNumber = 2,
    kNetworkFieldNumber = 3,
    kNameFieldNumber = 1,
    kCriteriaNetworkFieldNumber = 5,
    kReportNetFieldNumber = 7,
    kShouldStopBlobFieldNumber = 9,
    kNumIterFieldNumber = 4,
    kReportIntervalFieldNumber = 8,
    kConcurrentSubstepsFieldNumber = 6,
    kOnlyOnceFieldNumber = 10,
    kCreateWorkspaceFieldNumber = 12,
    kRunEveryMsFieldNumber = 11,
    kNumConcurrentInstancesFieldNumber = 13,
  };
  // repeated .caffe2.ExecutionStep substep = 2;
  int substep_size() const;
  private:
  int _internal_substep_size() const;
  public:
  void clear_substep();
  ::caffe2::ExecutionStep* mutable_substep(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >*
      mutable_substep();
  private:
  const ::caffe2::ExecutionStep& _internal_substep(int index) const;
  ::caffe2::ExecutionStep* _internal_add_substep();
  public:
  const ::caffe2::ExecutionStep& substep(int index) const;
  ::caffe2::ExecutionStep* add_substep();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >&
      substep() const;

// repeated string network = 3;
  int network_size() const;
  private:
  int _internal_network_size() const;
  public:
  void clear_network();
  const std::string& network(int index) const;
  std::string* mutable_network(int index);
  void set_network(int index, const std::string& value);
  void set_network(int index, std::string&& value);
  void set_network(int index, const char* value);
  void set_network(int index, const char* value, size_t size);
  std::string* add_network();
  void add_network(const std::string& value);
  void add_network(std::string&& value);
  void add_network(const char* value);
  void add_network(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& network() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_network();
  private:
  const std::string& _internal_network(int index) const;
  std::string* _internal_add_network();
  public:

// optional string criteria_network = 5 [deprecated = true];
  PROTOBUF_DEPRECATED bool has_criteria_network() const;
  private:
  bool _internal_has_criteria_network() const;
  public:
  PROTOBUF_DEPRECATED void clear_criteria_network();
  PROTOBUF_DEPRECATED const std::string& criteria_network() const;
  PROTOBUF_DEPRECATED void set_criteria_network(const std::string& value);
  PROTOBUF_DEPRECATED void set_criteria_network(std::string&& value);
  PROTOBUF_DEPRECATED void set_criteria_network(const char* value);
  PROTOBUF_DEPRECATED void set_criteria_network(const char* value, size_t size);
  PROTOBUF_DEPRECATED std::string* mutable_criteria_network();
  PROTOBUF_DEPRECATED std::string* release_criteria_network();
  PROTOBUF_DEPRECATED void set_allocated_criteria_network(std::string* criteria_network);
  private:
  const std::string& _internal_criteria_network() const;
  void _internal_set_criteria_network(const std::string& value);
  std::string* _internal_mutable_criteria_network();
  public:

// optional string report_net = 7;
  bool has_report_net() const;
  private:
  bool _internal_has_report_net() const;
  public:
  void clear_report_net();
  const std::string& report_net() const;
  void set_report_net(const std::string& value);
  void set_report_net(std::string&& value);
  void set_report_net(const char* value);
  void set_report_net(const char* value, size_t size);
  std::string* mutable_report_net();
  std::string* release_report_net();
  void set_allocated_report_net(std::string* report_net);
  private:
  const std::string& _internal_report_net() const;
  void _internal_set_report_net(const std::string& value);
  std::string* _internal_mutable_report_net();
  public:

// optional string should_stop_blob = 9;
  bool has_should_stop_blob() const;
  private:
  bool _internal_has_should_stop_blob() const;
  public:
  void clear_should_stop_blob();
  const std::string& should_stop_blob() const;
  void set_should_stop_blob(const std::string& value);
  void set_should_stop_blob(std::string&& value);
  void set_should_stop_blob(const char* value);
  void set_should_stop_blob(const char* value, size_t size);
  std::string* mutable_should_stop_blob();
  std::string* release_should_stop_blob();
  void set_allocated_should_stop_blob(std::string* should_stop_blob);
  private:
  const std::string& _internal_should_stop_blob() const;
  void _internal_set_should_stop_blob(const std::string& value);
  std::string* _internal_mutable_should_stop_blob();
  public:

// optional int64 num_iter = 4;
  bool has_num_iter() const;
  private:
  bool _internal_has_num_iter() const;
  public:
  void clear_num_iter();
  ::PROTOBUF_NAMESPACE_ID::int64 num_iter() const;
  void set_num_iter(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_num_iter() const;
  void _internal_set_num_iter(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

// optional int32 report_interval = 8;
  bool has_report_interval() const;
  private:
  bool _internal_has_report_interval() const;
  public:
  void clear_report_interval();
  ::PROTOBUF_NAMESPACE_ID::int32 report_interval() const;
  void set_report_interval(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_report_interval() const;
  void _internal_set_report_interval(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

// optional bool concurrent_substeps = 6;
  bool has_concurrent_substeps() const;
  private:
  bool _internal_has_concurrent_substeps() const;
  public:
  void clear_concurrent_substeps();
  bool concurrent_substeps() const;
  void set_concurrent_substeps(bool value);
  private:
  bool _internal_concurrent_substeps() const;
  void _internal_set_concurrent_substeps(bool value);
  public:

// optional bool only_once = 10;
  bool has_only_once() const;
  private:
  bool _internal_has_only_once() const;
  public:
  void clear_only_once();
  bool only_once() const;
  void set_only_once(bool value);
  private:
  bool _internal_only_once() const;
  void _internal_set_only_once(bool value);
  public:

// optional bool create_workspace = 12;
  bool has_create_workspace() const;
  private:
  bool _internal_has_create_workspace() const;
  public:
  void clear_create_workspace();
  bool create_workspace() const;
  void set_create_workspace(bool value);
  private:
  bool _internal_create_workspace() const;
  void _internal_set_create_workspace(bool value);
  public:

// optional int64 run_every_ms = 11;
  bool has_run_every_ms() const;
  private:
  bool _internal_has_run_every_ms() const;
  public:
  void clear_run_every_ms();
  ::PROTOBUF_NAMESPACE_ID::int64 run_every_ms() const;
  void set_run_every_ms(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_run_every_ms() const;
  void _internal_set_run_every_ms(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

// optional int32 num_concurrent_instances = 13;
  bool has_num_concurrent_instances() const;
  private:
  bool _internal_has_num_concurrent_instances() const;
  public:
  void clear_num_concurrent_instances();
  ::PROTOBUF_NAMESPACE_ID::int32 num_concurrent_instances() const;
  void set_num_concurrent_instances(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_concurrent_instances() const;
  void _internal_set_num_concurrent_instances(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.ExecutionStep)
 private:
  class _Internal;

template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep > substep_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> network_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr criteria_network_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr report_net_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr should_stop_blob_;
  ::PROTOBUF_NAMESPACE_ID::int64 num_iter_;
  ::PROTOBUF_NAMESPACE_ID::int32 report_interval_;
  bool concurrent_substeps_;
  bool only_once_;
  bool create_workspace_;
  ::PROTOBUF_NAMESPACE_ID::int64 run_every_ms_;
  ::PROTOBUF_NAMESPACE_ID::int32 num_concurrent_instances_;
  friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
};
// -------------------------------------------------------------------

class TORCH_API PlanDef PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.PlanDef) */ {
 public:
  inline PlanDef() : PlanDef(nullptr) {}
  virtual ~PlanDef();

PlanDef(const PlanDef& from);
  PlanDef(PlanDef&& from) noexcept
    : PlanDef() {
    *this = ::std::move(from);
  }

inline PlanDef& operator=(const PlanDef& from) {
    CopyFrom(from);
    return *this;
  }
  inline PlanDef& operator=(PlanDef&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PlanDef* internal_default_instance() {
    return reinterpret_cast<const PlanDef*>(
               &_PlanDef_default_instance_);
  }
  static int const kIndexInFileMessages =
    17;

friend void swap(PlanDef& a, PlanDef& b) {
    a.Swap(&b);
  }
  inline void Swap(PlanDef* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PlanDef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline PlanDef* New() const final {
    return CreateMaybeMessage<PlanDef>(nullptr);
  }

PlanDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PlanDef>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PlanDef& from);
  void MergeFrom(const PlanDef& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PlanDef* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.PlanDef";
  }
  protected:
  explicit PlanDef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kNetworkFieldNumber = 2,
    kExecutionStepFieldNumber = 3,
    kNameFieldNumber = 1,
  };
  // repeated .caffe2.NetDef network = 2;
  int network_size() const;
  private:
  int _internal_network_size() const;
  public:
  void clear_network();
  ::caffe2::NetDef* mutable_network(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >*
      mutable_network();
  private:
  const ::caffe2::NetDef& _internal_network(int index) const;
  ::caffe2::NetDef* _internal_add_network();
  public:
  const ::caffe2::NetDef& network(int index) const;
  ::caffe2::NetDef* add_network();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >&
      network() const;

// repeated .caffe2.ExecutionStep execution_step = 3;
  int execution_step_size() const;
  private:
  int _internal_execution_step_size() const;
  public:
  void clear_execution_step();
  ::caffe2::ExecutionStep* mutable_execution_step(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >*
      mutable_execution_step();
  private:
  const ::caffe2::ExecutionStep& _internal_execution_step(int index) const;
  ::caffe2::ExecutionStep* _internal_add_execution_step();
  public:
  const ::caffe2::ExecutionStep& execution_step(int index) const;
  ::caffe2::ExecutionStep* add_execution_step();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >&
      execution_step() const;

// @@protoc_insertion_point(class_scope:caffe2.PlanDef)
 private:
  class _Internal;

class TORCH_API BlobProto PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.BlobProto) */ {
 public:
  inline BlobProto() : BlobProto(nullptr) {}
  virtual ~BlobProto();

BlobProto(const BlobProto& from);
  BlobProto(BlobProto&& from) noexcept
    : BlobProto() {
    *this = ::std::move(from);
  }

inline BlobProto& operator=(const BlobProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline BlobProto& operator=(BlobProto&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BlobProto* internal_default_instance() {
    return reinterpret_cast<const BlobProto*>(
               &_BlobProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    18;

friend void swap(BlobProto& a, BlobProto& b) {
    a.Swap(&b);
  }
  inline void Swap(BlobProto* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BlobProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline BlobProto* New() const final {
    return CreateMaybeMessage<BlobProto>(nullptr);
  }

BlobProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BlobProto>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BlobProto& from);
  void MergeFrom(const BlobProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BlobProto* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.BlobProto";
  }
  protected:
  explicit BlobProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kNameFieldNumber = 1,
    kTypeFieldNumber = 2,
    kContentFieldNumber = 4,
    kTensorFieldNumber = 3,
    kQtensorFieldNumber = 5,
    kContentNumChunksFieldNumber = 6,
    kContentChunkIdFieldNumber = 7,
  };
  // optional string name = 1;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

// optional string type = 2;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  const std::string& type() const;
  void set_type(const std::string& value);
  void set_type(std::string&& value);
  void set_type(const char* value);
  void set_type(const char* value, size_t size);
  std::string* mutable_type();
  std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

// optional bytes content = 4;
  bool has_content() const;
  private:
  bool _internal_has_content() const;
  public:
  void clear_content();
  const std::string& content() const;
  void set_content(const std::string& value);
  void set_content(std::string&& value);
  void set_content(const char* value);
  void set_content(const void* value, size_t size);
  std::string* mutable_content();
  std::string* release_content();
  void set_allocated_content(std::string* content);
  private:
  const std::string& _internal_content() const;
  void _internal_set_content(const std::string& value);
  std::string* _internal_mutable_content();
  public:

// optional .caffe2.TensorProto tensor = 3;
  bool has_tensor() const;
  private:
  bool _internal_has_tensor() const;
  public:
  void clear_tensor();
  const ::caffe2::TensorProto& tensor() const;
  ::caffe2::TensorProto* release_tensor();
  ::caffe2::TensorProto* mutable_tensor();
  void set_allocated_tensor(::caffe2::TensorProto* tensor);
  private:
  const ::caffe2::TensorProto& _internal_tensor() const;
  ::caffe2::TensorProto* _internal_mutable_tensor();
  public:
  void unsafe_arena_set_allocated_tensor(
      ::caffe2::TensorProto* tensor);
  ::caffe2::TensorProto* unsafe_arena_release_tensor();

// optional .caffe2.QTensorProto qtensor = 5;
  bool has_qtensor() const;
  private:
  bool _internal_has_qtensor() const;
  public:
  void clear_qtensor();
  const ::caffe2::QTensorProto& qtensor() const;
  ::caffe2::QTensorProto* release_qtensor();
  ::caffe2::QTensorProto* mutable_qtensor();
  void set_allocated_qtensor(::caffe2::QTensorProto* qtensor);
  private:
  const ::caffe2::QTensorProto& _internal_qtensor() const;
  ::caffe2::QTensorProto* _internal_mutable_qtensor();
  public:
  void unsafe_arena_set_allocated_qtensor(
      ::caffe2::QTensorProto* qtensor);
  ::caffe2::QTensorProto* unsafe_arena_release_qtensor();

// optional int32 content_num_chunks = 6;
  bool has_content_num_chunks() const;
  private:
  bool _internal_has_content_num_chunks() const;
  public:
  void clear_content_num_chunks();
  ::PROTOBUF_NAMESPACE_ID::int32 content_num_chunks() const;
  void set_content_num_chunks(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_content_num_chunks() const;
  void _internal_set_content_num_chunks(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

// optional int32 content_chunk_id = 7;
  bool has_content_chunk_id() const;
  private:
  bool _internal_has_content_chunk_id() const;
  public:
  void clear_content_chunk_id();
  ::PROTOBUF_NAMESPACE_ID::int32 content_chunk_id() const;
  void set_content_chunk_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_content_chunk_id() const;
  void _internal_set_content_chunk_id(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.BlobProto)
 private:
  class _Internal;

class TORCH_API DBReaderProto PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.DBReaderProto) */ {
 public:
  inline DBReaderProto() : DBReaderProto(nullptr) {}
  virtual ~DBReaderProto();

DBReaderProto(const DBReaderProto& from);
  DBReaderProto(DBReaderProto&& from) noexcept
    : DBReaderProto() {
    *this = ::std::move(from);
  }

inline DBReaderProto& operator=(const DBReaderProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline DBReaderProto& operator=(DBReaderProto&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const DBReaderProto* internal_default_instance() {
    return reinterpret_cast<const DBReaderProto*>(
               &_DBReaderProto_default_instance_);
  }
  static int const kIndexInFileMessages =
    19;

friend void swap(DBReaderProto& a, DBReaderProto& b) {
    a.Swap(&b);
  }
  inline void Swap(DBReaderProto* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DBReaderProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline DBReaderProto* New() const final {
    return CreateMaybeMessage<DBReaderProto>(nullptr);
  }

DBReaderProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DBReaderProto>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DBReaderProto& from);
  void MergeFrom(const DBReaderProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DBReaderProto* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.DBReaderProto";
  }
  protected:
  explicit DBReaderProto(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kNameFieldNumber = 1,
    kSourceFieldNumber = 2,
    kDbTypeFieldNumber = 3,
    kKeyFieldNumber = 4,
  };
  // optional string name = 1;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

// optional string source = 2;
  bool has_source() const;
  private:
  bool _internal_has_source() const;
  public:
  void clear_source();
  const std::string& source() const;
  void set_source(const std::string& value);
  void set_source(std::string&& value);
  void set_source(const char* value);
  void set_source(const char* value, size_t size);
  std::string* mutable_source();
  std::string* release_source();
  void set_allocated_source(std::string* source);
  private:
  const std::string& _internal_source() const;
  void _internal_set_source(const std::string& value);
  std::string* _internal_mutable_source();
  public:

// optional string db_type = 3;
  bool has_db_type() const;
  private:
  bool _internal_has_db_type() const;
  public:
  void clear_db_type();
  const std::string& db_type() const;
  void set_db_type(const std::string& value);
  void set_db_type(std::string&& value);
  void set_db_type(const char* value);
  void set_db_type(const char* value, size_t size);
  std::string* mutable_db_type();
  std::string* release_db_type();
  void set_allocated_db_type(std::string* db_type);
  private:
  const std::string& _internal_db_type() const;
  void _internal_set_db_type(const std::string& value);
  std::string* _internal_mutable_db_type();
  public:

// optional string key = 4;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const std::string& key() const;
  void set_key(const std::string& value);
  void set_key(std::string&& value);
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  std::string* mutable_key();
  std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

// @@protoc_insertion_point(class_scope:caffe2.DBReaderProto)
 private:
  class _Internal;

class TORCH_API BlobSerializationOptions PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.BlobSerializationOptions) */ {
 public:
  inline BlobSerializationOptions() : BlobSerializationOptions(nullptr) {}
  virtual ~BlobSerializationOptions();

BlobSerializationOptions(const BlobSerializationOptions& from);
  BlobSerializationOptions(BlobSerializationOptions&& from) noexcept
    : BlobSerializationOptions() {
    *this = ::std::move(from);
  }

inline BlobSerializationOptions& operator=(const BlobSerializationOptions& from) {
    CopyFrom(from);
    return *this;
  }
  inline BlobSerializationOptions& operator=(BlobSerializationOptions&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BlobSerializationOptions* internal_default_instance() {
    return reinterpret_cast<const BlobSerializationOptions*>(
               &_BlobSerializationOptions_default_instance_);
  }
  static int const kIndexInFileMessages =
    20;

friend void swap(BlobSerializationOptions& a, BlobSerializationOptions& b) {
    a.Swap(&b);
  }
  inline void Swap(BlobSerializationOptions* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BlobSerializationOptions* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline BlobSerializationOptions* New() const final {
    return CreateMaybeMessage<BlobSerializationOptions>(nullptr);
  }

BlobSerializationOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BlobSerializationOptions>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BlobSerializationOptions& from);
  void MergeFrom(const BlobSerializationOptions& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BlobSerializationOptions* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.BlobSerializationOptions";
  }
  protected:
  explicit BlobSerializationOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

typedef BlobSerializationOptions_FloatFormat FloatFormat;
  static FloatFormat const FLOAT_DEFAULT =
    BlobSerializationOptions_FloatFormat_FLOAT_DEFAULT;
  static FloatFormat const FLOAT_PROTOBUF =
    BlobSerializationOptions_FloatFormat_FLOAT_PROTOBUF;
  static FloatFormat const FLOAT_BFLOAT16 =
    BlobSerializationOptions_FloatFormat_FLOAT_BFLOAT16;
  static inline bool FloatFormat_IsValid(int value) {
    return BlobSerializationOptions_FloatFormat_IsValid(value);
  }
  static FloatFormat const FloatFormat_MIN =
    BlobSerializationOptions_FloatFormat_FloatFormat_MIN;
  static FloatFormat const FloatFormat_MAX =
    BlobSerializationOptions_FloatFormat_FloatFormat_MAX;
  static int const FloatFormat_ARRAYSIZE =
    BlobSerializationOptions_FloatFormat_FloatFormat_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  FloatFormat_descriptor() {
    return BlobSerializationOptions_FloatFormat_descriptor();
  }
  template<typename T>
  static inline const std::string& FloatFormat_Name(T enum_t_value) {
    static_assert(::std::is_same<T, FloatFormat>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function FloatFormat_Name.");
    return BlobSerializationOptions_FloatFormat_Name(enum_t_value);
  }
  static inline bool FloatFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      FloatFormat* value) {
    return BlobSerializationOptions_FloatFormat_Parse(name, value);
  }

// accessors -------------------------------------------------------

enum : int {
    kBlobNameRegexFieldNumber = 1,
    kChunkSizeFieldNumber = 2,
    kFloatFormatFieldNumber = 3,
  };
  // optional string blob_name_regex = 1;
  bool has_blob_name_regex() const;
  private:
  bool _internal_has_blob_name_regex() const;
  public:
  void clear_blob_name_regex();
  const std::string& blob_name_regex() const;
  void set_blob_name_regex(const std::string& value);
  void set_blob_name_regex(std::string&& value);
  void set_blob_name_regex(const char* value);
  void set_blob_name_regex(const char* value, size_t size);
  std::string* mutable_blob_name_regex();
  std::string* release_blob_name_regex();
  void set_allocated_blob_name_regex(std::string* blob_name_regex);
  private:
  const std::string& _internal_blob_name_regex() const;
  void _internal_set_blob_name_regex(const std::string& value);
  std::string* _internal_mutable_blob_name_regex();
  public:

// optional int64 chunk_size = 2;
  bool has_chunk_size() const;
  private:
  bool _internal_has_chunk_size() const;
  public:
  void clear_chunk_size();
  ::PROTOBUF_NAMESPACE_ID::int64 chunk_size() const;
  void set_chunk_size(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_chunk_size() const;
  void _internal_set_chunk_size(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

// optional .caffe2.BlobSerializationOptions.FloatFormat float_format = 3;
  bool has_float_format() const;
  private:
  bool _internal_has_float_format() const;
  public:
  void clear_float_format();
  ::caffe2::BlobSerializationOptions_FloatFormat float_format() const;
  void set_float_format(::caffe2::BlobSerializationOptions_FloatFormat value);
  private:
  ::caffe2::BlobSerializationOptions_FloatFormat _internal_float_format() const;
  void _internal_set_float_format(::caffe2::BlobSerializationOptions_FloatFormat value);
  public:

// @@protoc_insertion_point(class_scope:caffe2.BlobSerializationOptions)
 private:
  class _Internal;

class TORCH_API SerializationOptions PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.SerializationOptions) */ {
 public:
  inline SerializationOptions() : SerializationOptions(nullptr) {}
  virtual ~SerializationOptions();

SerializationOptions(const SerializationOptions& from);
  SerializationOptions(SerializationOptions&& from) noexcept
    : SerializationOptions() {
    *this = ::std::move(from);
  }

inline SerializationOptions& operator=(const SerializationOptions& from) {
    CopyFrom(from);
    return *this;
  }
  inline SerializationOptions& operator=(SerializationOptions&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SerializationOptions* internal_default_instance() {
    return reinterpret_cast<const SerializationOptions*>(
               &_SerializationOptions_default_instance_);
  }
  static int const kIndexInFileMessages =
    21;

friend void swap(SerializationOptions& a, SerializationOptions& b) {
    a.Swap(&b);
  }
  inline void Swap(SerializationOptions* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SerializationOptions* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

// implements Message ----------------------------------------------

inline SerializationOptions* New() const final {
    return CreateMaybeMessage<SerializationOptions>(nullptr);
  }

SerializationOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SerializationOptions>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SerializationOptions& from);
  void MergeFrom(const SerializationOptions& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializationOptions* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.SerializationOptions";
  }
  protected:
  explicit SerializationOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

public:

// nested types ----------------------------------------------------

// accessors -------------------------------------------------------

enum : int {
    kOptionsFieldNumber = 1,
  };
  // repeated .caffe2.BlobSerializationOptions options = 1;
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::caffe2::BlobSerializationOptions* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions >*
      mutable_options();
  private:
  const ::caffe2::BlobSerializationOptions& _internal_options(int index) const;
  ::caffe2::BlobSerializationOptions* _internal_add_options();
  public:
  const ::caffe2::BlobSerializationOptions& options(int index) const;
  ::caffe2::BlobSerializationOptions* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions >&
      options() const;

// @@protoc_insertion_point(class_scope:caffe2.SerializationOptions)
 private:
  class _Internal;

template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions > options_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto;
};
// ===================================================================

// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// TensorProto_Segment

// required int64 begin = 1;
inline bool TensorProto_Segment::_internal_has_begin() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TensorProto_Segment::has_begin() const {
  return _internal_has_begin();
}
inline void TensorProto_Segment::clear_begin() {
  begin_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::_internal_begin() const {
  return begin_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::begin() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.Segment.begin)
  return _internal_begin();
}
inline void TensorProto_Segment::_internal_set_begin(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000001u;
  begin_ = value;
}
inline void TensorProto_Segment::set_begin(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_begin(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.Segment.begin)
}

// required int64 end = 2;
inline bool TensorProto_Segment::_internal_has_end() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool TensorProto_Segment::has_end() const {
  return _internal_has_end();
}
inline void TensorProto_Segment::clear_end() {
  end_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::_internal_end() const {
  return end_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::end() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.Segment.end)
  return _internal_end();
}
inline void TensorProto_Segment::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000002u;
  end_ = value;
}
inline void TensorProto_Segment::set_end(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_end(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.Segment.end)
}

// -------------------------------------------------------------------

// TensorProto

// repeated int64 dims = 1;
inline int TensorProto::_internal_dims_size() const {
  return dims_.size();
}
inline int TensorProto::dims_size() const {
  return _internal_dims_size();
}
inline void TensorProto::clear_dims() {
  dims_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::_internal_dims(int index) const {
  return dims_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::dims(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.dims)
  return _internal_dims(index);
}
inline void TensorProto::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  dims_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.dims)
}
inline void TensorProto::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
  dims_.Add(value);
}
inline void TensorProto::add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_add_dims(value);
  // @@protoc_insertion_point(field_add:caffe2.TensorProto.dims)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
TensorProto::_internal_dims() const {
  return dims_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
TensorProto::dims() const {
  // @@protoc_insertion_point(field_list:caffe2.TensorProto.dims)
  return _internal_dims();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
TensorProto::_internal_mutable_dims() {
  return &dims_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
TensorProto::mutable_dims() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.dims)
  return _internal_mutable_dims();
}

// optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT];
inline bool TensorProto::_internal_has_data_type() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool TensorProto::has_data_type() const {
  return _internal_has_data_type();
}
inline void TensorProto::clear_data_type() {
  data_type_ = 1;
  _has_bits_[0] &= ~0x00000040u;
}
inline ::caffe2::TensorProto_DataType TensorProto::_internal_data_type() const {
  return static_cast< ::caffe2::TensorProto_DataType >(data_type_);
}
inline ::caffe2::TensorProto_DataType TensorProto::data_type() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.data_type)
  return _internal_data_type();
}
inline void TensorProto::_internal_set_data_type(::caffe2::TensorProto_DataType value) {
  assert(::caffe2::TensorProto_DataType_IsValid(value));
  _has_bits_[0] |= 0x00000040u;
  data_type_ = value;
}
inline void TensorProto::set_data_type(::caffe2::TensorProto_DataType value) {
  _internal_set_data_type(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.data_type)
}

// optional uint32 data_format = 15 [default = 0];
inline bool TensorProto::_internal_has_data_format() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool TensorProto::has_data_format() const {
  return _internal_has_data_format();
}
inline void TensorProto::clear_data_format() {
  data_format_ = 0u;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TensorProto::_internal_data_format() const {
  return data_format_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TensorProto::data_format() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.data_format)
  return _internal_data_format();
}
inline void TensorProto::_internal_set_data_format(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000020u;
  data_format_ = value;
}
inline void TensorProto::set_data_format(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_data_format(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.data_format)
}

// repeated float float_data = 3 [packed = true];
inline int TensorProto::_internal_float_data_size() const {
  return float_data_.size();
}
inline int TensorProto::float_data_size() const {
  return _internal_float_data_size();
}
inline void TensorProto::clear_float_data() {
  float_data_.Clear();
}
inline float TensorProto::_internal_float_data(int index) const {
  return float_data_.Get(index);
}
inline float TensorProto::float_data(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.float_data)
  return _internal_float_data(index);
}
inline void TensorProto::set_float_data(int index, float value) {
  float_data_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.float_data)
}
inline void TensorProto::_internal_add_float_data(float value) {
  float_data_.Add(value);
}
inline void TensorProto::add_float_data(float value) {
  _internal_add_float_data(value);
  // @@protoc_insertion_point(field_add:caffe2.TensorProto.float_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
TensorProto::_internal_float_data() const {
  return float_data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
TensorProto::float_data() const {
  // @@protoc_insertion_point(field_list:caffe2.TensorProto.float_data)
  return _internal_float_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
TensorProto::_internal_mutable_float_data() {
  return &float_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
TensorProto::mutable_float_data() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.float_data)
  return _internal_mutable_float_data();
}

// repeated int32 int32_data = 4 [packed = true];
inline int TensorProto::_internal_int32_data_size() const {
  return int32_data_.size();
}
inline int TensorProto::int32_data_size() const {
  return _internal_int32_data_size();
}
inline void TensorProto::clear_int32_data() {
  int32_data_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::_internal_int32_data(int index) const {
  return int32_data_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::int32_data(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.int32_data)
  return _internal_int32_data(index);
}
inline void TensorProto::set_int32_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
  int32_data_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.int32_data)
}
inline void TensorProto::_internal_add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value) {
  int32_data_.Add(value);
}
inline void TensorProto::add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_add_int32_data(value);
  // @@protoc_insertion_point(field_add:caffe2.TensorProto.int32_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
TensorProto::_internal_int32_data() const {
  return int32_data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
TensorProto::int32_data() const {
  // @@protoc_insertion_point(field_list:caffe2.TensorProto.int32_data)
  return _internal_int32_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
TensorProto::_internal_mutable_int32_data() {
  return &int32_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
TensorProto::mutable_int32_data() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.int32_data)
  return _internal_mutable_int32_data();
}

// optional bytes byte_data = 5;
inline bool TensorProto::_internal_has_byte_data() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TensorProto::has_byte_data() const {
  return _internal_has_byte_data();
}
inline void TensorProto::clear_byte_data() {
  byte_data_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TensorProto::byte_data() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.byte_data)
  return _internal_byte_data();
}
inline void TensorProto::set_byte_data(const std::string& value) {
  _internal_set_byte_data(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.byte_data)
}
inline std::string* TensorProto::mutable_byte_data() {
  // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.byte_data)
  return _internal_mutable_byte_data();
}
inline const std::string& TensorProto::_internal_byte_data() const {
  return byte_data_.Get();
}
inline void TensorProto::_internal_set_byte_data(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  byte_data_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void TensorProto::set_byte_data(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  byte_data_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorProto.byte_data)
}
inline void TensorProto::set_byte_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  byte_data_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.byte_data)
}
inline void TensorProto::set_byte_data(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  byte_data_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.byte_data)
}
inline std::string* TensorProto::_internal_mutable_byte_data() {
  _has_bits_[0] |= 0x00000001u;
  return byte_data_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* TensorProto::release_byte_data() {
  // @@protoc_insertion_point(field_release:caffe2.TensorProto.byte_data)
  if (!_internal_has_byte_data()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return byte_data_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void TensorProto::set_allocated_byte_data(std::string* byte_data) {
  if (byte_data != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  byte_data_.SetAllocated(&GetEmptyStringAlreadyInited(), byte_data,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.byte_data)
}

// repeated bytes string_data = 6;
inline int TensorProto::_internal_string_data_size() const {
  return string_data_.size();
}
inline int TensorProto::string_data_size() const {
  return _internal_string_data_size();
}
inline void TensorProto::clear_string_data() {
  string_data_.Clear();
}
inline std::string* TensorProto::add_string_data() {
  // @@protoc_insertion_point(field_add_mutable:caffe2.TensorProto.string_data)
  return _internal_add_string_data();
}
inline const std::string& TensorProto::_internal_string_data(int index) const {
  return string_data_.Get(index);
}
inline const std::string& TensorProto::string_data(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.string_data)
  return _internal_string_data(index);
}
inline std::string* TensorProto::mutable_string_data(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.string_data)
  return string_data_.Mutable(index);
}
inline void TensorProto::set_string_data(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.string_data)
  string_data_.Mutable(index)->assign(value);
}
inline void TensorProto::set_string_data(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.string_data)
  string_data_.Mutable(index)->assign(std::move(value));
}
inline void TensorProto::set_string_data(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  string_data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.string_data)
}
inline void TensorProto::set_string_data(int index, const void* value, size_t size) {
  string_data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.string_data)
}
inline std::string* TensorProto::_internal_add_string_data() {
  return string_data_.Add();
}
inline void TensorProto::add_string_data(const std::string& value) {
  string_data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:caffe2.TensorProto.string_data)
}
inline void TensorProto::add_string_data(std::string&& value) {
  string_data_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:caffe2.TensorProto.string_data)
}
inline void TensorProto::add_string_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  string_data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:caffe2.TensorProto.string_data)
}
inline void TensorProto::add_string_data(const void* value, size_t size) {
  string_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:caffe2.TensorProto.string_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
TensorProto::string_data() const {
  // @@protoc_insertion_point(field_list:caffe2.TensorProto.string_data)
  return string_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
TensorProto::mutable_string_data() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.string_data)
  return &string_data_;
}

// repeated double double_data = 9 [packed = true];
inline int TensorProto::_internal_double_data_size() const {
  return double_data_.size();
}
inline int TensorProto::double_data_size() const {
  return _internal_double_data_size();
}
inline void TensorProto::clear_double_data() {
  double_data_.Clear();
}
inline double TensorProto::_internal_double_data(int index) const {
  return double_data_.Get(index);
}
inline double TensorProto::double_data(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.double_data)
  return _internal_double_data(index);
}
inline void TensorProto::set_double_data(int index, double value) {
  double_data_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.double_data)
}
inline void TensorProto::_internal_add_double_data(double value) {
  double_data_.Add(value);
}
inline void TensorProto::add_double_data(double value) {
  _internal_add_double_data(value);
  // @@protoc_insertion_point(field_add:caffe2.TensorProto.double_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
TensorProto::_internal_double_data() const {
  return double_data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
TensorProto::double_data() const {
  // @@protoc_insertion_point(field_list:caffe2.TensorProto.double_data)
  return _internal_double_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
TensorProto::_internal_mutable_double_data() {
  return &double_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
TensorProto::mutable_double_data() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.double_data)
  return _internal_mutable_double_data();
}

// repeated int64 int64_data = 10 [packed = true];
inline int TensorProto::_internal_int64_data_size() const {
  return int64_data_.size();
}
inline int TensorProto::int64_data_size() const {
  return _internal_int64_data_size();
}
inline void TensorProto::clear_int64_data() {
  int64_data_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::_internal_int64_data(int index) const {
  return int64_data_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::int64_data(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.int64_data)
  return _internal_int64_data(index);
}
inline void TensorProto::set_int64_data(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  int64_data_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.int64_data)
}
inline void TensorProto::_internal_add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value) {
  int64_data_.Add(value);
}
inline void TensorProto::add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_add_int64_data(value);
  // @@protoc_insertion_point(field_add:caffe2.TensorProto.int64_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
TensorProto::_internal_int64_data() const {
  return int64_data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
TensorProto::int64_data() const {
  // @@protoc_insertion_point(field_list:caffe2.TensorProto.int64_data)
  return _internal_int64_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
TensorProto::_internal_mutable_int64_data() {
  return &int64_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
TensorProto::mutable_int64_data() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.int64_data)
  return _internal_mutable_int64_data();
}

// optional bytes raw_data = 13;
inline bool TensorProto::_internal_has_raw_data() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool TensorProto::has_raw_data() const {
  return _internal_has_raw_data();
}
inline void TensorProto::clear_raw_data() {
  raw_data_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& TensorProto::raw_data() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.raw_data)
  return _internal_raw_data();
}
inline void TensorProto::set_raw_data(const std::string& value) {
  _internal_set_raw_data(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.raw_data)
}
inline std::string* TensorProto::mutable_raw_data() {
  // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.raw_data)
  return _internal_mutable_raw_data();
}
inline const std::string& TensorProto::_internal_raw_data() const {
  return raw_data_.Get();
}
inline void TensorProto::_internal_set_raw_data(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  raw_data_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void TensorProto::set_raw_data(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  raw_data_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorProto.raw_data)
}
inline void TensorProto::set_raw_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  raw_data_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.raw_data)
}
inline void TensorProto::set_raw_data(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000004u;
  raw_data_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.raw_data)
}
inline std::string* TensorProto::_internal_mutable_raw_data() {
  _has_bits_[0] |= 0x00000004u;
  return raw_data_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* TensorProto::release_raw_data() {
  // @@protoc_insertion_point(field_release:caffe2.TensorProto.raw_data)
  if (!_internal_has_raw_data()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return raw_data_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void TensorProto::set_allocated_raw_data(std::string* raw_data) {
  if (raw_data != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  raw_data_.SetAllocated(&GetEmptyStringAlreadyInited(), raw_data,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.raw_data)
}

// optional string name = 7;
inline bool TensorProto::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool TensorProto::has_name() const {
  return _internal_has_name();
}
inline void TensorProto::clear_name() {
  name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& TensorProto::name() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.name)
  return _internal_name();
}
inline void TensorProto::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorProto.name)
}
inline std::string* TensorProto::mutable_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.name)
  return _internal_mutable_name();
}
inline const std::string& TensorProto::_internal_name() const {
  return name_.Get();
}
inline void TensorProto::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void TensorProto::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorProto.name)
}
inline void TensorProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.name)
}
inline void TensorProto::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.name)
}
inline std::string* TensorProto::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000002u;
  return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* TensorProto::release_name() {
  // @@protoc_insertion_point(field_release:caffe2.TensorProto.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void TensorProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.name)
}

// optional .caffe2.DeviceOption device_detail = 8;
inline bool TensorProto::_internal_has_device_detail() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || device_detail_ != nullptr);
  return value;
}
inline bool TensorProto::has_device_detail() const {
  return _internal_has_device_detail();
}
inline void TensorProto::clear_device_detail() {
  if (device_detail_ != nullptr) device_detail_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::caffe2::DeviceOption& TensorProto::_internal_device_detail() const {
  const ::caffe2::DeviceOption* p = device_detail_;
  return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::DeviceOption*>(
      &::caffe2::_DeviceOption_default_instance_);
}
inline const ::caffe2::DeviceOption& TensorProto::device_detail() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.device_detail)
  return _internal_device_detail();
}
inline void TensorProto::unsafe_arena_set_allocated_device_detail(
    ::caffe2::DeviceOption* device_detail) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_detail_);
  }
  device_detail_ = device_detail;
  if (device_detail) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.TensorProto.device_detail)
}
inline ::caffe2::DeviceOption* TensorProto::release_device_detail() {
  _has_bits_[0] &= ~0x00000008u;
  ::caffe2::DeviceOption* temp = device_detail_;
  device_detail_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::caffe2::DeviceOption* TensorProto::unsafe_arena_release_device_detail() {
  // @@protoc_insertion_point(field_release:caffe2.TensorProto.device_detail)
  _has_bits_[0] &= ~0x00000008u;
  ::caffe2::DeviceOption* temp = device_detail_;
  device_detail_ = nullptr;
  return temp;
}
inline ::caffe2::DeviceOption* TensorProto::_internal_mutable_device_detail() {
  _has_bits_[0] |= 0x00000008u;
  if (device_detail_ == nullptr) {
    auto* p = CreateMaybeMessage<::caffe2::DeviceOption>(GetArena());
    device_detail_ = p;
  }
  return device_detail_;
}
inline ::caffe2::DeviceOption* TensorProto::mutable_device_detail() {
  // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.device_detail)
  return _internal_mutable_device_detail();
}
inline void TensorProto::set_allocated_device_detail(::caffe2::DeviceOption* device_detail) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete device_detail_;
  }
  if (device_detail) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(device_detail);
    if (message_arena != submessage_arena) {
      device_detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, device_detail, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  device_detail_ = device_detail;
  // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.device_detail)
}

// optional .caffe2.TensorProto.Segment segment = 11;
inline bool TensorProto::_internal_has_segment() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || segment_ != nullptr);
  return value;
}
inline bool TensorProto::has_segment() const {
  return _internal_has_segment();
}
inline void TensorProto::clear_segment() {
  if (segment_ != nullptr) segment_->Clear();
  _has_bits_[0] &= ~0x00000010u;
}
inline const ::caffe2::TensorProto_Segment& TensorProto::_internal_segment() const {
  const ::caffe2::TensorProto_Segment* p = segment_;
  return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::TensorProto_Segment*>(
      &::caffe2::_TensorProto_Segment_default_instance_);
}
inline const ::caffe2::TensorProto_Segment& TensorProto::segment() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProto.segment)
  return _internal_segment();
}
inline void TensorProto::unsafe_arena_set_allocated_segment(
    ::caffe2::TensorProto_Segment* segment) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(segment_);
  }
  segment_ = segment;
  if (segment) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.TensorProto.segment)
}
inline ::caffe2::TensorProto_Segment* TensorProto::release_segment() {
  _has_bits_[0] &= ~0x00000010u;
  ::caffe2::TensorProto_Segment* temp = segment_;
  segment_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::caffe2::TensorProto_Segment* TensorProto::unsafe_arena_release_segment() {
  // @@protoc_insertion_point(field_release:caffe2.TensorProto.segment)
  _has_bits_[0] &= ~0x00000010u;
  ::caffe2::TensorProto_Segment* temp = segment_;
  segment_ = nullptr;
  return temp;
}
inline ::caffe2::TensorProto_Segment* TensorProto::_internal_mutable_segment() {
  _has_bits_[0] |= 0x00000010u;
  if (segment_ == nullptr) {
    auto* p = CreateMaybeMessage<::caffe2::TensorProto_Segment>(GetArena());
    segment_ = p;
  }
  return segment_;
}
inline ::caffe2::TensorProto_Segment* TensorProto::mutable_segment() {
  // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.segment)
  return _internal_mutable_segment();
}
inline void TensorProto::set_allocated_segment(::caffe2::TensorProto_Segment* segment) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete segment_;
  }
  if (segment) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(segment);
    if (message_arena != submessage_arena) {
      segment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, segment, submessage_arena);
    }
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  segment_ = segment;
  // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.segment)
}

// -------------------------------------------------------------------

// QTensorProto

// repeated int64 dims = 1;
inline int QTensorProto::_internal_dims_size() const {
  return dims_.size();
}
inline int QTensorProto::dims_size() const {
  return _internal_dims_size();
}
inline void QTensorProto::clear_dims() {
  dims_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 QTensorProto::_internal_dims(int index) const {
  return dims_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 QTensorProto::dims(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.QTensorProto.dims)
  return _internal_dims(index);
}
inline void QTensorProto::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  dims_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.QTensorProto.dims)
}
inline void QTensorProto::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
  dims_.Add(value);
}
inline void QTensorProto::add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_add_dims(value);
  // @@protoc_insertion_point(field_add:caffe2.QTensorProto.dims)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
QTensorProto::_internal_dims() const {
  return dims_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
QTensorProto::dims() const {
  // @@protoc_insertion_point(field_list:caffe2.QTensorProto.dims)
  return _internal_dims();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
QTensorProto::_internal_mutable_dims() {
  return &dims_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
QTensorProto::mutable_dims() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.dims)
  return _internal_mutable_dims();
}

// required int32 precision = 2;
inline bool QTensorProto::_internal_has_precision() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool QTensorProto::has_precision() const {
  return _internal_has_precision();
}
inline void QTensorProto::clear_precision() {
  precision_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::_internal_precision() const {
  return precision_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::precision() const {
  // @@protoc_insertion_point(field_get:caffe2.QTensorProto.precision)
  return _internal_precision();
}
inline void QTensorProto::_internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000008u;
  precision_ = value;
}
inline void QTensorProto::set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_precision(value);
  // @@protoc_insertion_point(field_set:caffe2.QTensorProto.precision)
}

// required double scale = 3;
inline bool QTensorProto::_internal_has_scale() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool QTensorProto::has_scale() const {
  return _internal_has_scale();
}
inline void QTensorProto::clear_scale() {
  scale_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline double QTensorProto::_internal_scale() const {
  return scale_;
}
inline double QTensorProto::scale() const {
  // @@protoc_insertion_point(field_get:caffe2.QTensorProto.scale)
  return _internal_scale();
}
inline void QTensorProto::_internal_set_scale(double value) {
  _has_bits_[0] |= 0x00000002u;
  scale_ = value;
}
inline void QTensorProto::set_scale(double value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:caffe2.QTensorProto.scale)
}

// required double bias = 4;
inline bool QTensorProto::_internal_has_bias() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool QTensorProto::has_bias() const {
  return _internal_has_bias();
}
inline void QTensorProto::clear_bias() {
  bias_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline double QTensorProto::_internal_bias() const {
  return bias_;
}
inline double QTensorProto::bias() const {
  // @@protoc_insertion_point(field_get:caffe2.QTensorProto.bias)
  return _internal_bias();
}
inline void QTensorProto::_internal_set_bias(double value) {
  _has_bits_[0] |= 0x00000004u;
  bias_ = value;
}
inline void QTensorProto::set_bias(double value) {
  _internal_set_bias(value);
  // @@protoc_insertion_point(field_set:caffe2.QTensorProto.bias)
}

// required bool is_signed = 5;
inline bool QTensorProto::_internal_has_is_signed() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool QTensorProto::has_is_signed() const {
  return _internal_has_is_signed();
}
inline void QTensorProto::clear_is_signed() {
  is_signed_ = false;
  _has_bits_[0] &= ~0x00000010u;
}
inline bool QTensorProto::_internal_is_signed() const {
  return is_signed_;
}
inline bool QTensorProto::is_signed() const {
  // @@protoc_insertion_point(field_get:caffe2.QTensorProto.is_signed)
  return _internal_is_signed();
}
inline void QTensorProto::_internal_set_is_signed(bool value) {
  _has_bits_[0] |= 0x00000010u;
  is_signed_ = value;
}
inline void QTensorProto::set_is_signed(bool value) {
  _internal_set_is_signed(value);
  // @@protoc_insertion_point(field_set:caffe2.QTensorProto.is_signed)
}

// repeated int32 data = 6 [packed = true];
inline int QTensorProto::_internal_data_size() const {
  return data_.size();
}
inline int QTensorProto::data_size() const {
  return _internal_data_size();
}
inline void QTensorProto::clear_data() {
  data_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::_internal_data(int index) const {
  return data_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::data(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.QTensorProto.data)
  return _internal_data(index);
}
inline void QTensorProto::set_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
  data_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.QTensorProto.data)
}
inline void QTensorProto::_internal_add_data(::PROTOBUF_NAMESPACE_ID::int32 value) {
  data_.Add(value);
}
inline void QTensorProto::add_data(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_add_data(value);
  // @@protoc_insertion_point(field_add:caffe2.QTensorProto.data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
QTensorProto::_internal_data() const {
  return data_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
QTensorProto::data() const {
  // @@protoc_insertion_point(field_list:caffe2.QTensorProto.data)
  return _internal_data();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
QTensorProto::_internal_mutable_data() {
  return &data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
QTensorProto::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.data)
  return _internal_mutable_data();
}

// optional string name = 7;
inline bool QTensorProto::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool QTensorProto::has_name() const {
  return _internal_has_name();
}
inline void QTensorProto::clear_name() {
  name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& QTensorProto::name() const {
  // @@protoc_insertion_point(field_get:caffe2.QTensorProto.name)
  return _internal_name();
}
inline void QTensorProto::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:caffe2.QTensorProto.name)
}
inline std::string* QTensorProto::mutable_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.QTensorProto.name)
  return _internal_mutable_name();
}
inline const std::string& QTensorProto::_internal_name() const {
  return name_.Get();
}
inline void QTensorProto::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void QTensorProto::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.QTensorProto.name)
}
inline void QTensorProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.QTensorProto.name)
}
inline void QTensorProto::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.QTensorProto.name)
}
inline std::string* QTensorProto::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* QTensorProto::release_name() {
  // @@protoc_insertion_point(field_release:caffe2.QTensorProto.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void QTensorProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.QTensorProto.name)
}

// optional .caffe2.TensorProto.DataType data_type = 8 [default = INT32];
inline bool QTensorProto::_internal_has_data_type() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool QTensorProto::has_data_type() const {
  return _internal_has_data_type();
}
inline void QTensorProto::clear_data_type() {
  data_type_ = 2;
  _has_bits_[0] &= ~0x00000080u;
}
inline ::caffe2::TensorProto_DataType QTensorProto::_internal_data_type() const {
  return static_cast< ::caffe2::TensorProto_DataType >(data_type_);
}
inline ::caffe2::TensorProto_DataType QTensorProto::data_type() const {
  // @@protoc_insertion_point(field_get:caffe2.QTensorProto.data_type)
  return _internal_data_type();
}
inline void QTensorProto::_internal_set_data_type(::caffe2::TensorProto_DataType value) {
  assert(::caffe2::TensorProto_DataType_IsValid(value));
  _has_bits_[0] |= 0x00000080u;
  data_type_ = value;
}
inline void QTensorProto::set_data_type(::caffe2::TensorProto_DataType value) {
  _internal_set_data_type(value);
  // @@protoc_insertion_point(field_set:caffe2.QTensorProto.data_type)
}

// repeated double scales = 9;
inline int QTensorProto::_internal_scales_size() const {
  return scales_.size();
}
inline int QTensorProto::scales_size() const {
  return _internal_scales_size();
}
inline void QTensorProto::clear_scales() {
  scales_.Clear();
}
inline double QTensorProto::_internal_scales(int index) const {
  return scales_.Get(index);
}
inline double QTensorProto::scales(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.QTensorProto.scales)
  return _internal_scales(index);
}
inline void QTensorProto::set_scales(int index, double value) {
  scales_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.QTensorProto.scales)
}
inline void QTensorProto::_internal_add_scales(double value) {
  scales_.Add(value);
}
inline void QTensorProto::add_scales(double value) {
  _internal_add_scales(value);
  // @@protoc_insertion_point(field_add:caffe2.QTensorProto.scales)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
QTensorProto::_internal_scales() const {
  return scales_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
QTensorProto::scales() const {
  // @@protoc_insertion_point(field_list:caffe2.QTensorProto.scales)
  return _internal_scales();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
QTensorProto::_internal_mutable_scales() {
  return &scales_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
QTensorProto::mutable_scales() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.scales)
  return _internal_mutable_scales();
}

// repeated double biases = 10;
inline int QTensorProto::_internal_biases_size() const {
  return biases_.size();
}
inline int QTensorProto::biases_size() const {
  return _internal_biases_size();
}
inline void QTensorProto::clear_biases() {
  biases_.Clear();
}
inline double QTensorProto::_internal_biases(int index) const {
  return biases_.Get(index);
}
inline double QTensorProto::biases(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.QTensorProto.biases)
  return _internal_biases(index);
}
inline void QTensorProto::set_biases(int index, double value) {
  biases_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.QTensorProto.biases)
}
inline void QTensorProto::_internal_add_biases(double value) {
  biases_.Add(value);
}
inline void QTensorProto::add_biases(double value) {
  _internal_add_biases(value);
  // @@protoc_insertion_point(field_add:caffe2.QTensorProto.biases)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
QTensorProto::_internal_biases() const {
  return biases_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
QTensorProto::biases() const {
  // @@protoc_insertion_point(field_list:caffe2.QTensorProto.biases)
  return _internal_biases();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
QTensorProto::_internal_mutable_biases() {
  return &biases_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
QTensorProto::mutable_biases() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.biases)
  return _internal_mutable_biases();
}

// optional int32 axis = 11;
inline bool QTensorProto::_internal_has_axis() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool QTensorProto::has_axis() const {
  return _internal_has_axis();
}
inline void QTensorProto::clear_axis() {
  axis_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::_internal_axis() const {
  return axis_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::axis() const {
  // @@protoc_insertion_point(field_get:caffe2.QTensorProto.axis)
  return _internal_axis();
}
inline void QTensorProto::_internal_set_axis(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000040u;
  axis_ = value;
}
inline void QTensorProto::set_axis(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_axis(value);
  // @@protoc_insertion_point(field_set:caffe2.QTensorProto.axis)
}

// optional bool is_multiparam = 12 [default = false];
inline bool QTensorProto::_internal_has_is_multiparam() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool QTensorProto::has_is_multiparam() const {
  return _internal_has_is_multiparam();
}
inline void QTensorProto::clear_is_multiparam() {
  is_multiparam_ = false;
  _has_bits_[0] &= ~0x00000020u;
}
inline bool QTensorProto::_internal_is_multiparam() const {
  return is_multiparam_;
}
inline bool QTensorProto::is_multiparam() const {
  // @@protoc_insertion_point(field_get:caffe2.QTensorProto.is_multiparam)
  return _internal_is_multiparam();
}
inline void QTensorProto::_internal_set_is_multiparam(bool value) {
  _has_bits_[0] |= 0x00000020u;
  is_multiparam_ = value;
}
inline void QTensorProto::set_is_multiparam(bool value) {
  _internal_set_is_multiparam(value);
  // @@protoc_insertion_point(field_set:caffe2.QTensorProto.is_multiparam)
}

// -------------------------------------------------------------------

// TensorProtos

// repeated .caffe2.TensorProto protos = 1;
inline int TensorProtos::_internal_protos_size() const {
  return protos_.size();
}
inline int TensorProtos::protos_size() const {
  return _internal_protos_size();
}
inline void TensorProtos::clear_protos() {
  protos_.Clear();
}
inline ::caffe2::TensorProto* TensorProtos::mutable_protos(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.TensorProtos.protos)
  return protos_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >*
TensorProtos::mutable_protos() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProtos.protos)
  return &protos_;
}
inline const ::caffe2::TensorProto& TensorProtos::_internal_protos(int index) const {
  return protos_.Get(index);
}
inline const ::caffe2::TensorProto& TensorProtos::protos(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.TensorProtos.protos)
  return _internal_protos(index);
}
inline ::caffe2::TensorProto* TensorProtos::_internal_add_protos() {
  return protos_.Add();
}
inline ::caffe2::TensorProto* TensorProtos::add_protos() {
  // @@protoc_insertion_point(field_add:caffe2.TensorProtos.protos)
  return _internal_add_protos();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >&
TensorProtos::protos() const {
  // @@protoc_insertion_point(field_list:caffe2.TensorProtos.protos)
  return protos_;
}

// -------------------------------------------------------------------

// TensorShape

// repeated int64 dims = 1;
inline int TensorShape::_internal_dims_size() const {
  return dims_.size();
}
inline int TensorShape::dims_size() const {
  return _internal_dims_size();
}
inline void TensorShape::clear_dims() {
  dims_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorShape::_internal_dims(int index) const {
  return dims_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorShape::dims(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.TensorShape.dims)
  return _internal_dims(index);
}
inline void TensorShape::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  dims_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.TensorShape.dims)
}
inline void TensorShape::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
  dims_.Add(value);
}
inline void TensorShape::add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_add_dims(value);
  // @@protoc_insertion_point(field_add:caffe2.TensorShape.dims)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
TensorShape::_internal_dims() const {
  return dims_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
TensorShape::dims() const {
  // @@protoc_insertion_point(field_list:caffe2.TensorShape.dims)
  return _internal_dims();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
TensorShape::_internal_mutable_dims() {
  return &dims_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
TensorShape::mutable_dims() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.TensorShape.dims)
  return _internal_mutable_dims();
}

// optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT];
inline bool TensorShape::_internal_has_data_type() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool TensorShape::has_data_type() const {
  return _internal_has_data_type();
}
inline void TensorShape::clear_data_type() {
  data_type_ = 1;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::caffe2::TensorProto_DataType TensorShape::_internal_data_type() const {
  return static_cast< ::caffe2::TensorProto_DataType >(data_type_);
}
inline ::caffe2::TensorProto_DataType TensorShape::data_type() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorShape.data_type)
  return _internal_data_type();
}
inline void TensorShape::_internal_set_data_type(::caffe2::TensorProto_DataType value) {
  assert(::caffe2::TensorProto_DataType_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  data_type_ = value;
}
inline void TensorShape::set_data_type(::caffe2::TensorProto_DataType value) {
  _internal_set_data_type(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorShape.data_type)
}

// repeated int32 unknown_dims = 3;
inline int TensorShape::_internal_unknown_dims_size() const {
  return unknown_dims_.size();
}
inline int TensorShape::unknown_dims_size() const {
  return _internal_unknown_dims_size();
}
inline void TensorShape::clear_unknown_dims() {
  unknown_dims_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TensorShape::_internal_unknown_dims(int index) const {
  return unknown_dims_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TensorShape::unknown_dims(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.TensorShape.unknown_dims)
  return _internal_unknown_dims(index);
}
inline void TensorShape::set_unknown_dims(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
  unknown_dims_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.TensorShape.unknown_dims)
}
inline void TensorShape::_internal_add_unknown_dims(::PROTOBUF_NAMESPACE_ID::int32 value) {
  unknown_dims_.Add(value);
}
inline void TensorShape::add_unknown_dims(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_add_unknown_dims(value);
  // @@protoc_insertion_point(field_add:caffe2.TensorShape.unknown_dims)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
TensorShape::_internal_unknown_dims() const {
  return unknown_dims_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
TensorShape::unknown_dims() const {
  // @@protoc_insertion_point(field_list:caffe2.TensorShape.unknown_dims)
  return _internal_unknown_dims();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
TensorShape::_internal_mutable_unknown_dims() {
  return &unknown_dims_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
TensorShape::mutable_unknown_dims() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.TensorShape.unknown_dims)
  return _internal_mutable_unknown_dims();
}

// optional bool unknown_shape = 4 [default = false];
inline bool TensorShape::_internal_has_unknown_shape() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool TensorShape::has_unknown_shape() const {
  return _internal_has_unknown_shape();
}
inline void TensorShape::clear_unknown_shape() {
  unknown_shape_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool TensorShape::_internal_unknown_shape() const {
  return unknown_shape_;
}
inline bool TensorShape::unknown_shape() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorShape.unknown_shape)
  return _internal_unknown_shape();
}
inline void TensorShape::_internal_set_unknown_shape(bool value) {
  _has_bits_[0] |= 0x00000002u;
  unknown_shape_ = value;
}
inline void TensorShape::set_unknown_shape(bool value) {
  _internal_set_unknown_shape(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorShape.unknown_shape)
}

// optional string name = 5;
inline bool TensorShape::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TensorShape::has_name() const {
  return _internal_has_name();
}
inline void TensorShape::clear_name() {
  name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TensorShape::name() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorShape.name)
  return _internal_name();
}
inline void TensorShape::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorShape.name)
}
inline std::string* TensorShape::mutable_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.TensorShape.name)
  return _internal_mutable_name();
}
inline const std::string& TensorShape::_internal_name() const {
  return name_.Get();
}
inline void TensorShape::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void TensorShape::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorShape.name)
}
inline void TensorShape::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.TensorShape.name)
}
inline void TensorShape::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.TensorShape.name)
}
inline std::string* TensorShape::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* TensorShape::release_name() {
  // @@protoc_insertion_point(field_release:caffe2.TensorShape.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void TensorShape::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.TensorShape.name)
}

// -------------------------------------------------------------------

// TensorShapes

// repeated .caffe2.TensorShape shapes = 1;
inline int TensorShapes::_internal_shapes_size() const {
  return shapes_.size();
}
inline int TensorShapes::shapes_size() const {
  return _internal_shapes_size();
}
inline void TensorShapes::clear_shapes() {
  shapes_.Clear();
}
inline ::caffe2::TensorShape* TensorShapes::mutable_shapes(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.TensorShapes.shapes)
  return shapes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape >*
TensorShapes::mutable_shapes() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.TensorShapes.shapes)
  return &shapes_;
}
inline const ::caffe2::TensorShape& TensorShapes::_internal_shapes(int index) const {
  return shapes_.Get(index);
}
inline const ::caffe2::TensorShape& TensorShapes::shapes(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.TensorShapes.shapes)
  return _internal_shapes(index);
}
inline ::caffe2::TensorShape* TensorShapes::_internal_add_shapes() {
  return shapes_.Add();
}
inline ::caffe2::TensorShape* TensorShapes::add_shapes() {
  // @@protoc_insertion_point(field_add:caffe2.TensorShapes.shapes)
  return _internal_add_shapes();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape >&
TensorShapes::shapes() const {
  // @@protoc_insertion_point(field_list:caffe2.TensorShapes.shapes)
  return shapes_;
}

// -------------------------------------------------------------------

// TensorBoundShape

// optional .caffe2.TensorShape shape = 1;
inline bool TensorBoundShape::_internal_has_shape() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || shape_ != nullptr);
  return value;
}
inline bool TensorBoundShape::has_shape() const {
  return _internal_has_shape();
}
inline void TensorBoundShape::clear_shape() {
  if (shape_ != nullptr) shape_->Clear();
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::caffe2::TensorShape& TensorBoundShape::_internal_shape() const {
  const ::caffe2::TensorShape* p = shape_;
  return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::TensorShape*>(
      &::caffe2::_TensorShape_default_instance_);
}
inline const ::caffe2::TensorShape& TensorBoundShape::shape() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.shape)
  return _internal_shape();
}
inline void TensorBoundShape::unsafe_arena_set_allocated_shape(
    ::caffe2::TensorShape* shape) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_);
  }
  shape_ = shape;
  if (shape) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.TensorBoundShape.shape)
}
inline ::caffe2::TensorShape* TensorBoundShape::release_shape() {
  _has_bits_[0] &= ~0x00000002u;
  ::caffe2::TensorShape* temp = shape_;
  shape_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::caffe2::TensorShape* TensorBoundShape::unsafe_arena_release_shape() {
  // @@protoc_insertion_point(field_release:caffe2.TensorBoundShape.shape)
  _has_bits_[0] &= ~0x00000002u;
  ::caffe2::TensorShape* temp = shape_;
  shape_ = nullptr;
  return temp;
}
inline ::caffe2::TensorShape* TensorBoundShape::_internal_mutable_shape() {
  _has_bits_[0] |= 0x00000002u;
  if (shape_ == nullptr) {
    auto* p = CreateMaybeMessage<::caffe2::TensorShape>(GetArena());
    shape_ = p;
  }
  return shape_;
}
inline ::caffe2::TensorShape* TensorBoundShape::mutable_shape() {
  // @@protoc_insertion_point(field_mutable:caffe2.TensorBoundShape.shape)
  return _internal_mutable_shape();
}
inline void TensorBoundShape::set_allocated_shape(::caffe2::TensorShape* shape) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete shape_;
  }
  if (shape) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(shape);
    if (message_arena != submessage_arena) {
      shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, shape, submessage_arena);
    }
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  shape_ = shape;
  // @@protoc_insertion_point(field_set_allocated:caffe2.TensorBoundShape.shape)
}

// repeated .caffe2.TensorBoundShape.DimType dim_type = 2;
inline int TensorBoundShape::_internal_dim_type_size() const {
  return dim_type_.size();
}
inline int TensorBoundShape::dim_type_size() const {
  return _internal_dim_type_size();
}
inline void TensorBoundShape::clear_dim_type() {
  dim_type_.Clear();
}
inline ::caffe2::TensorBoundShape_DimType TensorBoundShape::_internal_dim_type(int index) const {
  return static_cast< ::caffe2::TensorBoundShape_DimType >(dim_type_.Get(index));
}
inline ::caffe2::TensorBoundShape_DimType TensorBoundShape::dim_type(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.dim_type)
  return _internal_dim_type(index);
}
inline void TensorBoundShape::set_dim_type(int index, ::caffe2::TensorBoundShape_DimType value) {
  assert(::caffe2::TensorBoundShape_DimType_IsValid(value));
  dim_type_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.TensorBoundShape.dim_type)
}
inline void TensorBoundShape::_internal_add_dim_type(::caffe2::TensorBoundShape_DimType value) {
  assert(::caffe2::TensorBoundShape_DimType_IsValid(value));
  dim_type_.Add(value);
}
inline void TensorBoundShape::add_dim_type(::caffe2::TensorBoundShape_DimType value) {
  // @@protoc_insertion_point(field_add:caffe2.TensorBoundShape.dim_type)
  _internal_add_dim_type(value);
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
TensorBoundShape::dim_type() const {
  // @@protoc_insertion_point(field_list:caffe2.TensorBoundShape.dim_type)
  return dim_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
TensorBoundShape::_internal_mutable_dim_type() {
  return &dim_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
TensorBoundShape::mutable_dim_type() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.TensorBoundShape.dim_type)
  return _internal_mutable_dim_type();
}

// optional string name = 3;
inline bool TensorBoundShape::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TensorBoundShape::has_name() const {
  return _internal_has_name();
}
inline void TensorBoundShape::clear_name() {
  name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TensorBoundShape::name() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.name)
  return _internal_name();
}
inline void TensorBoundShape::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorBoundShape.name)
}
inline std::string* TensorBoundShape::mutable_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.TensorBoundShape.name)
  return _internal_mutable_name();
}
inline const std::string& TensorBoundShape::_internal_name() const {
  return name_.Get();
}
inline void TensorBoundShape::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void TensorBoundShape::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorBoundShape.name)
}
inline void TensorBoundShape::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.TensorBoundShape.name)
}
inline void TensorBoundShape::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.TensorBoundShape.name)
}
inline std::string* TensorBoundShape::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* TensorBoundShape::release_name() {
  // @@protoc_insertion_point(field_release:caffe2.TensorBoundShape.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void TensorBoundShape::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.TensorBoundShape.name)
}

// optional bool shape_is_final = 4;
inline bool TensorBoundShape::_internal_has_shape_is_final() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool TensorBoundShape::has_shape_is_final() const {
  return _internal_has_shape_is_final();
}
inline void TensorBoundShape::clear_shape_is_final() {
  shape_is_final_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool TensorBoundShape::_internal_shape_is_final() const {
  return shape_is_final_;
}
inline bool TensorBoundShape::shape_is_final() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.shape_is_final)
  return _internal_shape_is_final();
}
inline void TensorBoundShape::_internal_set_shape_is_final(bool value) {
  _has_bits_[0] |= 0x00000004u;
  shape_is_final_ = value;
}
inline void TensorBoundShape::set_shape_is_final(bool value) {
  _internal_set_shape_is_final(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorBoundShape.shape_is_final)
}

// -------------------------------------------------------------------

// TensorBoundShapes

// repeated .caffe2.TensorBoundShape shapes = 1;
inline int TensorBoundShapes::_internal_shapes_size() const {
  return shapes_.size();
}
inline int TensorBoundShapes::shapes_size() const {
  return _internal_shapes_size();
}
inline void TensorBoundShapes::clear_shapes() {
  shapes_.Clear();
}
inline ::caffe2::TensorBoundShape* TensorBoundShapes::mutable_shapes(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.TensorBoundShapes.shapes)
  return shapes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape >*
TensorBoundShapes::mutable_shapes() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.TensorBoundShapes.shapes)
  return &shapes_;
}
inline const ::caffe2::TensorBoundShape& TensorBoundShapes::_internal_shapes(int index) const {
  return shapes_.Get(index);
}
inline const ::caffe2::TensorBoundShape& TensorBoundShapes::shapes(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.TensorBoundShapes.shapes)
  return _internal_shapes(index);
}
inline ::caffe2::TensorBoundShape* TensorBoundShapes::_internal_add_shapes() {
  return shapes_.Add();
}
inline ::caffe2::TensorBoundShape* TensorBoundShapes::add_shapes() {
  // @@protoc_insertion_point(field_add:caffe2.TensorBoundShapes.shapes)
  return _internal_add_shapes();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape >&
TensorBoundShapes::shapes() const {
  // @@protoc_insertion_point(field_list:caffe2.TensorBoundShapes.shapes)
  return shapes_;
}

// optional int64 max_batch_size = 2;
inline bool TensorBoundShapes::_internal_has_max_batch_size() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TensorBoundShapes::has_max_batch_size() const {
  return _internal_has_max_batch_size();
}
inline void TensorBoundShapes::clear_max_batch_size() {
  max_batch_size_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorBoundShapes::_internal_max_batch_size() const {
  return max_batch_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorBoundShapes::max_batch_size() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorBoundShapes.max_batch_size)
  return _internal_max_batch_size();
}
inline void TensorBoundShapes::_internal_set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000001u;
  max_batch_size_ = value;
}
inline void TensorBoundShapes::set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_max_batch_size(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorBoundShapes.max_batch_size)
}

// optional int64 max_feature_len = 3;
inline bool TensorBoundShapes::_internal_has_max_feature_len() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool TensorBoundShapes::has_max_feature_len() const {
  return _internal_has_max_feature_len();
}
inline void TensorBoundShapes::clear_max_feature_len() {
  max_feature_len_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorBoundShapes::_internal_max_feature_len() const {
  return max_feature_len_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TensorBoundShapes::max_feature_len() const {
  // @@protoc_insertion_point(field_get:caffe2.TensorBoundShapes.max_feature_len)
  return _internal_max_feature_len();
}
inline void TensorBoundShapes::_internal_set_max_feature_len(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000002u;
  max_feature_len_ = value;
}
inline void TensorBoundShapes::set_max_feature_len(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_max_feature_len(value);
  // @@protoc_insertion_point(field_set:caffe2.TensorBoundShapes.max_feature_len)
}

// -------------------------------------------------------------------

// AOTConfig

// required int64 max_batch_size = 1;
inline bool AOTConfig::_internal_has_max_batch_size() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool AOTConfig::has_max_batch_size() const {
  return _internal_has_max_batch_size();
}
inline void AOTConfig::clear_max_batch_size() {
  max_batch_size_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 AOTConfig::_internal_max_batch_size() const {
  return max_batch_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 AOTConfig::max_batch_size() const {
  // @@protoc_insertion_point(field_get:caffe2.AOTConfig.max_batch_size)
  return _internal_max_batch_size();
}
inline void AOTConfig::_internal_set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000002u;
  max_batch_size_ = value;
}
inline void AOTConfig::set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_max_batch_size(value);
  // @@protoc_insertion_point(field_set:caffe2.AOTConfig.max_batch_size)
}

// required int64 max_seq_size = 2;
inline bool AOTConfig::_internal_has_max_seq_size() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool AOTConfig::has_max_seq_size() const {
  return _internal_has_max_seq_size();
}
inline void AOTConfig::clear_max_seq_size() {
  max_seq_size_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 AOTConfig::_internal_max_seq_size() const {
  return max_seq_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 AOTConfig::max_seq_size() const {
  // @@protoc_insertion_point(field_get:caffe2.AOTConfig.max_seq_size)
  return _internal_max_seq_size();
}
inline void AOTConfig::_internal_set_max_seq_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000004u;
  max_seq_size_ = value;
}
inline void AOTConfig::set_max_seq_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_max_seq_size(value);
  // @@protoc_insertion_point(field_set:caffe2.AOTConfig.max_seq_size)
}

// required bool in_batch_broadcast = 3;
inline bool AOTConfig::_internal_has_in_batch_broadcast() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool AOTConfig::has_in_batch_broadcast() const {
  return _internal_has_in_batch_broadcast();
}
inline void AOTConfig::clear_in_batch_broadcast() {
  in_batch_broadcast_ = false;
  _has_bits_[0] &= ~0x00000008u;
}
inline bool AOTConfig::_internal_in_batch_broadcast() const {
  return in_batch_broadcast_;
}
inline bool AOTConfig::in_batch_broadcast() const {
  // @@protoc_insertion_point(field_get:caffe2.AOTConfig.in_batch_broadcast)
  return _internal_in_batch_broadcast();
}
inline void AOTConfig::_internal_set_in_batch_broadcast(bool value) {
  _has_bits_[0] |= 0x00000008u;
  in_batch_broadcast_ = value;
}
inline void AOTConfig::set_in_batch_broadcast(bool value) {
  _internal_set_in_batch_broadcast(value);
  // @@protoc_insertion_point(field_set:caffe2.AOTConfig.in_batch_broadcast)
}

// optional string onnxifi_blacklist_ops = 4;
inline bool AOTConfig::_internal_has_onnxifi_blacklist_ops() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool AOTConfig::has_onnxifi_blacklist_ops() const {
  return _internal_has_onnxifi_blacklist_ops();
}
inline void AOTConfig::clear_onnxifi_blacklist_ops() {
  onnxifi_blacklist_ops_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& AOTConfig::onnxifi_blacklist_ops() const {
  // @@protoc_insertion_point(field_get:caffe2.AOTConfig.onnxifi_blacklist_ops)
  return _internal_onnxifi_blacklist_ops();
}
inline void AOTConfig::set_onnxifi_blacklist_ops(const std::string& value) {
  _internal_set_onnxifi_blacklist_ops(value);
  // @@protoc_insertion_point(field_set:caffe2.AOTConfig.onnxifi_blacklist_ops)
}
inline std::string* AOTConfig::mutable_onnxifi_blacklist_ops() {
  // @@protoc_insertion_point(field_mutable:caffe2.AOTConfig.onnxifi_blacklist_ops)
  return _internal_mutable_onnxifi_blacklist_ops();
}
inline const std::string& AOTConfig::_internal_onnxifi_blacklist_ops() const {
  return onnxifi_blacklist_ops_.Get();
}
inline void AOTConfig::_internal_set_onnxifi_blacklist_ops(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  onnxifi_blacklist_ops_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void AOTConfig::set_onnxifi_blacklist_ops(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  onnxifi_blacklist_ops_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.AOTConfig.onnxifi_blacklist_ops)
}
inline void AOTConfig::set_onnxifi_blacklist_ops(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  onnxifi_blacklist_ops_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.AOTConfig.onnxifi_blacklist_ops)
}
inline void AOTConfig::set_onnxifi_blacklist_ops(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  onnxifi_blacklist_ops_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.AOTConfig.onnxifi_blacklist_ops)
}
inline std::string* AOTConfig::_internal_mutable_onnxifi_blacklist_ops() {
  _has_bits_[0] |= 0x00000001u;
  return onnxifi_blacklist_ops_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* AOTConfig::release_onnxifi_blacklist_ops() {
  // @@protoc_insertion_point(field_release:caffe2.AOTConfig.onnxifi_blacklist_ops)
  if (!_internal_has_onnxifi_blacklist_ops()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return onnxifi_blacklist_ops_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void AOTConfig::set_allocated_onnxifi_blacklist_ops(std::string* onnxifi_blacklist_ops) {
  if (onnxifi_blacklist_ops != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  onnxifi_blacklist_ops_.SetAllocated(&GetEmptyStringAlreadyInited(), onnxifi_blacklist_ops,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.AOTConfig.onnxifi_blacklist_ops)
}

// optional int32 onnxifi_min_ops = 5;
inline bool AOTConfig::_internal_has_onnxifi_min_ops() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool AOTConfig::has_onnxifi_min_ops() const {
  return _internal_has_onnxifi_min_ops();
}
inline void AOTConfig::clear_onnxifi_min_ops() {
  onnxifi_min_ops_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 AOTConfig::_internal_onnxifi_min_ops() const {
  return onnxifi_min_ops_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 AOTConfig::onnxifi_min_ops() const {
  // @@protoc_insertion_point(field_get:caffe2.AOTConfig.onnxifi_min_ops)
  return _internal_onnxifi_min_ops();
}
inline void AOTConfig::_internal_set_onnxifi_min_ops(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000010u;
  onnxifi_min_ops_ = value;
}
inline void AOTConfig::set_onnxifi_min_ops(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_onnxifi_min_ops(value);
  // @@protoc_insertion_point(field_set:caffe2.AOTConfig.onnxifi_min_ops)
}

// -------------------------------------------------------------------

// Argument

// optional string name = 1;
inline bool Argument::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Argument::has_name() const {
  return _internal_has_name();
}
inline void Argument::clear_name() {
  name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Argument::name() const {
  // @@protoc_insertion_point(field_get:caffe2.Argument.name)
  return _internal_name();
}
inline void Argument::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:caffe2.Argument.name)
}
inline std::string* Argument::mutable_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.Argument.name)
  return _internal_mutable_name();
}
inline const std::string& Argument::_internal_name() const {
  return name_.Get();
}
inline void Argument::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Argument::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.Argument.name)
}
inline void Argument::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.Argument.name)
}
inline void Argument::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.Argument.name)
}
inline std::string* Argument::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Argument::release_name() {
  // @@protoc_insertion_point(field_release:caffe2.Argument.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void Argument::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.name)
}

// optional float f = 2;
inline bool Argument::_internal_has_f() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Argument::has_f() const {
  return _internal_has_f();
}
inline void Argument::clear_f() {
  f_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline float Argument::_internal_f() const {
  return f_;
}
inline float Argument::f() const {
  // @@protoc_insertion_point(field_get:caffe2.Argument.f)
  return _internal_f();
}
inline void Argument::_internal_set_f(float value) {
  _has_bits_[0] |= 0x00000020u;
  f_ = value;
}
inline void Argument::set_f(float value) {
  _internal_set_f(value);
  // @@protoc_insertion_point(field_set:caffe2.Argument.f)
}

// optional int64 i = 3;
inline bool Argument::_internal_has_i() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Argument::has_i() const {
  return _internal_has_i();
}
inline void Argument::clear_i() {
  i_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Argument::_internal_i() const {
  return i_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Argument::i() const {
  // @@protoc_insertion_point(field_get:caffe2.Argument.i)
  return _internal_i();
}
inline void Argument::_internal_set_i(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000010u;
  i_ = value;
}
inline void Argument::set_i(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_i(value);
  // @@protoc_insertion_point(field_set:caffe2.Argument.i)
}

// optional bytes s = 4;
inline bool Argument::_internal_has_s() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Argument::has_s() const {
  return _internal_has_s();
}
inline void Argument::clear_s() {
  s_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Argument::s() const {
  // @@protoc_insertion_point(field_get:caffe2.Argument.s)
  return _internal_s();
}
inline void Argument::set_s(const std::string& value) {
  _internal_set_s(value);
  // @@protoc_insertion_point(field_set:caffe2.Argument.s)
}
inline std::string* Argument::mutable_s() {
  // @@protoc_insertion_point(field_mutable:caffe2.Argument.s)
  return _internal_mutable_s();
}
inline const std::string& Argument::_internal_s() const {
  return s_.Get();
}
inline void Argument::_internal_set_s(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  s_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Argument::set_s(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  s_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.Argument.s)
}
inline void Argument::set_s(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  s_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.Argument.s)
}
inline void Argument::set_s(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  s_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.Argument.s)
}
inline std::string* Argument::_internal_mutable_s() {
  _has_bits_[0] |= 0x00000002u;
  return s_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Argument::release_s() {
  // @@protoc_insertion_point(field_release:caffe2.Argument.s)
  if (!_internal_has_s()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return s_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void Argument::set_allocated_s(std::string* s) {
  if (s != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  s_.SetAllocated(&GetEmptyStringAlreadyInited(), s,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.s)
}

// optional .caffe2.TensorProto t = 10;
inline bool Argument::_internal_has_t() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || t_ != nullptr);
  return value;
}
inline bool Argument::has_t() const {
  return _internal_has_t();
}
inline void Argument::clear_t() {
  if (t_ != nullptr) t_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::caffe2::TensorProto& Argument::_internal_t() const {
  const ::caffe2::TensorProto* p = t_;
  return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::TensorProto*>(
      &::caffe2::_TensorProto_default_instance_);
}
inline const ::caffe2::TensorProto& Argument::t() const {
  // @@protoc_insertion_point(field_get:caffe2.Argument.t)
  return _internal_t();
}
inline void Argument::unsafe_arena_set_allocated_t(
    ::caffe2::TensorProto* t) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(t_);
  }
  t_ = t;
  if (t) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.Argument.t)
}
inline ::caffe2::TensorProto* Argument::release_t() {
  _has_bits_[0] &= ~0x00000008u;
  ::caffe2::TensorProto* temp = t_;
  t_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::caffe2::TensorProto* Argument::unsafe_arena_release_t() {
  // @@protoc_insertion_point(field_release:caffe2.Argument.t)
  _has_bits_[0] &= ~0x00000008u;
  ::caffe2::TensorProto* temp = t_;
  t_ = nullptr;
  return temp;
}
inline ::caffe2::TensorProto* Argument::_internal_mutable_t() {
  _has_bits_[0] |= 0x00000008u;
  if (t_ == nullptr) {
    auto* p = CreateMaybeMessage<::caffe2::TensorProto>(GetArena());
    t_ = p;
  }
  return t_;
}
inline ::caffe2::TensorProto* Argument::mutable_t() {
  // @@protoc_insertion_point(field_mutable:caffe2.Argument.t)
  return _internal_mutable_t();
}
inline void Argument::set_allocated_t(::caffe2::TensorProto* t) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete t_;
  }
  if (t) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(t);
    if (message_arena != submessage_arena) {
      t = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, t, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  t_ = t;
  // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.t)
}

// optional .caffe2.NetDef n = 8;
inline bool Argument::_internal_has_n() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || n_ != nullptr);
  return value;
}
inline bool Argument::has_n() const {
  return _internal_has_n();
}
inline void Argument::clear_n() {
  if (n_ != nullptr) n_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::caffe2::NetDef& Argument::_internal_n() const {
  const ::caffe2::NetDef* p = n_;
  return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::NetDef*>(
      &::caffe2::_NetDef_default_instance_);
}
inline const ::caffe2::NetDef& Argument::n() const {
  // @@protoc_insertion_point(field_get:caffe2.Argument.n)
  return _internal_n();
}
inline void Argument::unsafe_arena_set_allocated_n(
    ::caffe2::NetDef* n) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(n_);
  }
  n_ = n;
  if (n) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.Argument.n)
}
inline ::caffe2::NetDef* Argument::release_n() {
  _has_bits_[0] &= ~0x00000004u;
  ::caffe2::NetDef* temp = n_;
  n_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::caffe2::NetDef* Argument::unsafe_arena_release_n() {
  // @@protoc_insertion_point(field_release:caffe2.Argument.n)
  _has_bits_[0] &= ~0x00000004u;
  ::caffe2::NetDef* temp = n_;
  n_ = nullptr;
  return temp;
}
inline ::caffe2::NetDef* Argument::_internal_mutable_n() {
  _has_bits_[0] |= 0x00000004u;
  if (n_ == nullptr) {
    auto* p = CreateMaybeMessage<::caffe2::NetDef>(GetArena());
    n_ = p;
  }
  return n_;
}
inline ::caffe2::NetDef* Argument::mutable_n() {
  // @@protoc_insertion_point(field_mutable:caffe2.Argument.n)
  return _internal_mutable_n();
}
inline void Argument::set_allocated_n(::caffe2::NetDef* n) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete n_;
  }
  if (n) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(n);
    if (message_arena != submessage_arena) {
      n = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, n, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  n_ = n;
  // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.n)
}

// repeated float floats = 5;
inline int Argument::_internal_floats_size() const {
  return floats_.size();
}
inline int Argument::floats_size() const {
  return _internal_floats_size();
}
inline void Argument::clear_floats() {
  floats_.Clear();
}
inline float Argument::_internal_floats(int index) const {
  return floats_.Get(index);
}
inline float Argument::floats(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.Argument.floats)
  return _internal_floats(index);
}
inline void Argument::set_floats(int index, float value) {
  floats_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.Argument.floats)
}
inline void Argument::_internal_add_floats(float value) {
  floats_.Add(value);
}
inline void Argument::add_floats(float value) {
  _internal_add_floats(value);
  // @@protoc_insertion_point(field_add:caffe2.Argument.floats)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
Argument::_internal_floats() const {
  return floats_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
Argument::floats() const {
  // @@protoc_insertion_point(field_list:caffe2.Argument.floats)
  return _internal_floats();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
Argument::_internal_mutable_floats() {
  return &floats_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
Argument::mutable_floats() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.floats)
  return _internal_mutable_floats();
}

// repeated int64 ints = 6;
inline int Argument::_internal_ints_size() const {
  return ints_.size();
}
inline int Argument::ints_size() const {
  return _internal_ints_size();
}
inline void Argument::clear_ints() {
  ints_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Argument::_internal_ints(int index) const {
  return ints_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Argument::ints(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.Argument.ints)
  return _internal_ints(index);
}
inline void Argument::set_ints(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  ints_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.Argument.ints)
}
inline void Argument::_internal_add_ints(::PROTOBUF_NAMESPACE_ID::int64 value) {
  ints_.Add(value);
}
inline void Argument::add_ints(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_add_ints(value);
  // @@protoc_insertion_point(field_add:caffe2.Argument.ints)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
Argument::_internal_ints() const {
  return ints_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
Argument::ints() const {
  // @@protoc_insertion_point(field_list:caffe2.Argument.ints)
  return _internal_ints();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
Argument::_internal_mutable_ints() {
  return &ints_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
Argument::mutable_ints() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.ints)
  return _internal_mutable_ints();
}

// repeated bytes strings = 7;
inline int Argument::_internal_strings_size() const {
  return strings_.size();
}
inline int Argument::strings_size() const {
  return _internal_strings_size();
}
inline void Argument::clear_strings() {
  strings_.Clear();
}
inline std::string* Argument::add_strings() {
  // @@protoc_insertion_point(field_add_mutable:caffe2.Argument.strings)
  return _internal_add_strings();
}
inline const std::string& Argument::_internal_strings(int index) const {
  return strings_.Get(index);
}
inline const std::string& Argument::strings(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.Argument.strings)
  return _internal_strings(index);
}
inline std::string* Argument::mutable_strings(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.Argument.strings)
  return strings_.Mutable(index);
}
inline void Argument::set_strings(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:caffe2.Argument.strings)
  strings_.Mutable(index)->assign(value);
}
inline void Argument::set_strings(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:caffe2.Argument.strings)
  strings_.Mutable(index)->assign(std::move(value));
}
inline void Argument::set_strings(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  strings_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:caffe2.Argument.strings)
}
inline void Argument::set_strings(int index, const void* value, size_t size) {
  strings_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:caffe2.Argument.strings)
}
inline std::string* Argument::_internal_add_strings() {
  return strings_.Add();
}
inline void Argument::add_strings(const std::string& value) {
  strings_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:caffe2.Argument.strings)
}
inline void Argument::add_strings(std::string&& value) {
  strings_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:caffe2.Argument.strings)
}
inline void Argument::add_strings(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  strings_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:caffe2.Argument.strings)
}
inline void Argument::add_strings(const void* value, size_t size) {
  strings_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:caffe2.Argument.strings)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Argument::strings() const {
  // @@protoc_insertion_point(field_list:caffe2.Argument.strings)
  return strings_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Argument::mutable_strings() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.strings)
  return &strings_;
}

// repeated .caffe2.TensorProto tensors = 11;
inline int Argument::_internal_tensors_size() const {
  return tensors_.size();
}
inline int Argument::tensors_size() const {
  return _internal_tensors_size();
}
inline void Argument::clear_tensors() {
  tensors_.Clear();
}
inline ::caffe2::TensorProto* Argument::mutable_tensors(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.Argument.tensors)
  return tensors_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >*
Argument::mutable_tensors() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.tensors)
  return &tensors_;
}
inline const ::caffe2::TensorProto& Argument::_internal_tensors(int index) const {
  return tensors_.Get(index);
}
inline const ::caffe2::TensorProto& Argument::tensors(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.Argument.tensors)
  return _internal_tensors(index);
}
inline ::caffe2::TensorProto* Argument::_internal_add_tensors() {
  return tensors_.Add();
}
inline ::caffe2::TensorProto* Argument::add_tensors() {
  // @@protoc_insertion_point(field_add:caffe2.Argument.tensors)
  return _internal_add_tensors();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >&
Argument::tensors() const {
  // @@protoc_insertion_point(field_list:caffe2.Argument.tensors)
  return tensors_;
}

// repeated .caffe2.NetDef nets = 9;
inline int Argument::_internal_nets_size() const {
  return nets_.size();
}
inline int Argument::nets_size() const {
  return _internal_nets_size();
}
inline void Argument::clear_nets() {
  nets_.Clear();
}
inline ::caffe2::NetDef* Argument::mutable_nets(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.Argument.nets)
  return nets_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >*
Argument::mutable_nets() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.nets)
  return &nets_;
}
inline const ::caffe2::NetDef& Argument::_internal_nets(int index) const {
  return nets_.Get(index);
}
inline const ::caffe2::NetDef& Argument::nets(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.Argument.nets)
  return _internal_nets(index);
}
inline ::caffe2::NetDef* Argument::_internal_add_nets() {
  return nets_.Add();
}
inline ::caffe2::NetDef* Argument::add_nets() {
  // @@protoc_insertion_point(field_add:caffe2.Argument.nets)
  return _internal_add_nets();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >&
Argument::nets() const {
  // @@protoc_insertion_point(field_list:caffe2.Argument.nets)
  return nets_;
}

// repeated .caffe2.QTensorProto qtensors = 12;
inline int Argument::_internal_qtensors_size() const {
  return qtensors_.size();
}
inline int Argument::qtensors_size() const {
  return _internal_qtensors_size();
}
inline void Argument::clear_qtensors() {
  qtensors_.Clear();
}
inline ::caffe2::QTensorProto* Argument::mutable_qtensors(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.Argument.qtensors)
  return qtensors_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto >*
Argument::mutable_qtensors() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.qtensors)
  return &qtensors_;
}
inline const ::caffe2::QTensorProto& Argument::_internal_qtensors(int index) const {
  return qtensors_.Get(index);
}
inline const ::caffe2::QTensorProto& Argument::qtensors(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.Argument.qtensors)
  return _internal_qtensors(index);
}
inline ::caffe2::QTensorProto* Argument::_internal_add_qtensors() {
  return qtensors_.Add();
}
inline ::caffe2::QTensorProto* Argument::add_qtensors() {
  // @@protoc_insertion_point(field_add:caffe2.Argument.qtensors)
  return _internal_add_qtensors();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto >&
Argument::qtensors() const {
  // @@protoc_insertion_point(field_list:caffe2.Argument.qtensors)
  return qtensors_;
}

// -------------------------------------------------------------------

// DeviceOption

// optional int32 device_type = 1 [default = 0];
inline bool DeviceOption::_internal_has_device_type() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DeviceOption::has_device_type() const {
  return _internal_has_device_type();
}
inline void DeviceOption::clear_device_type() {
  device_type_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::_internal_device_type() const {
  return device_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::device_type() const {
  // @@protoc_insertion_point(field_get:caffe2.DeviceOption.device_type)
  return _internal_device_type();
}
inline void DeviceOption::_internal_set_device_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000002u;
  device_type_ = value;
}
inline void DeviceOption::set_device_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_device_type(value);
  // @@protoc_insertion_point(field_set:caffe2.DeviceOption.device_type)
}

// optional int32 device_id = 2;
inline bool DeviceOption::_internal_has_device_id() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DeviceOption::has_device_id() const {
  return _internal_has_device_id();
}
inline void DeviceOption::clear_device_id() {
  device_id_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::_internal_device_id() const {
  return device_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::device_id() const {
  // @@protoc_insertion_point(field_get:caffe2.DeviceOption.device_id)
  return _internal_device_id();
}
inline void DeviceOption::_internal_set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000004u;
  device_id_ = value;
}
inline void DeviceOption::set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_device_id(value);
  // @@protoc_insertion_point(field_set:caffe2.DeviceOption.device_id)
}

// optional uint32 random_seed = 3;
inline bool DeviceOption::_internal_has_random_seed() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool DeviceOption::has_random_seed() const {
  return _internal_has_random_seed();
}
inline void DeviceOption::clear_random_seed() {
  random_seed_ = 0u;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceOption::_internal_random_seed() const {
  return random_seed_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceOption::random_seed() const {
  // @@protoc_insertion_point(field_get:caffe2.DeviceOption.random_seed)
  return _internal_random_seed();
}
inline void DeviceOption::_internal_set_random_seed(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000008u;
  random_seed_ = value;
}
inline void DeviceOption::set_random_seed(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_random_seed(value);
  // @@protoc_insertion_point(field_set:caffe2.DeviceOption.random_seed)
}

// optional string node_name = 4;
inline bool DeviceOption::_internal_has_node_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DeviceOption::has_node_name() const {
  return _internal_has_node_name();
}
inline void DeviceOption::clear_node_name() {
  node_name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DeviceOption::node_name() const {
  // @@protoc_insertion_point(field_get:caffe2.DeviceOption.node_name)
  return _internal_node_name();
}
inline void DeviceOption::set_node_name(const std::string& value) {
  _internal_set_node_name(value);
  // @@protoc_insertion_point(field_set:caffe2.DeviceOption.node_name)
}
inline std::string* DeviceOption::mutable_node_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.DeviceOption.node_name)
  return _internal_mutable_node_name();
}
inline const std::string& DeviceOption::_internal_node_name() const {
  return node_name_.Get();
}
inline void DeviceOption::_internal_set_node_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  node_name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void DeviceOption::set_node_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  node_name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.DeviceOption.node_name)
}
inline void DeviceOption::set_node_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  node_name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.DeviceOption.node_name)
}
inline void DeviceOption::set_node_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  node_name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.DeviceOption.node_name)
}
inline std::string* DeviceOption::_internal_mutable_node_name() {
  _has_bits_[0] |= 0x00000001u;
  return node_name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* DeviceOption::release_node_name() {
  // @@protoc_insertion_point(field_release:caffe2.DeviceOption.node_name)
  if (!_internal_has_node_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return node_name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void DeviceOption::set_allocated_node_name(std::string* node_name) {
  if (node_name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  node_name_.SetAllocated(&GetEmptyStringAlreadyInited(), node_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.DeviceOption.node_name)
}

// optional int32 numa_node_id = 5;
inline bool DeviceOption::_internal_has_numa_node_id() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool DeviceOption::has_numa_node_id() const {
  return _internal_has_numa_node_id();
}
inline void DeviceOption::clear_numa_node_id() {
  numa_node_id_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::_internal_numa_node_id() const {
  return numa_node_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::numa_node_id() const {
  // @@protoc_insertion_point(field_get:caffe2.DeviceOption.numa_node_id)
  return _internal_numa_node_id();
}
inline void DeviceOption::_internal_set_numa_node_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000010u;
  numa_node_id_ = value;
}
inline void DeviceOption::set_numa_node_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_numa_node_id(value);
  // @@protoc_insertion_point(field_set:caffe2.DeviceOption.numa_node_id)
}

// repeated string extra_info = 6;
inline int DeviceOption::_internal_extra_info_size() const {
  return extra_info_.size();
}
inline int DeviceOption::extra_info_size() const {
  return _internal_extra_info_size();
}
inline void DeviceOption::clear_extra_info() {
  extra_info_.Clear();
}
inline std::string* DeviceOption::add_extra_info() {
  // @@protoc_insertion_point(field_add_mutable:caffe2.DeviceOption.extra_info)
  return _internal_add_extra_info();
}
inline const std::string& DeviceOption::_internal_extra_info(int index) const {
  return extra_info_.Get(index);
}
inline const std::string& DeviceOption::extra_info(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.DeviceOption.extra_info)
  return _internal_extra_info(index);
}
inline std::string* DeviceOption::mutable_extra_info(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.DeviceOption.extra_info)
  return extra_info_.Mutable(index);
}
inline void DeviceOption::set_extra_info(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:caffe2.DeviceOption.extra_info)
  extra_info_.Mutable(index)->assign(value);
}
inline void DeviceOption::set_extra_info(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:caffe2.DeviceOption.extra_info)
  extra_info_.Mutable(index)->assign(std::move(value));
}
inline void DeviceOption::set_extra_info(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  extra_info_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:caffe2.DeviceOption.extra_info)
}
inline void DeviceOption::set_extra_info(int index, const char* value, size_t size) {
  extra_info_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:caffe2.DeviceOption.extra_info)
}
inline std::string* DeviceOption::_internal_add_extra_info() {
  return extra_info_.Add();
}
inline void DeviceOption::add_extra_info(const std::string& value) {
  extra_info_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:caffe2.DeviceOption.extra_info)
}
inline void DeviceOption::add_extra_info(std::string&& value) {
  extra_info_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:caffe2.DeviceOption.extra_info)
}
inline void DeviceOption::add_extra_info(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  extra_info_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:caffe2.DeviceOption.extra_info)
}
inline void DeviceOption::add_extra_info(const char* value, size_t size) {
  extra_info_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:caffe2.DeviceOption.extra_info)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
DeviceOption::extra_info() const {
  // @@protoc_insertion_point(field_list:caffe2.DeviceOption.extra_info)
  return extra_info_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
DeviceOption::mutable_extra_info() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.DeviceOption.extra_info)
  return &extra_info_;
}

// -------------------------------------------------------------------

// OperatorDef

// repeated string input = 1;
inline int OperatorDef::_internal_input_size() const {
  return input_.size();
}
inline int OperatorDef::input_size() const {
  return _internal_input_size();
}
inline void OperatorDef::clear_input() {
  input_.Clear();
}
inline std::string* OperatorDef::add_input() {
  // @@protoc_insertion_point(field_add_mutable:caffe2.OperatorDef.input)
  return _internal_add_input();
}
inline const std::string& OperatorDef::_internal_input(int index) const {
  return input_.Get(index);
}
inline const std::string& OperatorDef::input(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.OperatorDef.input)
  return _internal_input(index);
}
inline std::string* OperatorDef::mutable_input(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.input)
  return input_.Mutable(index);
}
inline void OperatorDef::set_input(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:caffe2.OperatorDef.input)
  input_.Mutable(index)->assign(value);
}
inline void OperatorDef::set_input(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:caffe2.OperatorDef.input)
  input_.Mutable(index)->assign(std::move(value));
}
inline void OperatorDef::set_input(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  input_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.input)
}
inline void OperatorDef::set_input(int index, const char* value, size_t size) {
  input_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.input)
}
inline std::string* OperatorDef::_internal_add_input() {
  return input_.Add();
}
inline void OperatorDef::add_input(const std::string& value) {
  input_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:caffe2.OperatorDef.input)
}
inline void OperatorDef::add_input(std::string&& value) {
  input_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:caffe2.OperatorDef.input)
}
inline void OperatorDef::add_input(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  input_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:caffe2.OperatorDef.input)
}
inline void OperatorDef::add_input(const char* value, size_t size) {
  input_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:caffe2.OperatorDef.input)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
OperatorDef::input() const {
  // @@protoc_insertion_point(field_list:caffe2.OperatorDef.input)
  return input_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
OperatorDef::mutable_input() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.input)
  return &input_;
}

// repeated string output = 2;
inline int OperatorDef::_internal_output_size() const {
  return output_.size();
}
inline int OperatorDef::output_size() const {
  return _internal_output_size();
}
inline void OperatorDef::clear_output() {
  output_.Clear();
}
inline std::string* OperatorDef::add_output() {
  // @@protoc_insertion_point(field_add_mutable:caffe2.OperatorDef.output)
  return _internal_add_output();
}
inline const std::string& OperatorDef::_internal_output(int index) const {
  return output_.Get(index);
}
inline const std::string& OperatorDef::output(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.OperatorDef.output)
  return _internal_output(index);
}
inline std::string* OperatorDef::mutable_output(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.output)
  return output_.Mutable(index);
}
inline void OperatorDef::set_output(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:caffe2.OperatorDef.output)
  output_.Mutable(index)->assign(value);
}
inline void OperatorDef::set_output(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:caffe2.OperatorDef.output)
  output_.Mutable(index)->assign(std::move(value));
}
inline void OperatorDef::set_output(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  output_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.output)
}
inline void OperatorDef::set_output(int index, const char* value, size_t size) {
  output_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.output)
}
inline std::string* OperatorDef::_internal_add_output() {
  return output_.Add();
}
inline void OperatorDef::add_output(const std::string& value) {
  output_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:caffe2.OperatorDef.output)
}
inline void OperatorDef::add_output(std::string&& value) {
  output_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:caffe2.OperatorDef.output)
}
inline void OperatorDef::add_output(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  output_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:caffe2.OperatorDef.output)
}
inline void OperatorDef::add_output(const char* value, size_t size) {
  output_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:caffe2.OperatorDef.output)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
OperatorDef::output() const {
  // @@protoc_insertion_point(field_list:caffe2.OperatorDef.output)
  return output_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
OperatorDef::mutable_output() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.output)
  return &output_;
}

// optional string name = 3;
inline bool OperatorDef::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool OperatorDef::has_name() const {
  return _internal_has_name();
}
inline void OperatorDef::clear_name() {
  name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& OperatorDef::name() const {
  // @@protoc_insertion_point(field_get:caffe2.OperatorDef.name)
  return _internal_name();
}
inline void OperatorDef::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:caffe2.OperatorDef.name)
}
inline std::string* OperatorDef::mutable_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.name)
  return _internal_mutable_name();
}
inline const std::string& OperatorDef::_internal_name() const {
  return name_.Get();
}
inline void OperatorDef::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void OperatorDef::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.name)
}
inline void OperatorDef::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.name)
}
inline void OperatorDef::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.name)
}
inline std::string* OperatorDef::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* OperatorDef::release_name() {
  // @@protoc_insertion_point(field_release:caffe2.OperatorDef.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void OperatorDef::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.name)
}

// optional string type = 4;
inline bool OperatorDef::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool OperatorDef::has_type() const {
  return _internal_has_type();
}
inline void OperatorDef::clear_type() {
  type_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& OperatorDef::type() const {
  // @@protoc_insertion_point(field_get:caffe2.OperatorDef.type)
  return _internal_type();
}
inline void OperatorDef::set_type(const std::string& value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:caffe2.OperatorDef.type)
}
inline std::string* OperatorDef::mutable_type() {
  // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.type)
  return _internal_mutable_type();
}
inline const std::string& OperatorDef::_internal_type() const {
  return type_.Get();
}
inline void OperatorDef::_internal_set_type(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  type_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void OperatorDef::set_type(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  type_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.type)
}
inline void OperatorDef::set_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.type)
}
inline void OperatorDef::set_type(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.type)
}
inline std::string* OperatorDef::_internal_mutable_type() {
  _has_bits_[0] |= 0x00000002u;
  return type_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* OperatorDef::release_type() {
  // @@protoc_insertion_point(field_release:caffe2.OperatorDef.type)
  if (!_internal_has_type()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return type_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void OperatorDef::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  type_.SetAllocated(&GetEmptyStringAlreadyInited(), type,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.type)
}

// repeated .caffe2.Argument arg = 5;
inline int OperatorDef::_internal_arg_size() const {
  return arg_.size();
}
inline int OperatorDef::arg_size() const {
  return _internal_arg_size();
}
inline void OperatorDef::clear_arg() {
  arg_.Clear();
}
inline ::caffe2::Argument* OperatorDef::mutable_arg(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.arg)
  return arg_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >*
OperatorDef::mutable_arg() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.arg)
  return &arg_;
}
inline const ::caffe2::Argument& OperatorDef::_internal_arg(int index) const {
  return arg_.Get(index);
}
inline const ::caffe2::Argument& OperatorDef::arg(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.OperatorDef.arg)
  return _internal_arg(index);
}
inline ::caffe2::Argument* OperatorDef::_internal_add_arg() {
  return arg_.Add();
}
inline ::caffe2::Argument* OperatorDef::add_arg() {
  // @@protoc_insertion_point(field_add:caffe2.OperatorDef.arg)
  return _internal_add_arg();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >&
OperatorDef::arg() const {
  // @@protoc_insertion_point(field_list:caffe2.OperatorDef.arg)
  return arg_;
}

// optional .caffe2.DeviceOption device_option = 6;
inline bool OperatorDef::_internal_has_device_option() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || device_option_ != nullptr);
  return value;
}
inline bool OperatorDef::has_device_option() const {
  return _internal_has_device_option();
}
inline void OperatorDef::clear_device_option() {
  if (device_option_ != nullptr) device_option_->Clear();
  _has_bits_[0] &= ~0x00000020u;
}
inline const ::caffe2::DeviceOption& OperatorDef::_internal_device_option() const {
  const ::caffe2::DeviceOption* p = device_option_;
  return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::DeviceOption*>(
      &::caffe2::_DeviceOption_default_instance_);
}
inline const ::caffe2::DeviceOption& OperatorDef::device_option() const {
  // @@protoc_insertion_point(field_get:caffe2.OperatorDef.device_option)
  return _internal_device_option();
}
inline void OperatorDef::unsafe_arena_set_allocated_device_option(
    ::caffe2::DeviceOption* device_option) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_option_);
  }
  device_option_ = device_option;
  if (device_option) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.OperatorDef.device_option)
}
inline ::caffe2::DeviceOption* OperatorDef::release_device_option() {
  _has_bits_[0] &= ~0x00000020u;
  ::caffe2::DeviceOption* temp = device_option_;
  device_option_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::caffe2::DeviceOption* OperatorDef::unsafe_arena_release_device_option() {
  // @@protoc_insertion_point(field_release:caffe2.OperatorDef.device_option)
  _has_bits_[0] &= ~0x00000020u;
  ::caffe2::DeviceOption* temp = device_option_;
  device_option_ = nullptr;
  return temp;
}
inline ::caffe2::DeviceOption* OperatorDef::_internal_mutable_device_option() {
  _has_bits_[0] |= 0x00000020u;
  if (device_option_ == nullptr) {
    auto* p = CreateMaybeMessage<::caffe2::DeviceOption>(GetArena());
    device_option_ = p;
  }
  return device_option_;
}
inline ::caffe2::DeviceOption* OperatorDef::mutable_device_option() {
  // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.device_option)
  return _internal_mutable_device_option();
}
inline void OperatorDef::set_allocated_device_option(::caffe2::DeviceOption* device_option) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete device_option_;
  }
  if (device_option) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(device_option);
    if (message_arena != submessage_arena) {
      device_option = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, device_option, submessage_arena);
    }
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  device_option_ = device_option;
  // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.device_option)
}

// optional string engine = 7;
inline bool OperatorDef::_internal_has_engine() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool OperatorDef::has_engine() const {
  return _internal_has_engine();
}
inline void OperatorDef::clear_engine() {
  engine_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& OperatorDef::engine() const {
  // @@protoc_insertion_point(field_get:caffe2.OperatorDef.engine)
  return _internal_engine();
}
inline void OperatorDef::set_engine(const std::string& value) {
  _internal_set_engine(value);
  // @@protoc_insertion_point(field_set:caffe2.OperatorDef.engine)
}
inline std::string* OperatorDef::mutable_engine() {
  // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.engine)
  return _internal_mutable_engine();
}
inline const std::string& OperatorDef::_internal_engine() const {
  return engine_.Get();
}
inline void OperatorDef::_internal_set_engine(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  engine_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void OperatorDef::set_engine(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  engine_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.engine)
}
inline void OperatorDef::set_engine(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  engine_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.engine)
}
inline void OperatorDef::set_engine(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000004u;
  engine_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.engine)
}
inline std::string* OperatorDef::_internal_mutable_engine() {
  _has_bits_[0] |= 0x00000004u;
  return engine_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* OperatorDef::release_engine() {
  // @@protoc_insertion_point(field_release:caffe2.OperatorDef.engine)
  if (!_internal_has_engine()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return engine_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void OperatorDef::set_allocated_engine(std::string* engine) {
  if (engine != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  engine_.SetAllocated(&GetEmptyStringAlreadyInited(), engine,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.engine)
}

// repeated string control_input = 8;
inline int OperatorDef::_internal_control_input_size() const {
  return control_input_.size();
}
inline int OperatorDef::control_input_size() const {
  return _internal_control_input_size();
}
inline void OperatorDef::clear_control_input() {
  control_input_.Clear();
}
inline std::string* OperatorDef::add_control_input() {
  // @@protoc_insertion_point(field_add_mutable:caffe2.OperatorDef.control_input)
  return _internal_add_control_input();
}
inline const std::string& OperatorDef::_internal_control_input(int index) const {
  return control_input_.Get(index);
}
inline const std::string& OperatorDef::control_input(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.OperatorDef.control_input)
  return _internal_control_input(index);
}
inline std::string* OperatorDef::mutable_control_input(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.control_input)
  return control_input_.Mutable(index);
}
inline void OperatorDef::set_control_input(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:caffe2.OperatorDef.control_input)
  control_input_.Mutable(index)->assign(value);
}
inline void OperatorDef::set_control_input(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:caffe2.OperatorDef.control_input)
  control_input_.Mutable(index)->assign(std::move(value));
}
inline void OperatorDef::set_control_input(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  control_input_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.control_input)
}
inline void OperatorDef::set_control_input(int index, const char* value, size_t size) {
  control_input_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.control_input)
}
inline std::string* OperatorDef::_internal_add_control_input() {
  return control_input_.Add();
}
inline void OperatorDef::add_control_input(const std::string& value) {
  control_input_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:caffe2.OperatorDef.control_input)
}
inline void OperatorDef::add_control_input(std::string&& value) {
  control_input_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:caffe2.OperatorDef.control_input)
}
inline void OperatorDef::add_control_input(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  control_input_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:caffe2.OperatorDef.control_input)
}
inline void OperatorDef::add_control_input(const char* value, size_t size) {
  control_input_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:caffe2.OperatorDef.control_input)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
OperatorDef::control_input() const {
  // @@protoc_insertion_point(field_list:caffe2.OperatorDef.control_input)
  return control_input_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
OperatorDef::mutable_control_input() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.control_input)
  return &control_input_;
}

// optional bool is_gradient_op = 9 [default = false];
inline bool OperatorDef::_internal_has_is_gradient_op() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool OperatorDef::has_is_gradient_op() const {
  return _internal_has_is_gradient_op();
}
inline void OperatorDef::clear_is_gradient_op() {
  is_gradient_op_ = false;
  _has_bits_[0] &= ~0x00000080u;
}
inline bool OperatorDef::_internal_is_gradient_op() const {
  return is_gradient_op_;
}
inline bool OperatorDef::is_gradient_op() const {
  // @@protoc_insertion_point(field_get:caffe2.OperatorDef.is_gradient_op)
  return _internal_is_gradient_op();
}
inline void OperatorDef::_internal_set_is_gradient_op(bool value) {
  _has_bits_[0] |= 0x00000080u;
  is_gradient_op_ = value;
}
inline void OperatorDef::set_is_gradient_op(bool value) {
  _internal_set_is_gradient_op(value);
  // @@protoc_insertion_point(field_set:caffe2.OperatorDef.is_gradient_op)
}

// optional string debug_info = 10;
inline bool OperatorDef::_internal_has_debug_info() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool OperatorDef::has_debug_info() const {
  return _internal_has_debug_info();
}
inline void OperatorDef::clear_debug_info() {
  debug_info_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& OperatorDef::debug_info() const {
  // @@protoc_insertion_point(field_get:caffe2.OperatorDef.debug_info)
  return _internal_debug_info();
}
inline void OperatorDef::set_debug_info(const std::string& value) {
  _internal_set_debug_info(value);
  // @@protoc_insertion_point(field_set:caffe2.OperatorDef.debug_info)
}
inline std::string* OperatorDef::mutable_debug_info() {
  // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.debug_info)
  return _internal_mutable_debug_info();
}
inline const std::string& OperatorDef::_internal_debug_info() const {
  return debug_info_.Get();
}
inline void OperatorDef::_internal_set_debug_info(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  debug_info_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void OperatorDef::set_debug_info(std::string&& value) {
  _has_bits_[0] |= 0x00000008u;
  debug_info_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.debug_info)
}
inline void OperatorDef::set_debug_info(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000008u;
  debug_info_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.debug_info)
}
inline void OperatorDef::set_debug_info(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000008u;
  debug_info_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.debug_info)
}
inline std::string* OperatorDef::_internal_mutable_debug_info() {
  _has_bits_[0] |= 0x00000008u;
  return debug_info_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* OperatorDef::release_debug_info() {
  // @@protoc_insertion_point(field_release:caffe2.OperatorDef.debug_info)
  if (!_internal_has_debug_info()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return debug_info_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void OperatorDef::set_allocated_debug_info(std::string* debug_info) {
  if (debug_info != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  debug_info_.SetAllocated(&GetEmptyStringAlreadyInited(), debug_info,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.debug_info)
}

// optional string domain = 11;
inline bool OperatorDef::_internal_has_domain() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool OperatorDef::has_domain() const {
  return _internal_has_domain();
}
inline void OperatorDef::clear_domain() {
  domain_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000010u;
}
inline const std::string& OperatorDef::domain() const {
  // @@protoc_insertion_point(field_get:caffe2.OperatorDef.domain)
  return _internal_domain();
}
inline void OperatorDef::set_domain(const std::string& value) {
  _internal_set_domain(value);
  // @@protoc_insertion_point(field_set:caffe2.OperatorDef.domain)
}
inline std::string* OperatorDef::mutable_domain() {
  // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.domain)
  return _internal_mutable_domain();
}
inline const std::string& OperatorDef::_internal_domain() const {
  return domain_.Get();
}
inline void OperatorDef::_internal_set_domain(const std::string& value) {
  _has_bits_[0] |= 0x00000010u;
  domain_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void OperatorDef::set_domain(std::string&& value) {
  _has_bits_[0] |= 0x00000010u;
  domain_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.domain)
}
inline void OperatorDef::set_domain(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000010u;
  domain_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.domain)
}
inline void OperatorDef::set_domain(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000010u;
  domain_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.domain)
}
inline std::string* OperatorDef::_internal_mutable_domain() {
  _has_bits_[0] |= 0x00000010u;
  return domain_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* OperatorDef::release_domain() {
  // @@protoc_insertion_point(field_release:caffe2.OperatorDef.domain)
  if (!_internal_has_domain()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000010u;
  return domain_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void OperatorDef::set_allocated_domain(std::string* domain) {
  if (domain != nullptr) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  domain_.SetAllocated(&GetEmptyStringAlreadyInited(), domain,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.domain)
}

// optional int64 op_version = 12;
inline bool OperatorDef::_internal_has_op_version() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool OperatorDef::has_op_version() const {
  return _internal_has_op_version();
}
inline void OperatorDef::clear_op_version() {
  op_version_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000040u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 OperatorDef::_internal_op_version() const {
  return op_version_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 OperatorDef::op_version() const {
  // @@protoc_insertion_point(field_get:caffe2.OperatorDef.op_version)
  return _internal_op_version();
}
inline void OperatorDef::_internal_set_op_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000040u;
  op_version_ = value;
}
inline void OperatorDef::set_op_version(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_op_version(value);
  // @@protoc_insertion_point(field_set:caffe2.OperatorDef.op_version)
}

// -------------------------------------------------------------------

// MapFieldEntry

// required string key = 1;
inline bool MapFieldEntry::_internal_has_key() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MapFieldEntry::has_key() const {
  return _internal_has_key();
}
inline void MapFieldEntry::clear_key() {
  key_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MapFieldEntry::key() const {
  // @@protoc_insertion_point(field_get:caffe2.MapFieldEntry.key)
  return _internal_key();
}
inline void MapFieldEntry::set_key(const std::string& value) {
  _internal_set_key(value);
  // @@protoc_insertion_point(field_set:caffe2.MapFieldEntry.key)
}
inline std::string* MapFieldEntry::mutable_key() {
  // @@protoc_insertion_point(field_mutable:caffe2.MapFieldEntry.key)
  return _internal_mutable_key();
}
inline const std::string& MapFieldEntry::_internal_key() const {
  return key_.Get();
}
inline void MapFieldEntry::_internal_set_key(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  key_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void MapFieldEntry::set_key(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  key_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.MapFieldEntry.key)
}
inline void MapFieldEntry::set_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  key_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.MapFieldEntry.key)
}
inline void MapFieldEntry::set_key(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  key_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.MapFieldEntry.key)
}
inline std::string* MapFieldEntry::_internal_mutable_key() {
  _has_bits_[0] |= 0x00000001u;
  return key_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* MapFieldEntry::release_key() {
  // @@protoc_insertion_point(field_release:caffe2.MapFieldEntry.key)
  if (!_internal_has_key()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return key_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void MapFieldEntry::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  key_.SetAllocated(&GetEmptyStringAlreadyInited(), key,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.MapFieldEntry.key)
}

// required string val = 2;
inline bool MapFieldEntry::_internal_has_val() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MapFieldEntry::has_val() const {
  return _internal_has_val();
}
inline void MapFieldEntry::clear_val() {
  val_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& MapFieldEntry::val() const {
  // @@protoc_insertion_point(field_get:caffe2.MapFieldEntry.val)
  return _internal_val();
}
inline void MapFieldEntry::set_val(const std::string& value) {
  _internal_set_val(value);
  // @@protoc_insertion_point(field_set:caffe2.MapFieldEntry.val)
}
inline std::string* MapFieldEntry::mutable_val() {
  // @@protoc_insertion_point(field_mutable:caffe2.MapFieldEntry.val)
  return _internal_mutable_val();
}
inline const std::string& MapFieldEntry::_internal_val() const {
  return val_.Get();
}
inline void MapFieldEntry::_internal_set_val(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  val_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void MapFieldEntry::set_val(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  val_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.MapFieldEntry.val)
}
inline void MapFieldEntry::set_val(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  val_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.MapFieldEntry.val)
}
inline void MapFieldEntry::set_val(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  val_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.MapFieldEntry.val)
}
inline std::string* MapFieldEntry::_internal_mutable_val() {
  _has_bits_[0] |= 0x00000002u;
  return val_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* MapFieldEntry::release_val() {
  // @@protoc_insertion_point(field_release:caffe2.MapFieldEntry.val)
  if (!_internal_has_val()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return val_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void MapFieldEntry::set_allocated_val(std::string* val) {
  if (val != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  val_.SetAllocated(&GetEmptyStringAlreadyInited(), val,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.MapFieldEntry.val)
}

// -------------------------------------------------------------------

// BackendOptions

// required string backend_name = 1;
inline bool BackendOptions::_internal_has_backend_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool BackendOptions::has_backend_name() const {
  return _internal_has_backend_name();
}
inline void BackendOptions::clear_backend_name() {
  backend_name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& BackendOptions::backend_name() const {
  // @@protoc_insertion_point(field_get:caffe2.BackendOptions.backend_name)
  return _internal_backend_name();
}
inline void BackendOptions::set_backend_name(const std::string& value) {
  _internal_set_backend_name(value);
  // @@protoc_insertion_point(field_set:caffe2.BackendOptions.backend_name)
}
inline std::string* BackendOptions::mutable_backend_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.BackendOptions.backend_name)
  return _internal_mutable_backend_name();
}
inline const std::string& BackendOptions::_internal_backend_name() const {
  return backend_name_.Get();
}
inline void BackendOptions::_internal_set_backend_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  backend_name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void BackendOptions::set_backend_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  backend_name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.BackendOptions.backend_name)
}
inline void BackendOptions::set_backend_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  backend_name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.BackendOptions.backend_name)
}
inline void BackendOptions::set_backend_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  backend_name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.BackendOptions.backend_name)
}
inline std::string* BackendOptions::_internal_mutable_backend_name() {
  _has_bits_[0] |= 0x00000001u;
  return backend_name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* BackendOptions::release_backend_name() {
  // @@protoc_insertion_point(field_release:caffe2.BackendOptions.backend_name)
  if (!_internal_has_backend_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return backend_name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void BackendOptions::set_allocated_backend_name(std::string* backend_name) {
  if (backend_name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  backend_name_.SetAllocated(&GetEmptyStringAlreadyInited(), backend_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.BackendOptions.backend_name)
}

// repeated .caffe2.MapFieldEntry option = 2;
inline int BackendOptions::_internal_option_size() const {
  return option_.size();
}
inline int BackendOptions::option_size() const {
  return _internal_option_size();
}
inline void BackendOptions::clear_option() {
  option_.Clear();
}
inline ::caffe2::MapFieldEntry* BackendOptions::mutable_option(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.BackendOptions.option)
  return option_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry >*
BackendOptions::mutable_option() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.BackendOptions.option)
  return &option_;
}
inline const ::caffe2::MapFieldEntry& BackendOptions::_internal_option(int index) const {
  return option_.Get(index);
}
inline const ::caffe2::MapFieldEntry& BackendOptions::option(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.BackendOptions.option)
  return _internal_option(index);
}
inline ::caffe2::MapFieldEntry* BackendOptions::_internal_add_option() {
  return option_.Add();
}
inline ::caffe2::MapFieldEntry* BackendOptions::add_option() {
  // @@protoc_insertion_point(field_add:caffe2.BackendOptions.option)
  return _internal_add_option();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry >&
BackendOptions::option() const {
  // @@protoc_insertion_point(field_list:caffe2.BackendOptions.option)
  return option_;
}

// -------------------------------------------------------------------

// PartitionInfo

// required string name = 1;
inline bool PartitionInfo::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PartitionInfo::has_name() const {
  return _internal_has_name();
}
inline void PartitionInfo::clear_name() {
  name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PartitionInfo::name() const {
  // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.name)
  return _internal_name();
}
inline void PartitionInfo::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:caffe2.PartitionInfo.name)
}
inline std::string* PartitionInfo::mutable_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.PartitionInfo.name)
  return _internal_mutable_name();
}
inline const std::string& PartitionInfo::_internal_name() const {
  return name_.Get();
}
inline void PartitionInfo::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void PartitionInfo::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.PartitionInfo.name)
}
inline void PartitionInfo::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.PartitionInfo.name)
}
inline void PartitionInfo::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.PartitionInfo.name)
}
inline std::string* PartitionInfo::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* PartitionInfo::release_name() {
  // @@protoc_insertion_point(field_release:caffe2.PartitionInfo.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void PartitionInfo::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.PartitionInfo.name)
}

// repeated int32 device_id = 2;
inline int PartitionInfo::_internal_device_id_size() const {
  return device_id_.size();
}
inline int PartitionInfo::device_id_size() const {
  return _internal_device_id_size();
}
inline void PartitionInfo::clear_device_id() {
  device_id_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionInfo::_internal_device_id(int index) const {
  return device_id_.Get(index);
}
inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionInfo::device_id(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.device_id)
  return _internal_device_id(index);
}
inline void PartitionInfo::set_device_id(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
  device_id_.Set(index, value);
  // @@protoc_insertion_point(field_set:caffe2.PartitionInfo.device_id)
}
inline void PartitionInfo::_internal_add_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  device_id_.Add(value);
}
inline void PartitionInfo::add_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_add_device_id(value);
  // @@protoc_insertion_point(field_add:caffe2.PartitionInfo.device_id)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
PartitionInfo::_internal_device_id() const {
  return device_id_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
PartitionInfo::device_id() const {
  // @@protoc_insertion_point(field_list:caffe2.PartitionInfo.device_id)
  return _internal_device_id();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
PartitionInfo::_internal_mutable_device_id() {
  return &device_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
PartitionInfo::mutable_device_id() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.PartitionInfo.device_id)
  return _internal_mutable_device_id();
}

// optional string extra_info = 3;
inline bool PartitionInfo::_internal_has_extra_info() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PartitionInfo::has_extra_info() const {
  return _internal_has_extra_info();
}
inline void PartitionInfo::clear_extra_info() {
  extra_info_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& PartitionInfo::extra_info() const {
  // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.extra_info)
  return _internal_extra_info();
}
inline void PartitionInfo::set_extra_info(const std::string& value) {
  _internal_set_extra_info(value);
  // @@protoc_insertion_point(field_set:caffe2.PartitionInfo.extra_info)
}
inline std::string* PartitionInfo::mutable_extra_info() {
  // @@protoc_insertion_point(field_mutable:caffe2.PartitionInfo.extra_info)
  return _internal_mutable_extra_info();
}
inline const std::string& PartitionInfo::_internal_extra_info() const {
  return extra_info_.Get();
}
inline void PartitionInfo::_internal_set_extra_info(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  extra_info_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void PartitionInfo::set_extra_info(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  extra_info_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.PartitionInfo.extra_info)
}
inline void PartitionInfo::set_extra_info(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  extra_info_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.PartitionInfo.extra_info)
}
inline void PartitionInfo::set_extra_info(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  extra_info_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.PartitionInfo.extra_info)
}
inline std::string* PartitionInfo::_internal_mutable_extra_info() {
  _has_bits_[0] |= 0x00000002u;
  return extra_info_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* PartitionInfo::release_extra_info() {
  // @@protoc_insertion_point(field_release:caffe2.PartitionInfo.extra_info)
  if (!_internal_has_extra_info()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return extra_info_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void PartitionInfo::set_allocated_extra_info(std::string* extra_info) {
  if (extra_info != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  extra_info_.SetAllocated(&GetEmptyStringAlreadyInited(), extra_info,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.PartitionInfo.extra_info)
}

// repeated .caffe2.BackendOptions backend_options = 4;
inline int PartitionInfo::_internal_backend_options_size() const {
  return backend_options_.size();
}
inline int PartitionInfo::backend_options_size() const {
  return _internal_backend_options_size();
}
inline void PartitionInfo::clear_backend_options() {
  backend_options_.Clear();
}
inline ::caffe2::BackendOptions* PartitionInfo::mutable_backend_options(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.PartitionInfo.backend_options)
  return backend_options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions >*
PartitionInfo::mutable_backend_options() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.PartitionInfo.backend_options)
  return &backend_options_;
}
inline const ::caffe2::BackendOptions& PartitionInfo::_internal_backend_options(int index) const {
  return backend_options_.Get(index);
}
inline const ::caffe2::BackendOptions& PartitionInfo::backend_options(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.backend_options)
  return _internal_backend_options(index);
}
inline ::caffe2::BackendOptions* PartitionInfo::_internal_add_backend_options() {
  return backend_options_.Add();
}
inline ::caffe2::BackendOptions* PartitionInfo::add_backend_options() {
  // @@protoc_insertion_point(field_add:caffe2.PartitionInfo.backend_options)
  return _internal_add_backend_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions >&
PartitionInfo::backend_options() const {
  // @@protoc_insertion_point(field_list:caffe2.PartitionInfo.backend_options)
  return backend_options_;
}

// -------------------------------------------------------------------

// NetDef

// optional string name = 1;
inline bool NetDef::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool NetDef::has_name() const {
  return _internal_has_name();
}
inline void NetDef::clear_name() {
  name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& NetDef::name() const {
  // @@protoc_insertion_point(field_get:caffe2.NetDef.name)
  return _internal_name();
}
inline void NetDef::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:caffe2.NetDef.name)
}
inline std::string* NetDef::mutable_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.NetDef.name)
  return _internal_mutable_name();
}
inline const std::string& NetDef::_internal_name() const {
  return name_.Get();
}
inline void NetDef::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void NetDef::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.NetDef.name)
}
inline void NetDef::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.NetDef.name)
}
inline void NetDef::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.name)
}
inline std::string* NetDef::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* NetDef::release_name() {
  // @@protoc_insertion_point(field_release:caffe2.NetDef.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void NetDef::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.NetDef.name)
}

// repeated .caffe2.OperatorDef op = 2;
inline int NetDef::_internal_op_size() const {
  return op_.size();
}
inline int NetDef::op_size() const {
  return _internal_op_size();
}
inline void NetDef::clear_op() {
  op_.Clear();
}
inline ::caffe2::OperatorDef* NetDef::mutable_op(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.NetDef.op)
  return op_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef >*
NetDef::mutable_op() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.op)
  return &op_;
}
inline const ::caffe2::OperatorDef& NetDef::_internal_op(int index) const {
  return op_.Get(index);
}
inline const ::caffe2::OperatorDef& NetDef::op(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.NetDef.op)
  return _internal_op(index);
}
inline ::caffe2::OperatorDef* NetDef::_internal_add_op() {
  return op_.Add();
}
inline ::caffe2::OperatorDef* NetDef::add_op() {
  // @@protoc_insertion_point(field_add:caffe2.NetDef.op)
  return _internal_add_op();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef >&
NetDef::op() const {
  // @@protoc_insertion_point(field_list:caffe2.NetDef.op)
  return op_;
}

// optional string type = 3;
inline bool NetDef::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NetDef::has_type() const {
  return _internal_has_type();
}
inline void NetDef::clear_type() {
  type_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& NetDef::type() const {
  // @@protoc_insertion_point(field_get:caffe2.NetDef.type)
  return _internal_type();
}
inline void NetDef::set_type(const std::string& value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:caffe2.NetDef.type)
}
inline std::string* NetDef::mutable_type() {
  // @@protoc_insertion_point(field_mutable:caffe2.NetDef.type)
  return _internal_mutable_type();
}
inline const std::string& NetDef::_internal_type() const {
  return type_.Get();
}
inline void NetDef::_internal_set_type(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  type_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void NetDef::set_type(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  type_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.NetDef.type)
}
inline void NetDef::set_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.NetDef.type)
}
inline void NetDef::set_type(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.type)
}
inline std::string* NetDef::_internal_mutable_type() {
  _has_bits_[0] |= 0x00000002u;
  return type_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* NetDef::release_type() {
  // @@protoc_insertion_point(field_release:caffe2.NetDef.type)
  if (!_internal_has_type()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return type_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void NetDef::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  type_.SetAllocated(&GetEmptyStringAlreadyInited(), type,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.NetDef.type)
}

// optional int32 num_workers = 4;
inline bool NetDef::_internal_has_num_workers() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool NetDef::has_num_workers() const {
  return _internal_has_num_workers();
}
inline void NetDef::clear_num_workers() {
  num_workers_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 NetDef::_internal_num_workers() const {
  return num_workers_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 NetDef::num_workers() const {
  // @@protoc_insertion_point(field_get:caffe2.NetDef.num_workers)
  return _internal_num_workers();
}
inline void NetDef::_internal_set_num_workers(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000008u;
  num_workers_ = value;
}
inline void NetDef::set_num_workers(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_num_workers(value);
  // @@protoc_insertion_point(field_set:caffe2.NetDef.num_workers)
}

// optional .caffe2.DeviceOption device_option = 5;
inline bool NetDef::_internal_has_device_option() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || device_option_ != nullptr);
  return value;
}
inline bool NetDef::has_device_option() const {
  return _internal_has_device_option();
}
inline void NetDef::clear_device_option() {
  if (device_option_ != nullptr) device_option_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::caffe2::DeviceOption& NetDef::_internal_device_option() const {
  const ::caffe2::DeviceOption* p = device_option_;
  return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::DeviceOption*>(
      &::caffe2::_DeviceOption_default_instance_);
}
inline const ::caffe2::DeviceOption& NetDef::device_option() const {
  // @@protoc_insertion_point(field_get:caffe2.NetDef.device_option)
  return _internal_device_option();
}
inline void NetDef::unsafe_arena_set_allocated_device_option(
    ::caffe2::DeviceOption* device_option) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_option_);
  }
  device_option_ = device_option;
  if (device_option) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.NetDef.device_option)
}
inline ::caffe2::DeviceOption* NetDef::release_device_option() {
  _has_bits_[0] &= ~0x00000004u;
  ::caffe2::DeviceOption* temp = device_option_;
  device_option_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::caffe2::DeviceOption* NetDef::unsafe_arena_release_device_option() {
  // @@protoc_insertion_point(field_release:caffe2.NetDef.device_option)
  _has_bits_[0] &= ~0x00000004u;
  ::caffe2::DeviceOption* temp = device_option_;
  device_option_ = nullptr;
  return temp;
}
inline ::caffe2::DeviceOption* NetDef::_internal_mutable_device_option() {
  _has_bits_[0] |= 0x00000004u;
  if (device_option_ == nullptr) {
    auto* p = CreateMaybeMessage<::caffe2::DeviceOption>(GetArena());
    device_option_ = p;
  }
  return device_option_;
}
inline ::caffe2::DeviceOption* NetDef::mutable_device_option() {
  // @@protoc_insertion_point(field_mutable:caffe2.NetDef.device_option)
  return _internal_mutable_device_option();
}
inline void NetDef::set_allocated_device_option(::caffe2::DeviceOption* device_option) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete device_option_;
  }
  if (device_option) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(device_option);
    if (message_arena != submessage_arena) {
      device_option = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, device_option, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  device_option_ = device_option;
  // @@protoc_insertion_point(field_set_allocated:caffe2.NetDef.device_option)
}

// repeated .caffe2.Argument arg = 6;
inline int NetDef::_internal_arg_size() const {
  return arg_.size();
}
inline int NetDef::arg_size() const {
  return _internal_arg_size();
}
inline void NetDef::clear_arg() {
  arg_.Clear();
}
inline ::caffe2::Argument* NetDef::mutable_arg(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.NetDef.arg)
  return arg_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >*
NetDef::mutable_arg() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.arg)
  return &arg_;
}
inline const ::caffe2::Argument& NetDef::_internal_arg(int index) const {
  return arg_.Get(index);
}
inline const ::caffe2::Argument& NetDef::arg(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.NetDef.arg)
  return _internal_arg(index);
}
inline ::caffe2::Argument* NetDef::_internal_add_arg() {
  return arg_.Add();
}
inline ::caffe2::Argument* NetDef::add_arg() {
  // @@protoc_insertion_point(field_add:caffe2.NetDef.arg)
  return _internal_add_arg();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >&
NetDef::arg() const {
  // @@protoc_insertion_point(field_list:caffe2.NetDef.arg)
  return arg_;
}

// repeated string external_input = 7;
inline int NetDef::_internal_external_input_size() const {
  return external_input_.size();
}
inline int NetDef::external_input_size() const {
  return _internal_external_input_size();
}
inline void NetDef::clear_external_input() {
  external_input_.Clear();
}
inline std::string* NetDef::add_external_input() {
  // @@protoc_insertion_point(field_add_mutable:caffe2.NetDef.external_input)
  return _internal_add_external_input();
}
inline const std::string& NetDef::_internal_external_input(int index) const {
  return external_input_.Get(index);
}
inline const std::string& NetDef::external_input(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.NetDef.external_input)
  return _internal_external_input(index);
}
inline std::string* NetDef::mutable_external_input(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.NetDef.external_input)
  return external_input_.Mutable(index);
}
inline void NetDef::set_external_input(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:caffe2.NetDef.external_input)
  external_input_.Mutable(index)->assign(value);
}
inline void NetDef::set_external_input(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:caffe2.NetDef.external_input)
  external_input_.Mutable(index)->assign(std::move(value));
}
inline void NetDef::set_external_input(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  external_input_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:caffe2.NetDef.external_input)
}
inline void NetDef::set_external_input(int index, const char* value, size_t size) {
  external_input_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.external_input)
}
inline std::string* NetDef::_internal_add_external_input() {
  return external_input_.Add();
}
inline void NetDef::add_external_input(const std::string& value) {
  external_input_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:caffe2.NetDef.external_input)
}
inline void NetDef::add_external_input(std::string&& value) {
  external_input_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:caffe2.NetDef.external_input)
}
inline void NetDef::add_external_input(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  external_input_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:caffe2.NetDef.external_input)
}
inline void NetDef::add_external_input(const char* value, size_t size) {
  external_input_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:caffe2.NetDef.external_input)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NetDef::external_input() const {
  // @@protoc_insertion_point(field_list:caffe2.NetDef.external_input)
  return external_input_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NetDef::mutable_external_input() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.external_input)
  return &external_input_;
}

// repeated string external_output = 8;
inline int NetDef::_internal_external_output_size() const {
  return external_output_.size();
}
inline int NetDef::external_output_size() const {
  return _internal_external_output_size();
}
inline void NetDef::clear_external_output() {
  external_output_.Clear();
}
inline std::string* NetDef::add_external_output() {
  // @@protoc_insertion_point(field_add_mutable:caffe2.NetDef.external_output)
  return _internal_add_external_output();
}
inline const std::string& NetDef::_internal_external_output(int index) const {
  return external_output_.Get(index);
}
inline const std::string& NetDef::external_output(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.NetDef.external_output)
  return _internal_external_output(index);
}
inline std::string* NetDef::mutable_external_output(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.NetDef.external_output)
  return external_output_.Mutable(index);
}
inline void NetDef::set_external_output(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:caffe2.NetDef.external_output)
  external_output_.Mutable(index)->assign(value);
}
inline void NetDef::set_external_output(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:caffe2.NetDef.external_output)
  external_output_.Mutable(index)->assign(std::move(value));
}
inline void NetDef::set_external_output(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  external_output_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:caffe2.NetDef.external_output)
}
inline void NetDef::set_external_output(int index, const char* value, size_t size) {
  external_output_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.external_output)
}
inline std::string* NetDef::_internal_add_external_output() {
  return external_output_.Add();
}
inline void NetDef::add_external_output(const std::string& value) {
  external_output_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:caffe2.NetDef.external_output)
}
inline void NetDef::add_external_output(std::string&& value) {
  external_output_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:caffe2.NetDef.external_output)
}
inline void NetDef::add_external_output(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  external_output_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:caffe2.NetDef.external_output)
}
inline void NetDef::add_external_output(const char* value, size_t size) {
  external_output_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:caffe2.NetDef.external_output)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
NetDef::external_output() const {
  // @@protoc_insertion_point(field_list:caffe2.NetDef.external_output)
  return external_output_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
NetDef::mutable_external_output() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.external_output)
  return &external_output_;
}

// repeated .caffe2.PartitionInfo partition_info = 9;
inline int NetDef::_internal_partition_info_size() const {
  return partition_info_.size();
}
inline int NetDef::partition_info_size() const {
  return _internal_partition_info_size();
}
inline void NetDef::clear_partition_info() {
  partition_info_.Clear();
}
inline ::caffe2::PartitionInfo* NetDef::mutable_partition_info(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.NetDef.partition_info)
  return partition_info_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo >*
NetDef::mutable_partition_info() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.partition_info)
  return &partition_info_;
}
inline const ::caffe2::PartitionInfo& NetDef::_internal_partition_info(int index) const {
  return partition_info_.Get(index);
}
inline const ::caffe2::PartitionInfo& NetDef::partition_info(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.NetDef.partition_info)
  return _internal_partition_info(index);
}
inline ::caffe2::PartitionInfo* NetDef::_internal_add_partition_info() {
  return partition_info_.Add();
}
inline ::caffe2::PartitionInfo* NetDef::add_partition_info() {
  // @@protoc_insertion_point(field_add:caffe2.NetDef.partition_info)
  return _internal_add_partition_info();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo >&
NetDef::partition_info() const {
  // @@protoc_insertion_point(field_list:caffe2.NetDef.partition_info)
  return partition_info_;
}

// -------------------------------------------------------------------

// ExecutionStep

// optional string name = 1;
inline bool ExecutionStep::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ExecutionStep::has_name() const {
  return _internal_has_name();
}
inline void ExecutionStep::clear_name() {
  name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ExecutionStep::name() const {
  // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.name)
  return _internal_name();
}
inline void ExecutionStep::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.name)
}
inline std::string* ExecutionStep::mutable_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.name)
  return _internal_mutable_name();
}
inline const std::string& ExecutionStep::_internal_name() const {
  return name_.Get();
}
inline void ExecutionStep::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void ExecutionStep::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.ExecutionStep.name)
}
inline void ExecutionStep::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.name)
}
inline void ExecutionStep::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.name)
}
inline std::string* ExecutionStep::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* ExecutionStep::release_name() {
  // @@protoc_insertion_point(field_release:caffe2.ExecutionStep.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void ExecutionStep::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.name)
}

// repeated .caffe2.ExecutionStep substep = 2;
inline int ExecutionStep::_internal_substep_size() const {
  return substep_.size();
}
inline int ExecutionStep::substep_size() const {
  return _internal_substep_size();
}
inline void ExecutionStep::clear_substep() {
  substep_.Clear();
}
inline ::caffe2::ExecutionStep* ExecutionStep::mutable_substep(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.substep)
  return substep_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >*
ExecutionStep::mutable_substep() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.ExecutionStep.substep)
  return &substep_;
}
inline const ::caffe2::ExecutionStep& ExecutionStep::_internal_substep(int index) const {
  return substep_.Get(index);
}
inline const ::caffe2::ExecutionStep& ExecutionStep::substep(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.substep)
  return _internal_substep(index);
}
inline ::caffe2::ExecutionStep* ExecutionStep::_internal_add_substep() {
  return substep_.Add();
}
inline ::caffe2::ExecutionStep* ExecutionStep::add_substep() {
  // @@protoc_insertion_point(field_add:caffe2.ExecutionStep.substep)
  return _internal_add_substep();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >&
ExecutionStep::substep() const {
  // @@protoc_insertion_point(field_list:caffe2.ExecutionStep.substep)
  return substep_;
}

// repeated string network = 3;
inline int ExecutionStep::_internal_network_size() const {
  return network_.size();
}
inline int ExecutionStep::network_size() const {
  return _internal_network_size();
}
inline void ExecutionStep::clear_network() {
  network_.Clear();
}
inline std::string* ExecutionStep::add_network() {
  // @@protoc_insertion_point(field_add_mutable:caffe2.ExecutionStep.network)
  return _internal_add_network();
}
inline const std::string& ExecutionStep::_internal_network(int index) const {
  return network_.Get(index);
}
inline const std::string& ExecutionStep::network(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.network)
  return _internal_network(index);
}
inline std::string* ExecutionStep::mutable_network(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.network)
  return network_.Mutable(index);
}
inline void ExecutionStep::set_network(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.network)
  network_.Mutable(index)->assign(value);
}
inline void ExecutionStep::set_network(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.network)
  network_.Mutable(index)->assign(std::move(value));
}
inline void ExecutionStep::set_network(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  network_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.network)
}
inline void ExecutionStep::set_network(int index, const char* value, size_t size) {
  network_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.network)
}
inline std::string* ExecutionStep::_internal_add_network() {
  return network_.Add();
}
inline void ExecutionStep::add_network(const std::string& value) {
  network_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:caffe2.ExecutionStep.network)
}
inline void ExecutionStep::add_network(std::string&& value) {
  network_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:caffe2.ExecutionStep.network)
}
inline void ExecutionStep::add_network(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  network_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:caffe2.ExecutionStep.network)
}
inline void ExecutionStep::add_network(const char* value, size_t size) {
  network_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:caffe2.ExecutionStep.network)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ExecutionStep::network() const {
  // @@protoc_insertion_point(field_list:caffe2.ExecutionStep.network)
  return network_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ExecutionStep::mutable_network() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.ExecutionStep.network)
  return &network_;
}

// optional int64 num_iter = 4;
inline bool ExecutionStep::_internal_has_num_iter() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ExecutionStep::has_num_iter() const {
  return _internal_has_num_iter();
}
inline void ExecutionStep::clear_num_iter() {
  num_iter_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ExecutionStep::_internal_num_iter() const {
  return num_iter_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ExecutionStep::num_iter() const {
  // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.num_iter)
  return _internal_num_iter();
}
inline void ExecutionStep::_internal_set_num_iter(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000010u;
  num_iter_ = value;
}
inline void ExecutionStep::set_num_iter(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_num_iter(value);
  // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.num_iter)
}

// optional string criteria_network = 5 [deprecated = true];
inline bool ExecutionStep::_internal_has_criteria_network() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ExecutionStep::has_criteria_network() const {
  return _internal_has_criteria_network();
}
inline void ExecutionStep::clear_criteria_network() {
  criteria_network_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ExecutionStep::criteria_network() const {
  // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.criteria_network)
  return _internal_criteria_network();
}
inline void ExecutionStep::set_criteria_network(const std::string& value) {
  _internal_set_criteria_network(value);
  // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.criteria_network)
}
inline std::string* ExecutionStep::mutable_criteria_network() {
  // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.criteria_network)
  return _internal_mutable_criteria_network();
}
inline const std::string& ExecutionStep::_internal_criteria_network() const {
  return criteria_network_.Get();
}
inline void ExecutionStep::_internal_set_criteria_network(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  criteria_network_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void ExecutionStep::set_criteria_network(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  criteria_network_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.ExecutionStep.criteria_network)
}
inline void ExecutionStep::set_criteria_network(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  criteria_network_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.criteria_network)
}
inline void ExecutionStep::set_criteria_network(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  criteria_network_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.criteria_network)
}
inline std::string* ExecutionStep::_internal_mutable_criteria_network() {
  _has_bits_[0] |= 0x00000002u;
  return criteria_network_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* ExecutionStep::release_criteria_network() {
  // @@protoc_insertion_point(field_release:caffe2.ExecutionStep.criteria_network)
  if (!_internal_has_criteria_network()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return criteria_network_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void ExecutionStep::set_allocated_criteria_network(std::string* criteria_network) {
  if (criteria_network != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  criteria_network_.SetAllocated(&GetEmptyStringAlreadyInited(), criteria_network,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.criteria_network)
}

// optional string report_net = 7;
inline bool ExecutionStep::_internal_has_report_net() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ExecutionStep::has_report_net() const {
  return _internal_has_report_net();
}
inline void ExecutionStep::clear_report_net() {
  report_net_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ExecutionStep::report_net() const {
  // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.report_net)
  return _internal_report_net();
}
inline void ExecutionStep::set_report_net(const std::string& value) {
  _internal_set_report_net(value);
  // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.report_net)
}
inline std::string* ExecutionStep::mutable_report_net() {
  // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.report_net)
  return _internal_mutable_report_net();
}
inline const std::string& ExecutionStep::_internal_report_net() const {
  return report_net_.Get();
}
inline void ExecutionStep::_internal_set_report_net(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  report_net_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void ExecutionStep::set_report_net(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  report_net_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.ExecutionStep.report_net)
}
inline void ExecutionStep::set_report_net(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  report_net_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.report_net)
}
inline void ExecutionStep::set_report_net(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000004u;
  report_net_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.report_net)
}
inline std::string* ExecutionStep::_internal_mutable_report_net() {
  _has_bits_[0] |= 0x00000004u;
  return report_net_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* ExecutionStep::release_report_net() {
  // @@protoc_insertion_point(field_release:caffe2.ExecutionStep.report_net)
  if (!_internal_has_report_net()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return report_net_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void ExecutionStep::set_allocated_report_net(std::string* report_net) {
  if (report_net != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  report_net_.SetAllocated(&GetEmptyStringAlreadyInited(), report_net,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.report_net)
}

// optional int32 report_interval = 8;
inline bool ExecutionStep::_internal_has_report_interval() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ExecutionStep::has_report_interval() const {
  return _internal_has_report_interval();
}
inline void ExecutionStep::clear_report_interval() {
  report_interval_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ExecutionStep::_internal_report_interval() const {
  return report_interval_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ExecutionStep::report_interval() const {
  // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.report_interval)
  return _internal_report_interval();
}
inline void ExecutionStep::_internal_set_report_interval(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000020u;
  report_interval_ = value;
}
inline void ExecutionStep::set_report_interval(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_report_interval(value);
  // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.report_interval)
}

// optional int64 run_every_ms = 11;
inline bool ExecutionStep::_internal_has_run_every_ms() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool ExecutionStep::has_run_every_ms() const {
  return _internal_has_run_every_ms();
}
inline void ExecutionStep::clear_run_every_ms() {
  run_every_ms_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000200u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ExecutionStep::_internal_run_every_ms() const {
  return run_every_ms_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ExecutionStep::run_every_ms() const {
  // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.run_every_ms)
  return _internal_run_every_ms();
}
inline void ExecutionStep::_internal_set_run_every_ms(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000200u;
  run_every_ms_ = value;
}
inline void ExecutionStep::set_run_every_ms(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_run_every_ms(value);
  // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.run_every_ms)
}

// optional bool concurrent_substeps = 6;
inline bool ExecutionStep::_internal_has_concurrent_substeps() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool ExecutionStep::has_concurrent_substeps() const {
  return _internal_has_concurrent_substeps();
}
inline void ExecutionStep::clear_concurrent_substeps() {
  concurrent_substeps_ = false;
  _has_bits_[0] &= ~0x00000040u;
}
inline bool ExecutionStep::_internal_concurrent_substeps() const {
  return concurrent_substeps_;
}
inline bool ExecutionStep::concurrent_substeps() const {
  // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.concurrent_substeps)
  return _internal_concurrent_substeps();
}
inline void ExecutionStep::_internal_set_concurrent_substeps(bool value) {
  _has_bits_[0] |= 0x00000040u;
  concurrent_substeps_ = value;
}
inline void ExecutionStep::set_concurrent_substeps(bool value) {
  _internal_set_concurrent_substeps(value);
  // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.concurrent_substeps)
}

// optional string should_stop_blob = 9;
inline bool ExecutionStep::_internal_has_should_stop_blob() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ExecutionStep::has_should_stop_blob() const {
  return _internal_has_should_stop_blob();
}
inline void ExecutionStep::clear_should_stop_blob() {
  should_stop_blob_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& ExecutionStep::should_stop_blob() const {
  // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.should_stop_blob)
  return _internal_should_stop_blob();
}
inline void ExecutionStep::set_should_stop_blob(const std::string& value) {
  _internal_set_should_stop_blob(value);
  // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.should_stop_blob)
}
inline std::string* ExecutionStep::mutable_should_stop_blob() {
  // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.should_stop_blob)
  return _internal_mutable_should_stop_blob();
}
inline const std::string& ExecutionStep::_internal_should_stop_blob() const {
  return should_stop_blob_.Get();
}
inline void ExecutionStep::_internal_set_should_stop_blob(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  should_stop_blob_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void ExecutionStep::set_should_stop_blob(std::string&& value) {
  _has_bits_[0] |= 0x00000008u;
  should_stop_blob_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.ExecutionStep.should_stop_blob)
}
inline void ExecutionStep::set_should_stop_blob(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000008u;
  should_stop_blob_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.should_stop_blob)
}
inline void ExecutionStep::set_should_stop_blob(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000008u;
  should_stop_blob_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.should_stop_blob)
}
inline std::string* ExecutionStep::_internal_mutable_should_stop_blob() {
  _has_bits_[0] |= 0x00000008u;
  return should_stop_blob_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* ExecutionStep::release_should_stop_blob() {
  // @@protoc_insertion_point(field_release:caffe2.ExecutionStep.should_stop_blob)
  if (!_internal_has_should_stop_blob()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return should_stop_blob_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void ExecutionStep::set_allocated_should_stop_blob(std::string* should_stop_blob) {
  if (should_stop_blob != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  should_stop_blob_.SetAllocated(&GetEmptyStringAlreadyInited(), should_stop_blob,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.should_stop_blob)
}

// optional bool only_once = 10;
inline bool ExecutionStep::_internal_has_only_once() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool ExecutionStep::has_only_once() const {
  return _internal_has_only_once();
}
inline void ExecutionStep::clear_only_once() {
  only_once_ = false;
  _has_bits_[0] &= ~0x00000080u;
}
inline bool ExecutionStep::_internal_only_once() const {
  return only_once_;
}
inline bool ExecutionStep::only_once() const {
  // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.only_once)
  return _internal_only_once();
}
inline void ExecutionStep::_internal_set_only_once(bool value) {
  _has_bits_[0] |= 0x00000080u;
  only_once_ = value;
}
inline void ExecutionStep::set_only_once(bool value) {
  _internal_set_only_once(value);
  // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.only_once)
}

// optional bool create_workspace = 12;
inline bool ExecutionStep::_internal_has_create_workspace() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool ExecutionStep::has_create_workspace() const {
  return _internal_has_create_workspace();
}
inline void ExecutionStep::clear_create_workspace() {
  create_workspace_ = false;
  _has_bits_[0] &= ~0x00000100u;
}
inline bool ExecutionStep::_internal_create_workspace() const {
  return create_workspace_;
}
inline bool ExecutionStep::create_workspace() const {
  // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.create_workspace)
  return _internal_create_workspace();
}
inline void ExecutionStep::_internal_set_create_workspace(bool value) {
  _has_bits_[0] |= 0x00000100u;
  create_workspace_ = value;
}
inline void ExecutionStep::set_create_workspace(bool value) {
  _internal_set_create_workspace(value);
  // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.create_workspace)
}

// optional int32 num_concurrent_instances = 13;
inline bool ExecutionStep::_internal_has_num_concurrent_instances() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool ExecutionStep::has_num_concurrent_instances() const {
  return _internal_has_num_concurrent_instances();
}
inline void ExecutionStep::clear_num_concurrent_instances() {
  num_concurrent_instances_ = 0;
  _has_bits_[0] &= ~0x00000400u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ExecutionStep::_internal_num_concurrent_instances() const {
  return num_concurrent_instances_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ExecutionStep::num_concurrent_instances() const {
  // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.num_concurrent_instances)
  return _internal_num_concurrent_instances();
}
inline void ExecutionStep::_internal_set_num_concurrent_instances(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000400u;
  num_concurrent_instances_ = value;
}
inline void ExecutionStep::set_num_concurrent_instances(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_num_concurrent_instances(value);
  // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.num_concurrent_instances)
}

// -------------------------------------------------------------------

// PlanDef

// optional string name = 1;
inline bool PlanDef::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PlanDef::has_name() const {
  return _internal_has_name();
}
inline void PlanDef::clear_name() {
  name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PlanDef::name() const {
  // @@protoc_insertion_point(field_get:caffe2.PlanDef.name)
  return _internal_name();
}
inline void PlanDef::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:caffe2.PlanDef.name)
}
inline std::string* PlanDef::mutable_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.PlanDef.name)
  return _internal_mutable_name();
}
inline const std::string& PlanDef::_internal_name() const {
  return name_.Get();
}
inline void PlanDef::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void PlanDef::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.PlanDef.name)
}
inline void PlanDef::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.PlanDef.name)
}
inline void PlanDef::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.PlanDef.name)
}
inline std::string* PlanDef::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* PlanDef::release_name() {
  // @@protoc_insertion_point(field_release:caffe2.PlanDef.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void PlanDef::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.PlanDef.name)
}

// repeated .caffe2.NetDef network = 2;
inline int PlanDef::_internal_network_size() const {
  return network_.size();
}
inline int PlanDef::network_size() const {
  return _internal_network_size();
}
inline void PlanDef::clear_network() {
  network_.Clear();
}
inline ::caffe2::NetDef* PlanDef::mutable_network(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.PlanDef.network)
  return network_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >*
PlanDef::mutable_network() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.PlanDef.network)
  return &network_;
}
inline const ::caffe2::NetDef& PlanDef::_internal_network(int index) const {
  return network_.Get(index);
}
inline const ::caffe2::NetDef& PlanDef::network(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.PlanDef.network)
  return _internal_network(index);
}
inline ::caffe2::NetDef* PlanDef::_internal_add_network() {
  return network_.Add();
}
inline ::caffe2::NetDef* PlanDef::add_network() {
  // @@protoc_insertion_point(field_add:caffe2.PlanDef.network)
  return _internal_add_network();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >&
PlanDef::network() const {
  // @@protoc_insertion_point(field_list:caffe2.PlanDef.network)
  return network_;
}

// repeated .caffe2.ExecutionStep execution_step = 3;
inline int PlanDef::_internal_execution_step_size() const {
  return execution_step_.size();
}
inline int PlanDef::execution_step_size() const {
  return _internal_execution_step_size();
}
inline void PlanDef::clear_execution_step() {
  execution_step_.Clear();
}
inline ::caffe2::ExecutionStep* PlanDef::mutable_execution_step(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.PlanDef.execution_step)
  return execution_step_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >*
PlanDef::mutable_execution_step() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.PlanDef.execution_step)
  return &execution_step_;
}
inline const ::caffe2::ExecutionStep& PlanDef::_internal_execution_step(int index) const {
  return execution_step_.Get(index);
}
inline const ::caffe2::ExecutionStep& PlanDef::execution_step(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.PlanDef.execution_step)
  return _internal_execution_step(index);
}
inline ::caffe2::ExecutionStep* PlanDef::_internal_add_execution_step() {
  return execution_step_.Add();
}
inline ::caffe2::ExecutionStep* PlanDef::add_execution_step() {
  // @@protoc_insertion_point(field_add:caffe2.PlanDef.execution_step)
  return _internal_add_execution_step();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >&
PlanDef::execution_step() const {
  // @@protoc_insertion_point(field_list:caffe2.PlanDef.execution_step)
  return execution_step_;
}

// -------------------------------------------------------------------

// BlobProto

// optional string name = 1;
inline bool BlobProto::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool BlobProto::has_name() const {
  return _internal_has_name();
}
inline void BlobProto::clear_name() {
  name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& BlobProto::name() const {
  // @@protoc_insertion_point(field_get:caffe2.BlobProto.name)
  return _internal_name();
}
inline void BlobProto::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:caffe2.BlobProto.name)
}
inline std::string* BlobProto::mutable_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.name)
  return _internal_mutable_name();
}
inline const std::string& BlobProto::_internal_name() const {
  return name_.Get();
}
inline void BlobProto::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void BlobProto::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.BlobProto.name)
}
inline void BlobProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.BlobProto.name)
}
inline void BlobProto::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.BlobProto.name)
}
inline std::string* BlobProto::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* BlobProto::release_name() {
  // @@protoc_insertion_point(field_release:caffe2.BlobProto.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void BlobProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.name)
}

// optional string type = 2;
inline bool BlobProto::_internal_has_type() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool BlobProto::has_type() const {
  return _internal_has_type();
}
inline void BlobProto::clear_type() {
  type_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& BlobProto::type() const {
  // @@protoc_insertion_point(field_get:caffe2.BlobProto.type)
  return _internal_type();
}
inline void BlobProto::set_type(const std::string& value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:caffe2.BlobProto.type)
}
inline std::string* BlobProto::mutable_type() {
  // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.type)
  return _internal_mutable_type();
}
inline const std::string& BlobProto::_internal_type() const {
  return type_.Get();
}
inline void BlobProto::_internal_set_type(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  type_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void BlobProto::set_type(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  type_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.BlobProto.type)
}
inline void BlobProto::set_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.BlobProto.type)
}
inline void BlobProto::set_type(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.BlobProto.type)
}
inline std::string* BlobProto::_internal_mutable_type() {
  _has_bits_[0] |= 0x00000002u;
  return type_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* BlobProto::release_type() {
  // @@protoc_insertion_point(field_release:caffe2.BlobProto.type)
  if (!_internal_has_type()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return type_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void BlobProto::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  type_.SetAllocated(&GetEmptyStringAlreadyInited(), type,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.type)
}

// optional .caffe2.TensorProto tensor = 3;
inline bool BlobProto::_internal_has_tensor() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || tensor_ != nullptr);
  return value;
}
inline bool BlobProto::has_tensor() const {
  return _internal_has_tensor();
}
inline void BlobProto::clear_tensor() {
  if (tensor_ != nullptr) tensor_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::caffe2::TensorProto& BlobProto::_internal_tensor() const {
  const ::caffe2::TensorProto* p = tensor_;
  return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::TensorProto*>(
      &::caffe2::_TensorProto_default_instance_);
}
inline const ::caffe2::TensorProto& BlobProto::tensor() const {
  // @@protoc_insertion_point(field_get:caffe2.BlobProto.tensor)
  return _internal_tensor();
}
inline void BlobProto::unsafe_arena_set_allocated_tensor(
    ::caffe2::TensorProto* tensor) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor_);
  }
  tensor_ = tensor;
  if (tensor) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.BlobProto.tensor)
}
inline ::caffe2::TensorProto* BlobProto::release_tensor() {
  _has_bits_[0] &= ~0x00000008u;
  ::caffe2::TensorProto* temp = tensor_;
  tensor_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::caffe2::TensorProto* BlobProto::unsafe_arena_release_tensor() {
  // @@protoc_insertion_point(field_release:caffe2.BlobProto.tensor)
  _has_bits_[0] &= ~0x00000008u;
  ::caffe2::TensorProto* temp = tensor_;
  tensor_ = nullptr;
  return temp;
}
inline ::caffe2::TensorProto* BlobProto::_internal_mutable_tensor() {
  _has_bits_[0] |= 0x00000008u;
  if (tensor_ == nullptr) {
    auto* p = CreateMaybeMessage<::caffe2::TensorProto>(GetArena());
    tensor_ = p;
  }
  return tensor_;
}
inline ::caffe2::TensorProto* BlobProto::mutable_tensor() {
  // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.tensor)
  return _internal_mutable_tensor();
}
inline void BlobProto::set_allocated_tensor(::caffe2::TensorProto* tensor) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete tensor_;
  }
  if (tensor) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tensor);
    if (message_arena != submessage_arena) {
      tensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tensor, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  tensor_ = tensor;
  // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.tensor)
}

// optional bytes content = 4;
inline bool BlobProto::_internal_has_content() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool BlobProto::has_content() const {
  return _internal_has_content();
}
inline void BlobProto::clear_content() {
  content_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& BlobProto::content() const {
  // @@protoc_insertion_point(field_get:caffe2.BlobProto.content)
  return _internal_content();
}
inline void BlobProto::set_content(const std::string& value) {
  _internal_set_content(value);
  // @@protoc_insertion_point(field_set:caffe2.BlobProto.content)
}
inline std::string* BlobProto::mutable_content() {
  // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.content)
  return _internal_mutable_content();
}
inline const std::string& BlobProto::_internal_content() const {
  return content_.Get();
}
inline void BlobProto::_internal_set_content(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  content_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void BlobProto::set_content(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  content_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.BlobProto.content)
}
inline void BlobProto::set_content(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  content_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.BlobProto.content)
}
inline void BlobProto::set_content(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000004u;
  content_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.BlobProto.content)
}
inline std::string* BlobProto::_internal_mutable_content() {
  _has_bits_[0] |= 0x00000004u;
  return content_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* BlobProto::release_content() {
  // @@protoc_insertion_point(field_release:caffe2.BlobProto.content)
  if (!_internal_has_content()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return content_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void BlobProto::set_allocated_content(std::string* content) {
  if (content != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  content_.SetAllocated(&GetEmptyStringAlreadyInited(), content,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.content)
}

// optional .caffe2.QTensorProto qtensor = 5;
inline bool BlobProto::_internal_has_qtensor() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || qtensor_ != nullptr);
  return value;
}
inline bool BlobProto::has_qtensor() const {
  return _internal_has_qtensor();
}
inline void BlobProto::clear_qtensor() {
  if (qtensor_ != nullptr) qtensor_->Clear();
  _has_bits_[0] &= ~0x00000010u;
}
inline const ::caffe2::QTensorProto& BlobProto::_internal_qtensor() const {
  const ::caffe2::QTensorProto* p = qtensor_;
  return p != nullptr ? *p : *reinterpret_cast<const ::caffe2::QTensorProto*>(
      &::caffe2::_QTensorProto_default_instance_);
}
inline const ::caffe2::QTensorProto& BlobProto::qtensor() const {
  // @@protoc_insertion_point(field_get:caffe2.BlobProto.qtensor)
  return _internal_qtensor();
}
inline void BlobProto::unsafe_arena_set_allocated_qtensor(
    ::caffe2::QTensorProto* qtensor) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(qtensor_);
  }
  qtensor_ = qtensor;
  if (qtensor) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.BlobProto.qtensor)
}
inline ::caffe2::QTensorProto* BlobProto::release_qtensor() {
  _has_bits_[0] &= ~0x00000010u;
  ::caffe2::QTensorProto* temp = qtensor_;
  qtensor_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::caffe2::QTensorProto* BlobProto::unsafe_arena_release_qtensor() {
  // @@protoc_insertion_point(field_release:caffe2.BlobProto.qtensor)
  _has_bits_[0] &= ~0x00000010u;
  ::caffe2::QTensorProto* temp = qtensor_;
  qtensor_ = nullptr;
  return temp;
}
inline ::caffe2::QTensorProto* BlobProto::_internal_mutable_qtensor() {
  _has_bits_[0] |= 0x00000010u;
  if (qtensor_ == nullptr) {
    auto* p = CreateMaybeMessage<::caffe2::QTensorProto>(GetArena());
    qtensor_ = p;
  }
  return qtensor_;
}
inline ::caffe2::QTensorProto* BlobProto::mutable_qtensor() {
  // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.qtensor)
  return _internal_mutable_qtensor();
}
inline void BlobProto::set_allocated_qtensor(::caffe2::QTensorProto* qtensor) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete qtensor_;
  }
  if (qtensor) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(qtensor);
    if (message_arena != submessage_arena) {
      qtensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, qtensor, submessage_arena);
    }
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  qtensor_ = qtensor;
  // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.qtensor)
}

// optional int32 content_num_chunks = 6;
inline bool BlobProto::_internal_has_content_num_chunks() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool BlobProto::has_content_num_chunks() const {
  return _internal_has_content_num_chunks();
}
inline void BlobProto::clear_content_num_chunks() {
  content_num_chunks_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 BlobProto::_internal_content_num_chunks() const {
  return content_num_chunks_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 BlobProto::content_num_chunks() const {
  // @@protoc_insertion_point(field_get:caffe2.BlobProto.content_num_chunks)
  return _internal_content_num_chunks();
}
inline void BlobProto::_internal_set_content_num_chunks(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000020u;
  content_num_chunks_ = value;
}
inline void BlobProto::set_content_num_chunks(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_content_num_chunks(value);
  // @@protoc_insertion_point(field_set:caffe2.BlobProto.content_num_chunks)
}

// optional int32 content_chunk_id = 7;
inline bool BlobProto::_internal_has_content_chunk_id() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool BlobProto::has_content_chunk_id() const {
  return _internal_has_content_chunk_id();
}
inline void BlobProto::clear_content_chunk_id() {
  content_chunk_id_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 BlobProto::_internal_content_chunk_id() const {
  return content_chunk_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 BlobProto::content_chunk_id() const {
  // @@protoc_insertion_point(field_get:caffe2.BlobProto.content_chunk_id)
  return _internal_content_chunk_id();
}
inline void BlobProto::_internal_set_content_chunk_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000040u;
  content_chunk_id_ = value;
}
inline void BlobProto::set_content_chunk_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_content_chunk_id(value);
  // @@protoc_insertion_point(field_set:caffe2.BlobProto.content_chunk_id)
}

// -------------------------------------------------------------------

// DBReaderProto

// optional string name = 1;
inline bool DBReaderProto::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DBReaderProto::has_name() const {
  return _internal_has_name();
}
inline void DBReaderProto::clear_name() {
  name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DBReaderProto::name() const {
  // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.name)
  return _internal_name();
}
inline void DBReaderProto::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.name)
}
inline std::string* DBReaderProto::mutable_name() {
  // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.name)
  return _internal_mutable_name();
}
inline const std::string& DBReaderProto::_internal_name() const {
  return name_.Get();
}
inline void DBReaderProto::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void DBReaderProto::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.DBReaderProto.name)
}
inline void DBReaderProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.name)
}
inline void DBReaderProto::set_name(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.name)
}
inline std::string* DBReaderProto::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* DBReaderProto::release_name() {
  // @@protoc_insertion_point(field_release:caffe2.DBReaderProto.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void DBReaderProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocated(&GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.name)
}

// optional string source = 2;
inline bool DBReaderProto::_internal_has_source() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DBReaderProto::has_source() const {
  return _internal_has_source();
}
inline void DBReaderProto::clear_source() {
  source_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DBReaderProto::source() const {
  // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.source)
  return _internal_source();
}
inline void DBReaderProto::set_source(const std::string& value) {
  _internal_set_source(value);
  // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.source)
}
inline std::string* DBReaderProto::mutable_source() {
  // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.source)
  return _internal_mutable_source();
}
inline const std::string& DBReaderProto::_internal_source() const {
  return source_.Get();
}
inline void DBReaderProto::_internal_set_source(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  source_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void DBReaderProto::set_source(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  source_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.DBReaderProto.source)
}
inline void DBReaderProto::set_source(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  source_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.source)
}
inline void DBReaderProto::set_source(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  source_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.source)
}
inline std::string* DBReaderProto::_internal_mutable_source() {
  _has_bits_[0] |= 0x00000002u;
  return source_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* DBReaderProto::release_source() {
  // @@protoc_insertion_point(field_release:caffe2.DBReaderProto.source)
  if (!_internal_has_source()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return source_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void DBReaderProto::set_allocated_source(std::string* source) {
  if (source != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  source_.SetAllocated(&GetEmptyStringAlreadyInited(), source,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.source)
}

// optional string db_type = 3;
inline bool DBReaderProto::_internal_has_db_type() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DBReaderProto::has_db_type() const {
  return _internal_has_db_type();
}
inline void DBReaderProto::clear_db_type() {
  db_type_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& DBReaderProto::db_type() const {
  // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.db_type)
  return _internal_db_type();
}
inline void DBReaderProto::set_db_type(const std::string& value) {
  _internal_set_db_type(value);
  // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.db_type)
}
inline std::string* DBReaderProto::mutable_db_type() {
  // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.db_type)
  return _internal_mutable_db_type();
}
inline const std::string& DBReaderProto::_internal_db_type() const {
  return db_type_.Get();
}
inline void DBReaderProto::_internal_set_db_type(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  db_type_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void DBReaderProto::set_db_type(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  db_type_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.DBReaderProto.db_type)
}
inline void DBReaderProto::set_db_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  db_type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.db_type)
}
inline void DBReaderProto::set_db_type(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000004u;
  db_type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.db_type)
}
inline std::string* DBReaderProto::_internal_mutable_db_type() {
  _has_bits_[0] |= 0x00000004u;
  return db_type_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* DBReaderProto::release_db_type() {
  // @@protoc_insertion_point(field_release:caffe2.DBReaderProto.db_type)
  if (!_internal_has_db_type()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return db_type_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void DBReaderProto::set_allocated_db_type(std::string* db_type) {
  if (db_type != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  db_type_.SetAllocated(&GetEmptyStringAlreadyInited(), db_type,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.db_type)
}

// optional string key = 4;
inline bool DBReaderProto::_internal_has_key() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool DBReaderProto::has_key() const {
  return _internal_has_key();
}
inline void DBReaderProto::clear_key() {
  key_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& DBReaderProto::key() const {
  // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.key)
  return _internal_key();
}
inline void DBReaderProto::set_key(const std::string& value) {
  _internal_set_key(value);
  // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.key)
}
inline std::string* DBReaderProto::mutable_key() {
  // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.key)
  return _internal_mutable_key();
}
inline const std::string& DBReaderProto::_internal_key() const {
  return key_.Get();
}
inline void DBReaderProto::_internal_set_key(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  key_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void DBReaderProto::set_key(std::string&& value) {
  _has_bits_[0] |= 0x00000008u;
  key_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.DBReaderProto.key)
}
inline void DBReaderProto::set_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000008u;
  key_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.key)
}
inline void DBReaderProto::set_key(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000008u;
  key_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.key)
}
inline std::string* DBReaderProto::_internal_mutable_key() {
  _has_bits_[0] |= 0x00000008u;
  return key_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* DBReaderProto::release_key() {
  // @@protoc_insertion_point(field_release:caffe2.DBReaderProto.key)
  if (!_internal_has_key()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return key_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void DBReaderProto::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  key_.SetAllocated(&GetEmptyStringAlreadyInited(), key,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.key)
}

// -------------------------------------------------------------------

// BlobSerializationOptions

// optional string blob_name_regex = 1;
inline bool BlobSerializationOptions::_internal_has_blob_name_regex() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool BlobSerializationOptions::has_blob_name_regex() const {
  return _internal_has_blob_name_regex();
}
inline void BlobSerializationOptions::clear_blob_name_regex() {
  blob_name_regex_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& BlobSerializationOptions::blob_name_regex() const {
  // @@protoc_insertion_point(field_get:caffe2.BlobSerializationOptions.blob_name_regex)
  return _internal_blob_name_regex();
}
inline void BlobSerializationOptions::set_blob_name_regex(const std::string& value) {
  _internal_set_blob_name_regex(value);
  // @@protoc_insertion_point(field_set:caffe2.BlobSerializationOptions.blob_name_regex)
}
inline std::string* BlobSerializationOptions::mutable_blob_name_regex() {
  // @@protoc_insertion_point(field_mutable:caffe2.BlobSerializationOptions.blob_name_regex)
  return _internal_mutable_blob_name_regex();
}
inline const std::string& BlobSerializationOptions::_internal_blob_name_regex() const {
  return blob_name_regex_.Get();
}
inline void BlobSerializationOptions::_internal_set_blob_name_regex(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  blob_name_regex_.Set(&GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void BlobSerializationOptions::set_blob_name_regex(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  blob_name_regex_.Set(
    &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:caffe2.BlobSerializationOptions.blob_name_regex)
}
inline void BlobSerializationOptions::set_blob_name_regex(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  blob_name_regex_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:caffe2.BlobSerializationOptions.blob_name_regex)
}
inline void BlobSerializationOptions::set_blob_name_regex(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  blob_name_regex_.Set(&GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:caffe2.BlobSerializationOptions.blob_name_regex)
}
inline std::string* BlobSerializationOptions::_internal_mutable_blob_name_regex() {
  _has_bits_[0] |= 0x00000001u;
  return blob_name_regex_.Mutable(&GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* BlobSerializationOptions::release_blob_name_regex() {
  // @@protoc_insertion_point(field_release:caffe2.BlobSerializationOptions.blob_name_regex)
  if (!_internal_has_blob_name_regex()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return blob_name_regex_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena());
}
inline void BlobSerializationOptions::set_allocated_blob_name_regex(std::string* blob_name_regex) {
  if (blob_name_regex != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  blob_name_regex_.SetAllocated(&GetEmptyStringAlreadyInited(), blob_name_regex,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:caffe2.BlobSerializationOptions.blob_name_regex)
}

// optional int64 chunk_size = 2;
inline bool BlobSerializationOptions::_internal_has_chunk_size() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool BlobSerializationOptions::has_chunk_size() const {
  return _internal_has_chunk_size();
}
inline void BlobSerializationOptions::clear_chunk_size() {
  chunk_size_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BlobSerializationOptions::_internal_chunk_size() const {
  return chunk_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 BlobSerializationOptions::chunk_size() const {
  // @@protoc_insertion_point(field_get:caffe2.BlobSerializationOptions.chunk_size)
  return _internal_chunk_size();
}
inline void BlobSerializationOptions::_internal_set_chunk_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000002u;
  chunk_size_ = value;
}
inline void BlobSerializationOptions::set_chunk_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_chunk_size(value);
  // @@protoc_insertion_point(field_set:caffe2.BlobSerializationOptions.chunk_size)
}

// optional .caffe2.BlobSerializationOptions.FloatFormat float_format = 3;
inline bool BlobSerializationOptions::_internal_has_float_format() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool BlobSerializationOptions::has_float_format() const {
  return _internal_has_float_format();
}
inline void BlobSerializationOptions::clear_float_format() {
  float_format_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::caffe2::BlobSerializationOptions_FloatFormat BlobSerializationOptions::_internal_float_format() const {
  return static_cast< ::caffe2::BlobSerializationOptions_FloatFormat >(float_format_);
}
inline ::caffe2::BlobSerializationOptions_FloatFormat BlobSerializationOptions::float_format() const {
  // @@protoc_insertion_point(field_get:caffe2.BlobSerializationOptions.float_format)
  return _internal_float_format();
}
inline void BlobSerializationOptions::_internal_set_float_format(::caffe2::BlobSerializationOptions_FloatFormat value) {
  assert(::caffe2::BlobSerializationOptions_FloatFormat_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  float_format_ = value;
}
inline void BlobSerializationOptions::set_float_format(::caffe2::BlobSerializationOptions_FloatFormat value) {
  _internal_set_float_format(value);
  // @@protoc_insertion_point(field_set:caffe2.BlobSerializationOptions.float_format)
}

// -------------------------------------------------------------------

// SerializationOptions

// repeated .caffe2.BlobSerializationOptions options = 1;
inline int SerializationOptions::_internal_options_size() const {
  return options_.size();
}
inline int SerializationOptions::options_size() const {
  return _internal_options_size();
}
inline void SerializationOptions::clear_options() {
  options_.Clear();
}
inline ::caffe2::BlobSerializationOptions* SerializationOptions::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:caffe2.SerializationOptions.options)
  return options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions >*
SerializationOptions::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:caffe2.SerializationOptions.options)
  return &options_;
}
inline const ::caffe2::BlobSerializationOptions& SerializationOptions::_internal_options(int index) const {
  return options_.Get(index);
}
inline const ::caffe2::BlobSerializationOptions& SerializationOptions::options(int index) const {
  // @@protoc_insertion_point(field_get:caffe2.SerializationOptions.options)
  return _internal_options(index);
}
inline ::caffe2::BlobSerializationOptions* SerializationOptions::_internal_add_options() {
  return options_.Add();
}
inline ::caffe2::BlobSerializationOptions* SerializationOptions::add_options() {
  // @@protoc_insertion_point(field_add:caffe2.SerializationOptions.options)
  return _internal_add_options();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions >&
SerializationOptions::options() const {
  // @@protoc_insertion_point(field_list:caffe2.SerializationOptions.options)
  return options_;
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// @@protoc_insertion_point(namespace_scope)

}  // namespace caffe2

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::caffe2::TensorProto_DataType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::TensorProto_DataType>() {
  return ::caffe2::TensorProto_DataType_descriptor();
}
template <> struct is_proto_enum< ::caffe2::TensorProto_SerializationFormat> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::TensorProto_SerializationFormat>() {
  return ::caffe2::TensorProto_SerializationFormat_descriptor();
}
template <> struct is_proto_enum< ::caffe2::TensorBoundShape_DimType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::TensorBoundShape_DimType>() {
  return ::caffe2::TensorBoundShape_DimType_descriptor();
}
template <> struct is_proto_enum< ::caffe2::BlobSerializationOptions_FloatFormat> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::BlobSerializationOptions_FloatFormat>() {
  return ::caffe2::BlobSerializationOptions_FloatFormat_descriptor();
}
template <> struct is_proto_enum< ::caffe2::DeviceTypeProto> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::DeviceTypeProto>() {
  return ::caffe2::DeviceTypeProto_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_caffe2_2fproto_2fcaffe2_2eproto

// Generated by the protocol buffer compiler. DO NOT EDIT! // source: caffe2/proto/caffe2.proto #ifndef GOOGLE_PROTOBUF_INCLUDED_caffe2_2fproto_2fcaffe2_2eproto #define GOOGLE_PROTOBUF_INCLUDED_caffe2_2fproto_2fcaffe2_2eproto #include #include #include #if PROTOBUF_VERSION < 3013000 #error This file was generated by a newer version of protoc which is #error incompatible with your Protocol Buffer headers. Please update #error your headers. #endif #if 3013000 < PROTOBUF_MIN_PROTOC_VERSION #error This file was generated by an older version of protoc which is #error incompatible with your Protocol Buffer headers. Please #error regenerate this file with a newer version of protoc. #endif #include #include #include #include #include #include #include #include #include #include #include // IWYU pragma: export #include // IWYU pragma: export #include #include // @@protoc_insertion_point(includes) #include #define PROTOBUF_INTERNAL_EXPORT_caffe2_2fproto_2fcaffe2_2eproto TORCH_API PROTOBUF_NAMESPACE_OPEN namespace internal { class AnyMetadata; } // namespace internal PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct TORCH_API TableStruct_caffe2_2fproto_2fcaffe2_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[22] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; }; extern TORCH_API const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_caffe2_2fproto_2fcaffe2_2eproto; namespace caffe2 { const ::std::string& GetEmptyStringAlreadyInited(); class AOTConfig; class AOTConfigDefaultTypeInternal; TORCH_API extern AOTConfigDefaultTypeInternal _AOTConfig_default_instance_; class Argument; class ArgumentDefaultTypeInternal; TORCH_API extern ArgumentDefaultTypeInternal _Argument_default_instance_; class BackendOptions; class BackendOptionsDefaultTypeInternal; TORCH_API extern BackendOptionsDefaultTypeInternal _BackendOptions_default_instance_; class BlobProto; class BlobProtoDefaultTypeInternal; TORCH_API extern BlobProtoDefaultTypeInternal _BlobProto_default_instance_; class BlobSerializationOptions; class BlobSerializationOptionsDefaultTypeInternal; TORCH_API extern BlobSerializationOptionsDefaultTypeInternal _BlobSerializationOptions_default_instance_; class DBReaderProto; class DBReaderProtoDefaultTypeInternal; TORCH_API extern DBReaderProtoDefaultTypeInternal _DBReaderProto_default_instance_; class DeviceOption; class DeviceOptionDefaultTypeInternal; TORCH_API extern DeviceOptionDefaultTypeInternal _DeviceOption_default_instance_; class ExecutionStep; class ExecutionStepDefaultTypeInternal; TORCH_API extern ExecutionStepDefaultTypeInternal _ExecutionStep_default_instance_; class MapFieldEntry; class MapFieldEntryDefaultTypeInternal; TORCH_API extern MapFieldEntryDefaultTypeInternal _MapFieldEntry_default_instance_; class NetDef; class NetDefDefaultTypeInternal; TORCH_API extern NetDefDefaultTypeInternal _NetDef_default_instance_; class OperatorDef; class OperatorDefDefaultTypeInternal; TORCH_API extern OperatorDefDefaultTypeInternal _OperatorDef_default_instance_; class PartitionInfo; class PartitionInfoDefaultTypeInternal; TORCH_API extern PartitionInfoDefaultTypeInternal _PartitionInfo_default_instance_; class PlanDef; class PlanDefDefaultTypeInternal; TORCH_API extern PlanDefDefaultTypeInternal _PlanDef_default_instance_; class QTensorProto; class QTensorProtoDefaultTypeInternal; TORCH_API extern QTensorProtoDefaultTypeInternal _QTensorProto_default_instance_; class SerializationOptions; class SerializationOptionsDefaultTypeInternal; TORCH_API extern SerializationOptionsDefaultTypeInternal _SerializationOptions_default_instance_; class TensorBoundShape; class TensorBoundShapeDefaultTypeInternal; TORCH_API extern TensorBoundShapeDefaultTypeInternal _TensorBoundShape_default_instance_; class TensorBoundShapes; class TensorBoundShapesDefaultTypeInternal; TORCH_API extern TensorBoundShapesDefaultTypeInternal _TensorBoundShapes_default_instance_; class TensorProto; class TensorProtoDefaultTypeInternal; TORCH_API extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_; class TensorProto_Segment; class TensorProto_SegmentDefaultTypeInternal; TORCH_API extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_; class TensorProtos; class TensorProtosDefaultTypeInternal; TORCH_API extern TensorProtosDefaultTypeInternal _TensorProtos_default_instance_; class TensorShape; class TensorShapeDefaultTypeInternal; TORCH_API extern TensorShapeDefaultTypeInternal _TensorShape_default_instance_; class TensorShapes; class TensorShapesDefaultTypeInternal; TORCH_API extern TensorShapesDefaultTypeInternal _TensorShapes_default_instance_; } // namespace caffe2 PROTOBUF_NAMESPACE_OPEN template<> TORCH_API ::caffe2::AOTConfig* Arena::CreateMaybeMessage<::caffe2::AOTConfig>(Arena*); template<> TORCH_API ::caffe2::Argument* Arena::CreateMaybeMessage<::caffe2::Argument>(Arena*); template<> TORCH_API ::caffe2::BackendOptions* Arena::CreateMaybeMessage<::caffe2::BackendOptions>(Arena*); template<> TORCH_API ::caffe2::BlobProto* Arena::CreateMaybeMessage<::caffe2::BlobProto>(Arena*); template<> TORCH_API ::caffe2::BlobSerializationOptions* Arena::CreateMaybeMessage<::caffe2::BlobSerializationOptions>(Arena*); template<> TORCH_API ::caffe2::DBReaderProto* Arena::CreateMaybeMessage<::caffe2::DBReaderProto>(Arena*); template<> TORCH_API ::caffe2::DeviceOption* Arena::CreateMaybeMessage<::caffe2::DeviceOption>(Arena*); template<> TORCH_API ::caffe2::ExecutionStep* Arena::CreateMaybeMessage<::caffe2::ExecutionStep>(Arena*); template<> TORCH_API ::caffe2::MapFieldEntry* Arena::CreateMaybeMessage<::caffe2::MapFieldEntry>(Arena*); template<> TORCH_API ::caffe2::NetDef* Arena::CreateMaybeMessage<::caffe2::NetDef>(Arena*); template<> TORCH_API ::caffe2::OperatorDef* Arena::CreateMaybeMessage<::caffe2::OperatorDef>(Arena*); template<> TORCH_API ::caffe2::PartitionInfo* Arena::CreateMaybeMessage<::caffe2::PartitionInfo>(Arena*); template<> TORCH_API ::caffe2::PlanDef* Arena::CreateMaybeMessage<::caffe2::PlanDef>(Arena*); template<> TORCH_API ::caffe2::QTensorProto* Arena::CreateMaybeMessage<::caffe2::QTensorProto>(Arena*); template<> TORCH_API ::caffe2::SerializationOptions* Arena::CreateMaybeMessage<::caffe2::SerializationOptions>(Arena*); template<> TORCH_API ::caffe2::TensorBoundShape* Arena::CreateMaybeMessage<::caffe2::TensorBoundShape>(Arena*); template<> TORCH_API ::caffe2::TensorBoundShapes* Arena::CreateMaybeMessage<::caffe2::TensorBoundShapes>(Arena*); template<> TORCH_API ::caffe2::TensorProto* Arena::CreateMaybeMessage<::caffe2::TensorProto>(Arena*); template<> TORCH_API ::caffe2::TensorProto_Segment* Arena::CreateMaybeMessage<::caffe2::TensorProto_Segment>(Arena*); template<> TORCH_API ::caffe2::TensorProtos* Arena::CreateMaybeMessage<::caffe2::TensorProtos>(Arena*); template<> TORCH_API ::caffe2::TensorShape* Arena::CreateMaybeMessage<::caffe2::TensorShape>(Arena*); template<> TORCH_API ::caffe2::TensorShapes* Arena::CreateMaybeMessage<::caffe2::TensorShapes>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace caffe2 { enum TensorProto_DataType : int { TensorProto_DataType_UNDEFINED = 0, TensorProto_DataType_FLOAT = 1, TensorProto_DataType_INT32 = 2, TensorProto_DataType_BYTE = 3, TensorProto_DataType_STRING = 4, TensorProto_DataType_BOOL = 5, TensorProto_DataType_UINT8 = 6, TensorProto_DataType_INT8 = 7, TensorProto_DataType_UINT16 = 8, TensorProto_DataType_INT16 = 9, TensorProto_DataType_INT64 = 10, TensorProto_DataType_FLOAT16 = 12, TensorProto_DataType_DOUBLE = 13, TensorProto_DataType_ZERO_COLLISION_HASH = 14, TensorProto_DataType_REBATCHING_BUFFER = 15 }; TORCH_API bool TensorProto_DataType_IsValid(int value); constexpr TensorProto_DataType TensorProto_DataType_DataType_MIN = TensorProto_DataType_UNDEFINED; constexpr TensorProto_DataType TensorProto_DataType_DataType_MAX = TensorProto_DataType_REBATCHING_BUFFER; constexpr int TensorProto_DataType_DataType_ARRAYSIZE = static_cast(TensorProto_DataType_DataType_MAX) + 1; TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TensorProto_DataType_descriptor(); template inline const std::string& TensorProto_DataType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function TensorProto_DataType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( TensorProto_DataType_descriptor(), enum_t_value); } inline bool TensorProto_DataType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TensorProto_DataType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( TensorProto_DataType_descriptor(), name, value); } enum TensorProto_SerializationFormat : int { TensorProto_SerializationFormat_FMT_PROTOBUF = 0, TensorProto_SerializationFormat_FMT_BFLOAT16 = 1 }; TORCH_API bool TensorProto_SerializationFormat_IsValid(int value); constexpr TensorProto_SerializationFormat TensorProto_SerializationFormat_SerializationFormat_MIN = TensorProto_SerializationFormat_FMT_PROTOBUF; constexpr TensorProto_SerializationFormat TensorProto_SerializationFormat_SerializationFormat_MAX = TensorProto_SerializationFormat_FMT_BFLOAT16; constexpr int TensorProto_SerializationFormat_SerializationFormat_ARRAYSIZE = static_cast(TensorProto_SerializationFormat_SerializationFormat_MAX) + 1; TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TensorProto_SerializationFormat_descriptor(); template inline const std::string& TensorProto_SerializationFormat_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function TensorProto_SerializationFormat_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( TensorProto_SerializationFormat_descriptor(), enum_t_value); } inline bool TensorProto_SerializationFormat_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TensorProto_SerializationFormat* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( TensorProto_SerializationFormat_descriptor(), name, value); } enum TensorBoundShape_DimType : int { TensorBoundShape_DimType_UNKNOWN = 0, TensorBoundShape_DimType_CONSTANT = 1, TensorBoundShape_DimType_BATCH = 2, TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX = 3, TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX_DEFAULT = 4, TensorBoundShape_DimType_FEATURE_MAX = 5, TensorBoundShape_DimType_FEATURE_MAX_DEFAULT = 6 }; TORCH_API bool TensorBoundShape_DimType_IsValid(int value); constexpr TensorBoundShape_DimType TensorBoundShape_DimType_DimType_MIN = TensorBoundShape_DimType_UNKNOWN; constexpr TensorBoundShape_DimType TensorBoundShape_DimType_DimType_MAX = TensorBoundShape_DimType_FEATURE_MAX_DEFAULT; constexpr int TensorBoundShape_DimType_DimType_ARRAYSIZE = static_cast(TensorBoundShape_DimType_DimType_MAX) + 1; TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TensorBoundShape_DimType_descriptor(); template inline const std::string& TensorBoundShape_DimType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function TensorBoundShape_DimType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( TensorBoundShape_DimType_descriptor(), enum_t_value); } inline bool TensorBoundShape_DimType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TensorBoundShape_DimType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( TensorBoundShape_DimType_descriptor(), name, value); } enum BlobSerializationOptions_FloatFormat : int { BlobSerializationOptions_FloatFormat_FLOAT_DEFAULT = 0, BlobSerializationOptions_FloatFormat_FLOAT_PROTOBUF = 1, BlobSerializationOptions_FloatFormat_FLOAT_BFLOAT16 = 2 }; TORCH_API bool BlobSerializationOptions_FloatFormat_IsValid(int value); constexpr BlobSerializationOptions_FloatFormat BlobSerializationOptions_FloatFormat_FloatFormat_MIN = BlobSerializationOptions_FloatFormat_FLOAT_DEFAULT; constexpr BlobSerializationOptions_FloatFormat BlobSerializationOptions_FloatFormat_FloatFormat_MAX = BlobSerializationOptions_FloatFormat_FLOAT_BFLOAT16; constexpr int BlobSerializationOptions_FloatFormat_FloatFormat_ARRAYSIZE = static_cast(BlobSerializationOptions_FloatFormat_FloatFormat_MAX) + 1; TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BlobSerializationOptions_FloatFormat_descriptor(); template inline const std::string& BlobSerializationOptions_FloatFormat_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function BlobSerializationOptions_FloatFormat_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( BlobSerializationOptions_FloatFormat_descriptor(), enum_t_value); } inline bool BlobSerializationOptions_FloatFormat_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BlobSerializationOptions_FloatFormat* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( BlobSerializationOptions_FloatFormat_descriptor(), name, value); } enum DeviceTypeProto : int { PROTO_CPU = 0, PROTO_CUDA = 1, PROTO_MKLDNN = 2, PROTO_OPENGL = 3, PROTO_OPENCL = 4, PROTO_IDEEP = 5, PROTO_HIP = 6, PROTO_FPGA = 7, PROTO_ORT = 8, PROTO_XLA = 9, PROTO_MLC = 10, PROTO_COMPILE_TIME_MAX_DEVICE_TYPES = 11 }; TORCH_API bool DeviceTypeProto_IsValid(int value); constexpr DeviceTypeProto DeviceTypeProto_MIN = PROTO_CPU; constexpr DeviceTypeProto DeviceTypeProto_MAX = PROTO_COMPILE_TIME_MAX_DEVICE_TYPES; constexpr int DeviceTypeProto_ARRAYSIZE = static_cast(DeviceTypeProto_MAX) + 1; TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceTypeProto_descriptor(); template inline const std::string& DeviceTypeProto_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DeviceTypeProto_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DeviceTypeProto_descriptor(), enum_t_value); } inline bool DeviceTypeProto_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceTypeProto* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DeviceTypeProto_descriptor(), name, value); } // =================================================================== class TORCH_API TensorProto_Segment PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorProto.Segment) */ { public: inline TensorProto_Segment() : TensorProto_Segment(nullptr) {} virtual ~TensorProto_Segment(); TensorProto_Segment(const TensorProto_Segment& from); TensorProto_Segment(TensorProto_Segment&& from) noexcept : TensorProto_Segment() { *this = ::std::move(from); } inline TensorProto_Segment& operator=(const TensorProto_Segment& from) { CopyFrom(from); return *this; } inline TensorProto_Segment& operator=(TensorProto_Segment&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const TensorProto_Segment& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const TensorProto_Segment* internal_default_instance() { return reinterpret_cast( &_TensorProto_Segment_default_instance_); } static int const kIndexInFileMessages = 0; friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) { a.Swap(&b); } inline void Swap(TensorProto_Segment* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TensorProto_Segment* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline TensorProto_Segment* New() const final { return CreateMaybeMessage(nullptr); } TensorProto_Segment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const TensorProto_Segment& from); void MergeFrom(const TensorProto_Segment& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TensorProto_Segment* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.TensorProto.Segment"; } protected: explicit TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kBeginFieldNumber = 1, kEndFieldNumber = 2, }; // required int64 begin = 1; bool has_begin() const; private: bool _internal_has_begin() const; public: void clear_begin(); ::PROTOBUF_NAMESPACE_ID::int64 begin() const; void set_begin(::PROTOBUF_NAMESPACE_ID::int64 value); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_begin() const; void _internal_set_begin(::PROTOBUF_NAMESPACE_ID::int64 value); public: // required int64 end = 2; bool has_end() const; private: bool _internal_has_end() const; public: void clear_end(); ::PROTOBUF_NAMESPACE_ID::int64 end() const; void set_end(::PROTOBUF_NAMESPACE_ID::int64 value); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_end() const; void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int64 value); public: // @@protoc_insertion_point(class_scope:caffe2.TensorProto.Segment) private: class _Internal; // helper for ByteSizeLong() size_t RequiredFieldsByteSizeFallback() const; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::int64 begin_; ::PROTOBUF_NAMESPACE_ID::int64 end_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API TensorProto PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorProto) */ { public: inline TensorProto() : TensorProto(nullptr) {} virtual ~TensorProto(); TensorProto(const TensorProto& from); TensorProto(TensorProto&& from) noexcept : TensorProto() { *this = ::std::move(from); } inline TensorProto& operator=(const TensorProto& from) { CopyFrom(from); return *this; } inline TensorProto& operator=(TensorProto&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const TensorProto& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const TensorProto* internal_default_instance() { return reinterpret_cast( &_TensorProto_default_instance_); } static int const kIndexInFileMessages = 1; friend void swap(TensorProto& a, TensorProto& b) { a.Swap(&b); } inline void Swap(TensorProto* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TensorProto* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline TensorProto* New() const final { return CreateMaybeMessage(nullptr); } TensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const TensorProto& from); void MergeFrom(const TensorProto& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TensorProto* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.TensorProto"; } protected: explicit TensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- typedef TensorProto_Segment Segment; typedef TensorProto_DataType DataType; static DataType const UNDEFINED = TensorProto_DataType_UNDEFINED; static DataType const FLOAT = TensorProto_DataType_FLOAT; static DataType const INT32 = TensorProto_DataType_INT32; static DataType const BYTE = TensorProto_DataType_BYTE; static DataType const STRING = TensorProto_DataType_STRING; static DataType const BOOL = TensorProto_DataType_BOOL; static DataType const UINT8 = TensorProto_DataType_UINT8; static DataType const INT8 = TensorProto_DataType_INT8; static DataType const UINT16 = TensorProto_DataType_UINT16; static DataType const INT16 = TensorProto_DataType_INT16; static DataType const INT64 = TensorProto_DataType_INT64; static DataType const FLOAT16 = TensorProto_DataType_FLOAT16; static DataType const DOUBLE = TensorProto_DataType_DOUBLE; static DataType const ZERO_COLLISION_HASH = TensorProto_DataType_ZERO_COLLISION_HASH; static DataType const REBATCHING_BUFFER = TensorProto_DataType_REBATCHING_BUFFER; static inline bool DataType_IsValid(int value) { return TensorProto_DataType_IsValid(value); } static DataType const DataType_MIN = TensorProto_DataType_DataType_MIN; static DataType const DataType_MAX = TensorProto_DataType_DataType_MAX; static int const DataType_ARRAYSIZE = TensorProto_DataType_DataType_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataType_descriptor() { return TensorProto_DataType_descriptor(); } template static inline const std::string& DataType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DataType_Name."); return TensorProto_DataType_Name(enum_t_value); } static inline bool DataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataType* value) { return TensorProto_DataType_Parse(name, value); } typedef TensorProto_SerializationFormat SerializationFormat; static SerializationFormat const FMT_PROTOBUF = TensorProto_SerializationFormat_FMT_PROTOBUF; static SerializationFormat const FMT_BFLOAT16 = TensorProto_SerializationFormat_FMT_BFLOAT16; static inline bool SerializationFormat_IsValid(int value) { return TensorProto_SerializationFormat_IsValid(value); } static SerializationFormat const SerializationFormat_MIN = TensorProto_SerializationFormat_SerializationFormat_MIN; static SerializationFormat const SerializationFormat_MAX = TensorProto_SerializationFormat_SerializationFormat_MAX; static int const SerializationFormat_ARRAYSIZE = TensorProto_SerializationFormat_SerializationFormat_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SerializationFormat_descriptor() { return TensorProto_SerializationFormat_descriptor(); } template static inline const std::string& SerializationFormat_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function SerializationFormat_Name."); return TensorProto_SerializationFormat_Name(enum_t_value); } static inline bool SerializationFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SerializationFormat* value) { return TensorProto_SerializationFormat_Parse(name, value); } // accessors ------------------------------------------------------- enum : int { kDimsFieldNumber = 1, kFloatDataFieldNumber = 3, kInt32DataFieldNumber = 4, kStringDataFieldNumber = 6, kDoubleDataFieldNumber = 9, kInt64DataFieldNumber = 10, kByteDataFieldNumber = 5, kNameFieldNumber = 7, kRawDataFieldNumber = 13, kDeviceDetailFieldNumber = 8, kSegmentFieldNumber = 11, kDataFormatFieldNumber = 15, kDataTypeFieldNumber = 2, }; // repeated int64 dims = 1; int dims_size() const; private: int _internal_dims_size() const; public: void clear_dims(); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_dims(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& _internal_dims() const; void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* _internal_mutable_dims(); public: ::PROTOBUF_NAMESPACE_ID::int64 dims(int index) const; void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); void add_dims(::PROTOBUF_NAMESPACE_ID::int64 value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& dims() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* mutable_dims(); // repeated float float_data = 3 [packed = true]; int float_data_size() const; private: int _internal_float_data_size() const; public: void clear_float_data(); private: float _internal_float_data(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& _internal_float_data() const; void _internal_add_float_data(float value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* _internal_mutable_float_data(); public: float float_data(int index) const; void set_float_data(int index, float value); void add_float_data(float value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& float_data() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* mutable_float_data(); // repeated int32 int32_data = 4 [packed = true]; int int32_data_size() const; private: int _internal_int32_data_size() const; public: void clear_int32_data(); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_int32_data(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& _internal_int32_data() const; void _internal_add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* _internal_mutable_int32_data(); public: ::PROTOBUF_NAMESPACE_ID::int32 int32_data(int index) const; void set_int32_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value); void add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& int32_data() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* mutable_int32_data(); // repeated bytes string_data = 6; int string_data_size() const; private: int _internal_string_data_size() const; public: void clear_string_data(); const std::string& string_data(int index) const; std::string* mutable_string_data(int index); void set_string_data(int index, const std::string& value); void set_string_data(int index, std::string&& value); void set_string_data(int index, const char* value); void set_string_data(int index, const void* value, size_t size); std::string* add_string_data(); void add_string_data(const std::string& value); void add_string_data(std::string&& value); void add_string_data(const char* value); void add_string_data(const void* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& string_data() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_string_data(); private: const std::string& _internal_string_data(int index) const; std::string* _internal_add_string_data(); public: // repeated double double_data = 9 [packed = true]; int double_data_size() const; private: int _internal_double_data_size() const; public: void clear_double_data(); private: double _internal_double_data(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& _internal_double_data() const; void _internal_add_double_data(double value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* _internal_mutable_double_data(); public: double double_data(int index) const; void set_double_data(int index, double value); void add_double_data(double value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& double_data() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* mutable_double_data(); // repeated int64 int64_data = 10 [packed = true]; int int64_data_size() const; private: int _internal_int64_data_size() const; public: void clear_int64_data(); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_int64_data(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& _internal_int64_data() const; void _internal_add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* _internal_mutable_int64_data(); public: ::PROTOBUF_NAMESPACE_ID::int64 int64_data(int index) const; void set_int64_data(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); void add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& int64_data() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* mutable_int64_data(); // optional bytes byte_data = 5; bool has_byte_data() const; private: bool _internal_has_byte_data() const; public: void clear_byte_data(); const std::string& byte_data() const; void set_byte_data(const std::string& value); void set_byte_data(std::string&& value); void set_byte_data(const char* value); void set_byte_data(const void* value, size_t size); std::string* mutable_byte_data(); std::string* release_byte_data(); void set_allocated_byte_data(std::string* byte_data); private: const std::string& _internal_byte_data() const; void _internal_set_byte_data(const std::string& value); std::string* _internal_mutable_byte_data(); public: // optional string name = 7; bool has_name() const; private: bool _internal_has_name() const; public: void clear_name(); const std::string& name() const; void set_name(const std::string& value); void set_name(std::string&& value); void set_name(const char* value); void set_name(const char* value, size_t size); std::string* mutable_name(); std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // optional bytes raw_data = 13; bool has_raw_data() const; private: bool _internal_has_raw_data() const; public: void clear_raw_data(); const std::string& raw_data() const; void set_raw_data(const std::string& value); void set_raw_data(std::string&& value); void set_raw_data(const char* value); void set_raw_data(const void* value, size_t size); std::string* mutable_raw_data(); std::string* release_raw_data(); void set_allocated_raw_data(std::string* raw_data); private: const std::string& _internal_raw_data() const; void _internal_set_raw_data(const std::string& value); std::string* _internal_mutable_raw_data(); public: // optional .caffe2.DeviceOption device_detail = 8; bool has_device_detail() const; private: bool _internal_has_device_detail() const; public: void clear_device_detail(); const ::caffe2::DeviceOption& device_detail() const; ::caffe2::DeviceOption* release_device_detail(); ::caffe2::DeviceOption* mutable_device_detail(); void set_allocated_device_detail(::caffe2::DeviceOption* device_detail); private: const ::caffe2::DeviceOption& _internal_device_detail() const; ::caffe2::DeviceOption* _internal_mutable_device_detail(); public: void unsafe_arena_set_allocated_device_detail( ::caffe2::DeviceOption* device_detail); ::caffe2::DeviceOption* unsafe_arena_release_device_detail(); // optional .caffe2.TensorProto.Segment segment = 11; bool has_segment() const; private: bool _internal_has_segment() const; public: void clear_segment(); const ::caffe2::TensorProto_Segment& segment() const; ::caffe2::TensorProto_Segment* release_segment(); ::caffe2::TensorProto_Segment* mutable_segment(); void set_allocated_segment(::caffe2::TensorProto_Segment* segment); private: const ::caffe2::TensorProto_Segment& _internal_segment() const; ::caffe2::TensorProto_Segment* _internal_mutable_segment(); public: void unsafe_arena_set_allocated_segment( ::caffe2::TensorProto_Segment* segment); ::caffe2::TensorProto_Segment* unsafe_arena_release_segment(); // optional uint32 data_format = 15 [default = 0]; bool has_data_format() const; private: bool _internal_has_data_format() const; public: void clear_data_format(); ::PROTOBUF_NAMESPACE_ID::uint32 data_format() const; void set_data_format(::PROTOBUF_NAMESPACE_ID::uint32 value); private: ::PROTOBUF_NAMESPACE_ID::uint32 _internal_data_format() const; void _internal_set_data_format(::PROTOBUF_NAMESPACE_ID::uint32 value); public: // optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT]; bool has_data_type() const; private: bool _internal_has_data_type() const; public: void clear_data_type(); ::caffe2::TensorProto_DataType data_type() const; void set_data_type(::caffe2::TensorProto_DataType value); private: ::caffe2::TensorProto_DataType _internal_data_type() const; void _internal_set_data_type(::caffe2::TensorProto_DataType value); public: // @@protoc_insertion_point(class_scope:caffe2.TensorProto) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > dims_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > float_data_; mutable std::atomic _float_data_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > int32_data_; mutable std::atomic _int32_data_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField string_data_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_data_; mutable std::atomic _double_data_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > int64_data_; mutable std::atomic _int64_data_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr byte_data_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_data_; ::caffe2::DeviceOption* device_detail_; ::caffe2::TensorProto_Segment* segment_; ::PROTOBUF_NAMESPACE_ID::uint32 data_format_; int data_type_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API QTensorProto PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.QTensorProto) */ { public: inline QTensorProto() : QTensorProto(nullptr) {} virtual ~QTensorProto(); QTensorProto(const QTensorProto& from); QTensorProto(QTensorProto&& from) noexcept : QTensorProto() { *this = ::std::move(from); } inline QTensorProto& operator=(const QTensorProto& from) { CopyFrom(from); return *this; } inline QTensorProto& operator=(QTensorProto&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const QTensorProto& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const QTensorProto* internal_default_instance() { return reinterpret_cast( &_QTensorProto_default_instance_); } static int const kIndexInFileMessages = 2; friend void swap(QTensorProto& a, QTensorProto& b) { a.Swap(&b); } inline void Swap(QTensorProto* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(QTensorProto* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline QTensorProto* New() const final { return CreateMaybeMessage(nullptr); } QTensorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const QTensorProto& from); void MergeFrom(const QTensorProto& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(QTensorProto* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.QTensorProto"; } protected: explicit QTensorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDimsFieldNumber = 1, kDataFieldNumber = 6, kScalesFieldNumber = 9, kBiasesFieldNumber = 10, kNameFieldNumber = 7, kScaleFieldNumber = 3, kBiasFieldNumber = 4, kPrecisionFieldNumber = 2, kIsSignedFieldNumber = 5, kIsMultiparamFieldNumber = 12, kAxisFieldNumber = 11, kDataTypeFieldNumber = 8, }; // repeated int64 dims = 1; int dims_size() const; private: int _internal_dims_size() const; public: void clear_dims(); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_dims(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& _internal_dims() const; void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* _internal_mutable_dims(); public: ::PROTOBUF_NAMESPACE_ID::int64 dims(int index) const; void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); void add_dims(::PROTOBUF_NAMESPACE_ID::int64 value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& dims() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* mutable_dims(); // repeated int32 data = 6 [packed = true]; int data_size() const; private: int _internal_data_size() const; public: void clear_data(); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_data(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& _internal_data() const; void _internal_add_data(::PROTOBUF_NAMESPACE_ID::int32 value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* _internal_mutable_data(); public: ::PROTOBUF_NAMESPACE_ID::int32 data(int index) const; void set_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value); void add_data(::PROTOBUF_NAMESPACE_ID::int32 value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& data() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* mutable_data(); // repeated double scales = 9; int scales_size() const; private: int _internal_scales_size() const; public: void clear_scales(); private: double _internal_scales(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& _internal_scales() const; void _internal_add_scales(double value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* _internal_mutable_scales(); public: double scales(int index) const; void set_scales(int index, double value); void add_scales(double value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& scales() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* mutable_scales(); // repeated double biases = 10; int biases_size() const; private: int _internal_biases_size() const; public: void clear_biases(); private: double _internal_biases(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& _internal_biases() const; void _internal_add_biases(double value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* _internal_mutable_biases(); public: double biases(int index) const; void set_biases(int index, double value); void add_biases(double value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& biases() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* mutable_biases(); // optional string name = 7; bool has_name() const; private: bool _internal_has_name() const; public: void clear_name(); const std::string& name() const; void set_name(const std::string& value); void set_name(std::string&& value); void set_name(const char* value); void set_name(const char* value, size_t size); std::string* mutable_name(); std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // required double scale = 3; bool has_scale() const; private: bool _internal_has_scale() const; public: void clear_scale(); double scale() const; void set_scale(double value); private: double _internal_scale() const; void _internal_set_scale(double value); public: // required double bias = 4; bool has_bias() const; private: bool _internal_has_bias() const; public: void clear_bias(); double bias() const; void set_bias(double value); private: double _internal_bias() const; void _internal_set_bias(double value); public: // required int32 precision = 2; bool has_precision() const; private: bool _internal_has_precision() const; public: void clear_precision(); ::PROTOBUF_NAMESPACE_ID::int32 precision() const; void set_precision(::PROTOBUF_NAMESPACE_ID::int32 value); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_precision() const; void _internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value); public: // required bool is_signed = 5; bool has_is_signed() const; private: bool _internal_has_is_signed() const; public: void clear_is_signed(); bool is_signed() const; void set_is_signed(bool value); private: bool _internal_is_signed() const; void _internal_set_is_signed(bool value); public: // optional bool is_multiparam = 12 [default = false]; bool has_is_multiparam() const; private: bool _internal_has_is_multiparam() const; public: void clear_is_multiparam(); bool is_multiparam() const; void set_is_multiparam(bool value); private: bool _internal_is_multiparam() const; void _internal_set_is_multiparam(bool value); public: // optional int32 axis = 11; bool has_axis() const; private: bool _internal_has_axis() const; public: void clear_axis(); ::PROTOBUF_NAMESPACE_ID::int32 axis() const; void set_axis(::PROTOBUF_NAMESPACE_ID::int32 value); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_axis() const; void _internal_set_axis(::PROTOBUF_NAMESPACE_ID::int32 value); public: // optional .caffe2.TensorProto.DataType data_type = 8 [default = INT32]; bool has_data_type() const; private: bool _internal_has_data_type() const; public: void clear_data_type(); ::caffe2::TensorProto_DataType data_type() const; void set_data_type(::caffe2::TensorProto_DataType value); private: ::caffe2::TensorProto_DataType _internal_data_type() const; void _internal_set_data_type(::caffe2::TensorProto_DataType value); public: // @@protoc_insertion_point(class_scope:caffe2.QTensorProto) private: class _Internal; // helper for ByteSizeLong() size_t RequiredFieldsByteSizeFallback() const; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > dims_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > data_; mutable std::atomic _data_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > scales_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > biases_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; double scale_; double bias_; ::PROTOBUF_NAMESPACE_ID::int32 precision_; bool is_signed_; bool is_multiparam_; ::PROTOBUF_NAMESPACE_ID::int32 axis_; int data_type_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API TensorProtos PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorProtos) */ { public: inline TensorProtos() : TensorProtos(nullptr) {} virtual ~TensorProtos(); TensorProtos(const TensorProtos& from); TensorProtos(TensorProtos&& from) noexcept : TensorProtos() { *this = ::std::move(from); } inline TensorProtos& operator=(const TensorProtos& from) { CopyFrom(from); return *this; } inline TensorProtos& operator=(TensorProtos&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const TensorProtos& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const TensorProtos* internal_default_instance() { return reinterpret_cast( &_TensorProtos_default_instance_); } static int const kIndexInFileMessages = 3; friend void swap(TensorProtos& a, TensorProtos& b) { a.Swap(&b); } inline void Swap(TensorProtos* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TensorProtos* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline TensorProtos* New() const final { return CreateMaybeMessage(nullptr); } TensorProtos* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const TensorProtos& from); void MergeFrom(const TensorProtos& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TensorProtos* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.TensorProtos"; } protected: explicit TensorProtos(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kProtosFieldNumber = 1, }; // repeated .caffe2.TensorProto protos = 1; int protos_size() const; private: int _internal_protos_size() const; public: void clear_protos(); ::caffe2::TensorProto* mutable_protos(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >* mutable_protos(); private: const ::caffe2::TensorProto& _internal_protos(int index) const; ::caffe2::TensorProto* _internal_add_protos(); public: const ::caffe2::TensorProto& protos(int index) const; ::caffe2::TensorProto* add_protos(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >& protos() const; // @@protoc_insertion_point(class_scope:caffe2.TensorProtos) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto > protos_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API TensorShape PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorShape) */ { public: inline TensorShape() : TensorShape(nullptr) {} virtual ~TensorShape(); TensorShape(const TensorShape& from); TensorShape(TensorShape&& from) noexcept : TensorShape() { *this = ::std::move(from); } inline TensorShape& operator=(const TensorShape& from) { CopyFrom(from); return *this; } inline TensorShape& operator=(TensorShape&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const TensorShape& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const TensorShape* internal_default_instance() { return reinterpret_cast( &_TensorShape_default_instance_); } static int const kIndexInFileMessages = 4; friend void swap(TensorShape& a, TensorShape& b) { a.Swap(&b); } inline void Swap(TensorShape* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TensorShape* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline TensorShape* New() const final { return CreateMaybeMessage(nullptr); } TensorShape* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const TensorShape& from); void MergeFrom(const TensorShape& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TensorShape* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.TensorShape"; } protected: explicit TensorShape(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDimsFieldNumber = 1, kUnknownDimsFieldNumber = 3, kNameFieldNumber = 5, kUnknownShapeFieldNumber = 4, kDataTypeFieldNumber = 2, }; // repeated int64 dims = 1; int dims_size() const; private: int _internal_dims_size() const; public: void clear_dims(); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_dims(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& _internal_dims() const; void _internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* _internal_mutable_dims(); public: ::PROTOBUF_NAMESPACE_ID::int64 dims(int index) const; void set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); void add_dims(::PROTOBUF_NAMESPACE_ID::int64 value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& dims() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* mutable_dims(); // repeated int32 unknown_dims = 3; int unknown_dims_size() const; private: int _internal_unknown_dims_size() const; public: void clear_unknown_dims(); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_unknown_dims(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& _internal_unknown_dims() const; void _internal_add_unknown_dims(::PROTOBUF_NAMESPACE_ID::int32 value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* _internal_mutable_unknown_dims(); public: ::PROTOBUF_NAMESPACE_ID::int32 unknown_dims(int index) const; void set_unknown_dims(int index, ::PROTOBUF_NAMESPACE_ID::int32 value); void add_unknown_dims(::PROTOBUF_NAMESPACE_ID::int32 value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& unknown_dims() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* mutable_unknown_dims(); // optional string name = 5; bool has_name() const; private: bool _internal_has_name() const; public: void clear_name(); const std::string& name() const; void set_name(const std::string& value); void set_name(std::string&& value); void set_name(const char* value); void set_name(const char* value, size_t size); std::string* mutable_name(); std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // optional bool unknown_shape = 4 [default = false]; bool has_unknown_shape() const; private: bool _internal_has_unknown_shape() const; public: void clear_unknown_shape(); bool unknown_shape() const; void set_unknown_shape(bool value); private: bool _internal_unknown_shape() const; void _internal_set_unknown_shape(bool value); public: // optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT]; bool has_data_type() const; private: bool _internal_has_data_type() const; public: void clear_data_type(); ::caffe2::TensorProto_DataType data_type() const; void set_data_type(::caffe2::TensorProto_DataType value); private: ::caffe2::TensorProto_DataType _internal_data_type() const; void _internal_set_data_type(::caffe2::TensorProto_DataType value); public: // @@protoc_insertion_point(class_scope:caffe2.TensorShape) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > dims_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > unknown_dims_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; bool unknown_shape_; int data_type_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API TensorShapes PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorShapes) */ { public: inline TensorShapes() : TensorShapes(nullptr) {} virtual ~TensorShapes(); TensorShapes(const TensorShapes& from); TensorShapes(TensorShapes&& from) noexcept : TensorShapes() { *this = ::std::move(from); } inline TensorShapes& operator=(const TensorShapes& from) { CopyFrom(from); return *this; } inline TensorShapes& operator=(TensorShapes&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const TensorShapes& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const TensorShapes* internal_default_instance() { return reinterpret_cast( &_TensorShapes_default_instance_); } static int const kIndexInFileMessages = 5; friend void swap(TensorShapes& a, TensorShapes& b) { a.Swap(&b); } inline void Swap(TensorShapes* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TensorShapes* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline TensorShapes* New() const final { return CreateMaybeMessage(nullptr); } TensorShapes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const TensorShapes& from); void MergeFrom(const TensorShapes& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TensorShapes* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.TensorShapes"; } protected: explicit TensorShapes(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kShapesFieldNumber = 1, }; // repeated .caffe2.TensorShape shapes = 1; int shapes_size() const; private: int _internal_shapes_size() const; public: void clear_shapes(); ::caffe2::TensorShape* mutable_shapes(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape >* mutable_shapes(); private: const ::caffe2::TensorShape& _internal_shapes(int index) const; ::caffe2::TensorShape* _internal_add_shapes(); public: const ::caffe2::TensorShape& shapes(int index) const; ::caffe2::TensorShape* add_shapes(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape >& shapes() const; // @@protoc_insertion_point(class_scope:caffe2.TensorShapes) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape > shapes_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API TensorBoundShape PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorBoundShape) */ { public: inline TensorBoundShape() : TensorBoundShape(nullptr) {} virtual ~TensorBoundShape(); TensorBoundShape(const TensorBoundShape& from); TensorBoundShape(TensorBoundShape&& from) noexcept : TensorBoundShape() { *this = ::std::move(from); } inline TensorBoundShape& operator=(const TensorBoundShape& from) { CopyFrom(from); return *this; } inline TensorBoundShape& operator=(TensorBoundShape&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const TensorBoundShape& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const TensorBoundShape* internal_default_instance() { return reinterpret_cast( &_TensorBoundShape_default_instance_); } static int const kIndexInFileMessages = 6; friend void swap(TensorBoundShape& a, TensorBoundShape& b) { a.Swap(&b); } inline void Swap(TensorBoundShape* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TensorBoundShape* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline TensorBoundShape* New() const final { return CreateMaybeMessage(nullptr); } TensorBoundShape* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const TensorBoundShape& from); void MergeFrom(const TensorBoundShape& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TensorBoundShape* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.TensorBoundShape"; } protected: explicit TensorBoundShape(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- typedef TensorBoundShape_DimType DimType; static DimType const UNKNOWN = TensorBoundShape_DimType_UNKNOWN; static DimType const CONSTANT = TensorBoundShape_DimType_CONSTANT; static DimType const BATCH = TensorBoundShape_DimType_BATCH; static DimType const BATCH_OF_FEATURE_MAX = TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX; static DimType const BATCH_OF_FEATURE_MAX_DEFAULT = TensorBoundShape_DimType_BATCH_OF_FEATURE_MAX_DEFAULT; static DimType const FEATURE_MAX = TensorBoundShape_DimType_FEATURE_MAX; static DimType const FEATURE_MAX_DEFAULT = TensorBoundShape_DimType_FEATURE_MAX_DEFAULT; static inline bool DimType_IsValid(int value) { return TensorBoundShape_DimType_IsValid(value); } static DimType const DimType_MIN = TensorBoundShape_DimType_DimType_MIN; static DimType const DimType_MAX = TensorBoundShape_DimType_DimType_MAX; static int const DimType_ARRAYSIZE = TensorBoundShape_DimType_DimType_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DimType_descriptor() { return TensorBoundShape_DimType_descriptor(); } template static inline const std::string& DimType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DimType_Name."); return TensorBoundShape_DimType_Name(enum_t_value); } static inline bool DimType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DimType* value) { return TensorBoundShape_DimType_Parse(name, value); } // accessors ------------------------------------------------------- enum : int { kDimTypeFieldNumber = 2, kNameFieldNumber = 3, kShapeFieldNumber = 1, kShapeIsFinalFieldNumber = 4, }; // repeated .caffe2.TensorBoundShape.DimType dim_type = 2; int dim_type_size() const; private: int _internal_dim_type_size() const; public: void clear_dim_type(); private: ::caffe2::TensorBoundShape_DimType _internal_dim_type(int index) const; void _internal_add_dim_type(::caffe2::TensorBoundShape_DimType value); ::PROTOBUF_NAMESPACE_ID::RepeatedField* _internal_mutable_dim_type(); public: ::caffe2::TensorBoundShape_DimType dim_type(int index) const; void set_dim_type(int index, ::caffe2::TensorBoundShape_DimType value); void add_dim_type(::caffe2::TensorBoundShape_DimType value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField& dim_type() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_dim_type(); // optional string name = 3; bool has_name() const; private: bool _internal_has_name() const; public: void clear_name(); const std::string& name() const; void set_name(const std::string& value); void set_name(std::string&& value); void set_name(const char* value); void set_name(const char* value, size_t size); std::string* mutable_name(); std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // optional .caffe2.TensorShape shape = 1; bool has_shape() const; private: bool _internal_has_shape() const; public: void clear_shape(); const ::caffe2::TensorShape& shape() const; ::caffe2::TensorShape* release_shape(); ::caffe2::TensorShape* mutable_shape(); void set_allocated_shape(::caffe2::TensorShape* shape); private: const ::caffe2::TensorShape& _internal_shape() const; ::caffe2::TensorShape* _internal_mutable_shape(); public: void unsafe_arena_set_allocated_shape( ::caffe2::TensorShape* shape); ::caffe2::TensorShape* unsafe_arena_release_shape(); // optional bool shape_is_final = 4; bool has_shape_is_final() const; private: bool _internal_has_shape_is_final() const; public: void clear_shape_is_final(); bool shape_is_final() const; void set_shape_is_final(bool value); private: bool _internal_shape_is_final() const; void _internal_set_shape_is_final(bool value); public: // @@protoc_insertion_point(class_scope:caffe2.TensorBoundShape) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField dim_type_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::caffe2::TensorShape* shape_; bool shape_is_final_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API TensorBoundShapes PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.TensorBoundShapes) */ { public: inline TensorBoundShapes() : TensorBoundShapes(nullptr) {} virtual ~TensorBoundShapes(); TensorBoundShapes(const TensorBoundShapes& from); TensorBoundShapes(TensorBoundShapes&& from) noexcept : TensorBoundShapes() { *this = ::std::move(from); } inline TensorBoundShapes& operator=(const TensorBoundShapes& from) { CopyFrom(from); return *this; } inline TensorBoundShapes& operator=(TensorBoundShapes&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const TensorBoundShapes& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const TensorBoundShapes* internal_default_instance() { return reinterpret_cast( &_TensorBoundShapes_default_instance_); } static int const kIndexInFileMessages = 7; friend void swap(TensorBoundShapes& a, TensorBoundShapes& b) { a.Swap(&b); } inline void Swap(TensorBoundShapes* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(TensorBoundShapes* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline TensorBoundShapes* New() const final { return CreateMaybeMessage(nullptr); } TensorBoundShapes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const TensorBoundShapes& from); void MergeFrom(const TensorBoundShapes& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(TensorBoundShapes* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.TensorBoundShapes"; } protected: explicit TensorBoundShapes(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kShapesFieldNumber = 1, kMaxBatchSizeFieldNumber = 2, kMaxFeatureLenFieldNumber = 3, }; // repeated .caffe2.TensorBoundShape shapes = 1; int shapes_size() const; private: int _internal_shapes_size() const; public: void clear_shapes(); ::caffe2::TensorBoundShape* mutable_shapes(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape >* mutable_shapes(); private: const ::caffe2::TensorBoundShape& _internal_shapes(int index) const; ::caffe2::TensorBoundShape* _internal_add_shapes(); public: const ::caffe2::TensorBoundShape& shapes(int index) const; ::caffe2::TensorBoundShape* add_shapes(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape >& shapes() const; // optional int64 max_batch_size = 2; bool has_max_batch_size() const; private: bool _internal_has_max_batch_size() const; public: void clear_max_batch_size(); ::PROTOBUF_NAMESPACE_ID::int64 max_batch_size() const; void set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_batch_size() const; void _internal_set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value); public: // optional int64 max_feature_len = 3; bool has_max_feature_len() const; private: bool _internal_has_max_feature_len() const; public: void clear_max_feature_len(); ::PROTOBUF_NAMESPACE_ID::int64 max_feature_len() const; void set_max_feature_len(::PROTOBUF_NAMESPACE_ID::int64 value); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_feature_len() const; void _internal_set_max_feature_len(::PROTOBUF_NAMESPACE_ID::int64 value); public: // @@protoc_insertion_point(class_scope:caffe2.TensorBoundShapes) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape > shapes_; ::PROTOBUF_NAMESPACE_ID::int64 max_batch_size_; ::PROTOBUF_NAMESPACE_ID::int64 max_feature_len_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API AOTConfig PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.AOTConfig) */ { public: inline AOTConfig() : AOTConfig(nullptr) {} virtual ~AOTConfig(); AOTConfig(const AOTConfig& from); AOTConfig(AOTConfig&& from) noexcept : AOTConfig() { *this = ::std::move(from); } inline AOTConfig& operator=(const AOTConfig& from) { CopyFrom(from); return *this; } inline AOTConfig& operator=(AOTConfig&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const AOTConfig& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const AOTConfig* internal_default_instance() { return reinterpret_cast( &_AOTConfig_default_instance_); } static int const kIndexInFileMessages = 8; friend void swap(AOTConfig& a, AOTConfig& b) { a.Swap(&b); } inline void Swap(AOTConfig* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(AOTConfig* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline AOTConfig* New() const final { return CreateMaybeMessage(nullptr); } AOTConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const AOTConfig& from); void MergeFrom(const AOTConfig& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AOTConfig* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.AOTConfig"; } protected: explicit AOTConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kOnnxifiBlacklistOpsFieldNumber = 4, kMaxBatchSizeFieldNumber = 1, kMaxSeqSizeFieldNumber = 2, kInBatchBroadcastFieldNumber = 3, kOnnxifiMinOpsFieldNumber = 5, }; // optional string onnxifi_blacklist_ops = 4; bool has_onnxifi_blacklist_ops() const; private: bool _internal_has_onnxifi_blacklist_ops() const; public: void clear_onnxifi_blacklist_ops(); const std::string& onnxifi_blacklist_ops() const; void set_onnxifi_blacklist_ops(const std::string& value); void set_onnxifi_blacklist_ops(std::string&& value); void set_onnxifi_blacklist_ops(const char* value); void set_onnxifi_blacklist_ops(const char* value, size_t size); std::string* mutable_onnxifi_blacklist_ops(); std::string* release_onnxifi_blacklist_ops(); void set_allocated_onnxifi_blacklist_ops(std::string* onnxifi_blacklist_ops); private: const std::string& _internal_onnxifi_blacklist_ops() const; void _internal_set_onnxifi_blacklist_ops(const std::string& value); std::string* _internal_mutable_onnxifi_blacklist_ops(); public: // required int64 max_batch_size = 1; bool has_max_batch_size() const; private: bool _internal_has_max_batch_size() const; public: void clear_max_batch_size(); ::PROTOBUF_NAMESPACE_ID::int64 max_batch_size() const; void set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_batch_size() const; void _internal_set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value); public: // required int64 max_seq_size = 2; bool has_max_seq_size() const; private: bool _internal_has_max_seq_size() const; public: void clear_max_seq_size(); ::PROTOBUF_NAMESPACE_ID::int64 max_seq_size() const; void set_max_seq_size(::PROTOBUF_NAMESPACE_ID::int64 value); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_seq_size() const; void _internal_set_max_seq_size(::PROTOBUF_NAMESPACE_ID::int64 value); public: // required bool in_batch_broadcast = 3; bool has_in_batch_broadcast() const; private: bool _internal_has_in_batch_broadcast() const; public: void clear_in_batch_broadcast(); bool in_batch_broadcast() const; void set_in_batch_broadcast(bool value); private: bool _internal_in_batch_broadcast() const; void _internal_set_in_batch_broadcast(bool value); public: // optional int32 onnxifi_min_ops = 5; bool has_onnxifi_min_ops() const; private: bool _internal_has_onnxifi_min_ops() const; public: void clear_onnxifi_min_ops(); ::PROTOBUF_NAMESPACE_ID::int32 onnxifi_min_ops() const; void set_onnxifi_min_ops(::PROTOBUF_NAMESPACE_ID::int32 value); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_onnxifi_min_ops() const; void _internal_set_onnxifi_min_ops(::PROTOBUF_NAMESPACE_ID::int32 value); public: // @@protoc_insertion_point(class_scope:caffe2.AOTConfig) private: class _Internal; // helper for ByteSizeLong() size_t RequiredFieldsByteSizeFallback() const; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr onnxifi_blacklist_ops_; ::PROTOBUF_NAMESPACE_ID::int64 max_batch_size_; ::PROTOBUF_NAMESPACE_ID::int64 max_seq_size_; bool in_batch_broadcast_; ::PROTOBUF_NAMESPACE_ID::int32 onnxifi_min_ops_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API Argument PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.Argument) */ { public: inline Argument() : Argument(nullptr) {} virtual ~Argument(); Argument(const Argument& from); Argument(Argument&& from) noexcept : Argument() { *this = ::std::move(from); } inline Argument& operator=(const Argument& from) { CopyFrom(from); return *this; } inline Argument& operator=(Argument&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const Argument& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const Argument* internal_default_instance() { return reinterpret_cast( &_Argument_default_instance_); } static int const kIndexInFileMessages = 9; friend void swap(Argument& a, Argument& b) { a.Swap(&b); } inline void Swap(Argument* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(Argument* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline Argument* New() const final { return CreateMaybeMessage(nullptr); } Argument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const Argument& from); void MergeFrom(const Argument& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Argument* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.Argument"; } protected: explicit Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kFloatsFieldNumber = 5, kIntsFieldNumber = 6, kStringsFieldNumber = 7, kNetsFieldNumber = 9, kTensorsFieldNumber = 11, kQtensorsFieldNumber = 12, kNameFieldNumber = 1, kSFieldNumber = 4, kNFieldNumber = 8, kTFieldNumber = 10, kIFieldNumber = 3, kFFieldNumber = 2, }; // repeated float floats = 5; int floats_size() const; private: int _internal_floats_size() const; public: void clear_floats(); private: float _internal_floats(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& _internal_floats() const; void _internal_add_floats(float value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* _internal_mutable_floats(); public: float floats(int index) const; void set_floats(int index, float value); void add_floats(float value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& floats() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* mutable_floats(); // repeated int64 ints = 6; int ints_size() const; private: int _internal_ints_size() const; public: void clear_ints(); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_ints(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& _internal_ints() const; void _internal_add_ints(::PROTOBUF_NAMESPACE_ID::int64 value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* _internal_mutable_ints(); public: ::PROTOBUF_NAMESPACE_ID::int64 ints(int index) const; void set_ints(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); void add_ints(::PROTOBUF_NAMESPACE_ID::int64 value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& ints() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* mutable_ints(); // repeated bytes strings = 7; int strings_size() const; private: int _internal_strings_size() const; public: void clear_strings(); const std::string& strings(int index) const; std::string* mutable_strings(int index); void set_strings(int index, const std::string& value); void set_strings(int index, std::string&& value); void set_strings(int index, const char* value); void set_strings(int index, const void* value, size_t size); std::string* add_strings(); void add_strings(const std::string& value); void add_strings(std::string&& value); void add_strings(const char* value); void add_strings(const void* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& strings() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_strings(); private: const std::string& _internal_strings(int index) const; std::string* _internal_add_strings(); public: // repeated .caffe2.NetDef nets = 9; int nets_size() const; private: int _internal_nets_size() const; public: void clear_nets(); ::caffe2::NetDef* mutable_nets(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >* mutable_nets(); private: const ::caffe2::NetDef& _internal_nets(int index) const; ::caffe2::NetDef* _internal_add_nets(); public: const ::caffe2::NetDef& nets(int index) const; ::caffe2::NetDef* add_nets(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >& nets() const; // repeated .caffe2.TensorProto tensors = 11; int tensors_size() const; private: int _internal_tensors_size() const; public: void clear_tensors(); ::caffe2::TensorProto* mutable_tensors(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >* mutable_tensors(); private: const ::caffe2::TensorProto& _internal_tensors(int index) const; ::caffe2::TensorProto* _internal_add_tensors(); public: const ::caffe2::TensorProto& tensors(int index) const; ::caffe2::TensorProto* add_tensors(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >& tensors() const; // repeated .caffe2.QTensorProto qtensors = 12; int qtensors_size() const; private: int _internal_qtensors_size() const; public: void clear_qtensors(); ::caffe2::QTensorProto* mutable_qtensors(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto >* mutable_qtensors(); private: const ::caffe2::QTensorProto& _internal_qtensors(int index) const; ::caffe2::QTensorProto* _internal_add_qtensors(); public: const ::caffe2::QTensorProto& qtensors(int index) const; ::caffe2::QTensorProto* add_qtensors(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto >& qtensors() const; // optional string name = 1; bool has_name() const; private: bool _internal_has_name() const; public: void clear_name(); const std::string& name() const; void set_name(const std::string& value); void set_name(std::string&& value); void set_name(const char* value); void set_name(const char* value, size_t size); std::string* mutable_name(); std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // optional bytes s = 4; bool has_s() const; private: bool _internal_has_s() const; public: void clear_s(); const std::string& s() const; void set_s(const std::string& value); void set_s(std::string&& value); void set_s(const char* value); void set_s(const void* value, size_t size); std::string* mutable_s(); std::string* release_s(); void set_allocated_s(std::string* s); private: const std::string& _internal_s() const; void _internal_set_s(const std::string& value); std::string* _internal_mutable_s(); public: // optional .caffe2.NetDef n = 8; bool has_n() const; private: bool _internal_has_n() const; public: void clear_n(); const ::caffe2::NetDef& n() const; ::caffe2::NetDef* release_n(); ::caffe2::NetDef* mutable_n(); void set_allocated_n(::caffe2::NetDef* n); private: const ::caffe2::NetDef& _internal_n() const; ::caffe2::NetDef* _internal_mutable_n(); public: void unsafe_arena_set_allocated_n( ::caffe2::NetDef* n); ::caffe2::NetDef* unsafe_arena_release_n(); // optional .caffe2.TensorProto t = 10; bool has_t() const; private: bool _internal_has_t() const; public: void clear_t(); const ::caffe2::TensorProto& t() const; ::caffe2::TensorProto* release_t(); ::caffe2::TensorProto* mutable_t(); void set_allocated_t(::caffe2::TensorProto* t); private: const ::caffe2::TensorProto& _internal_t() const; ::caffe2::TensorProto* _internal_mutable_t(); public: void unsafe_arena_set_allocated_t( ::caffe2::TensorProto* t); ::caffe2::TensorProto* unsafe_arena_release_t(); // optional int64 i = 3; bool has_i() const; private: bool _internal_has_i() const; public: void clear_i(); ::PROTOBUF_NAMESPACE_ID::int64 i() const; void set_i(::PROTOBUF_NAMESPACE_ID::int64 value); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_i() const; void _internal_set_i(::PROTOBUF_NAMESPACE_ID::int64 value); public: // optional float f = 2; bool has_f() const; private: bool _internal_has_f() const; public: void clear_f(); float f() const; void set_f(float value); private: float _internal_f() const; void _internal_set_f(float value); public: // @@protoc_insertion_point(class_scope:caffe2.Argument) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > floats_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > ints_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField strings_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef > nets_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto > tensors_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto > qtensors_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr s_; ::caffe2::NetDef* n_; ::caffe2::TensorProto* t_; ::PROTOBUF_NAMESPACE_ID::int64 i_; float f_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API DeviceOption PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.DeviceOption) */ { public: inline DeviceOption() : DeviceOption(nullptr) {} virtual ~DeviceOption(); DeviceOption(const DeviceOption& from); DeviceOption(DeviceOption&& from) noexcept : DeviceOption() { *this = ::std::move(from); } inline DeviceOption& operator=(const DeviceOption& from) { CopyFrom(from); return *this; } inline DeviceOption& operator=(DeviceOption&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const DeviceOption& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const DeviceOption* internal_default_instance() { return reinterpret_cast( &_DeviceOption_default_instance_); } static int const kIndexInFileMessages = 10; friend void swap(DeviceOption& a, DeviceOption& b) { a.Swap(&b); } inline void Swap(DeviceOption* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DeviceOption* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline DeviceOption* New() const final { return CreateMaybeMessage(nullptr); } DeviceOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const DeviceOption& from); void MergeFrom(const DeviceOption& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DeviceOption* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.DeviceOption"; } protected: explicit DeviceOption(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kExtraInfoFieldNumber = 6, kNodeNameFieldNumber = 4, kDeviceTypeFieldNumber = 1, kDeviceIdFieldNumber = 2, kRandomSeedFieldNumber = 3, kNumaNodeIdFieldNumber = 5, }; // repeated string extra_info = 6; int extra_info_size() const; private: int _internal_extra_info_size() const; public: void clear_extra_info(); const std::string& extra_info(int index) const; std::string* mutable_extra_info(int index); void set_extra_info(int index, const std::string& value); void set_extra_info(int index, std::string&& value); void set_extra_info(int index, const char* value); void set_extra_info(int index, const char* value, size_t size); std::string* add_extra_info(); void add_extra_info(const std::string& value); void add_extra_info(std::string&& value); void add_extra_info(const char* value); void add_extra_info(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& extra_info() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_extra_info(); private: const std::string& _internal_extra_info(int index) const; std::string* _internal_add_extra_info(); public: // optional string node_name = 4; bool has_node_name() const; private: bool _internal_has_node_name() const; public: void clear_node_name(); const std::string& node_name() const; void set_node_name(const std::string& value); void set_node_name(std::string&& value); void set_node_name(const char* value); void set_node_name(const char* value, size_t size); std::string* mutable_node_name(); std::string* release_node_name(); void set_allocated_node_name(std::string* node_name); private: const std::string& _internal_node_name() const; void _internal_set_node_name(const std::string& value); std::string* _internal_mutable_node_name(); public: // optional int32 device_type = 1 [default = 0]; bool has_device_type() const; private: bool _internal_has_device_type() const; public: void clear_device_type(); ::PROTOBUF_NAMESPACE_ID::int32 device_type() const; void set_device_type(::PROTOBUF_NAMESPACE_ID::int32 value); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_device_type() const; void _internal_set_device_type(::PROTOBUF_NAMESPACE_ID::int32 value); public: // optional int32 device_id = 2; bool has_device_id() const; private: bool _internal_has_device_id() const; public: void clear_device_id(); ::PROTOBUF_NAMESPACE_ID::int32 device_id() const; void set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_device_id() const; void _internal_set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value); public: // optional uint32 random_seed = 3; bool has_random_seed() const; private: bool _internal_has_random_seed() const; public: void clear_random_seed(); ::PROTOBUF_NAMESPACE_ID::uint32 random_seed() const; void set_random_seed(::PROTOBUF_NAMESPACE_ID::uint32 value); private: ::PROTOBUF_NAMESPACE_ID::uint32 _internal_random_seed() const; void _internal_set_random_seed(::PROTOBUF_NAMESPACE_ID::uint32 value); public: // optional int32 numa_node_id = 5; bool has_numa_node_id() const; private: bool _internal_has_numa_node_id() const; public: void clear_numa_node_id(); ::PROTOBUF_NAMESPACE_ID::int32 numa_node_id() const; void set_numa_node_id(::PROTOBUF_NAMESPACE_ID::int32 value); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_numa_node_id() const; void _internal_set_numa_node_id(::PROTOBUF_NAMESPACE_ID::int32 value); public: // @@protoc_insertion_point(class_scope:caffe2.DeviceOption) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField extra_info_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr node_name_; ::PROTOBUF_NAMESPACE_ID::int32 device_type_; ::PROTOBUF_NAMESPACE_ID::int32 device_id_; ::PROTOBUF_NAMESPACE_ID::uint32 random_seed_; ::PROTOBUF_NAMESPACE_ID::int32 numa_node_id_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API OperatorDef PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.OperatorDef) */ { public: inline OperatorDef() : OperatorDef(nullptr) {} virtual ~OperatorDef(); OperatorDef(const OperatorDef& from); OperatorDef(OperatorDef&& from) noexcept : OperatorDef() { *this = ::std::move(from); } inline OperatorDef& operator=(const OperatorDef& from) { CopyFrom(from); return *this; } inline OperatorDef& operator=(OperatorDef&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const OperatorDef& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const OperatorDef* internal_default_instance() { return reinterpret_cast( &_OperatorDef_default_instance_); } static int const kIndexInFileMessages = 11; friend void swap(OperatorDef& a, OperatorDef& b) { a.Swap(&b); } inline void Swap(OperatorDef* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(OperatorDef* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline OperatorDef* New() const final { return CreateMaybeMessage(nullptr); } OperatorDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const OperatorDef& from); void MergeFrom(const OperatorDef& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(OperatorDef* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.OperatorDef"; } protected: explicit OperatorDef(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kInputFieldNumber = 1, kOutputFieldNumber = 2, kArgFieldNumber = 5, kControlInputFieldNumber = 8, kNameFieldNumber = 3, kTypeFieldNumber = 4, kEngineFieldNumber = 7, kDebugInfoFieldNumber = 10, kDomainFieldNumber = 11, kDeviceOptionFieldNumber = 6, kOpVersionFieldNumber = 12, kIsGradientOpFieldNumber = 9, }; // repeated string input = 1; int input_size() const; private: int _internal_input_size() const; public: void clear_input(); const std::string& input(int index) const; std::string* mutable_input(int index); void set_input(int index, const std::string& value); void set_input(int index, std::string&& value); void set_input(int index, const char* value); void set_input(int index, const char* value, size_t size); std::string* add_input(); void add_input(const std::string& value); void add_input(std::string&& value); void add_input(const char* value); void add_input(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& input() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_input(); private: const std::string& _internal_input(int index) const; std::string* _internal_add_input(); public: // repeated string output = 2; int output_size() const; private: int _internal_output_size() const; public: void clear_output(); const std::string& output(int index) const; std::string* mutable_output(int index); void set_output(int index, const std::string& value); void set_output(int index, std::string&& value); void set_output(int index, const char* value); void set_output(int index, const char* value, size_t size); std::string* add_output(); void add_output(const std::string& value); void add_output(std::string&& value); void add_output(const char* value); void add_output(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& output() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_output(); private: const std::string& _internal_output(int index) const; std::string* _internal_add_output(); public: // repeated .caffe2.Argument arg = 5; int arg_size() const; private: int _internal_arg_size() const; public: void clear_arg(); ::caffe2::Argument* mutable_arg(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >* mutable_arg(); private: const ::caffe2::Argument& _internal_arg(int index) const; ::caffe2::Argument* _internal_add_arg(); public: const ::caffe2::Argument& arg(int index) const; ::caffe2::Argument* add_arg(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >& arg() const; // repeated string control_input = 8; int control_input_size() const; private: int _internal_control_input_size() const; public: void clear_control_input(); const std::string& control_input(int index) const; std::string* mutable_control_input(int index); void set_control_input(int index, const std::string& value); void set_control_input(int index, std::string&& value); void set_control_input(int index, const char* value); void set_control_input(int index, const char* value, size_t size); std::string* add_control_input(); void add_control_input(const std::string& value); void add_control_input(std::string&& value); void add_control_input(const char* value); void add_control_input(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& control_input() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_control_input(); private: const std::string& _internal_control_input(int index) const; std::string* _internal_add_control_input(); public: // optional string name = 3; bool has_name() const; private: bool _internal_has_name() const; public: void clear_name(); const std::string& name() const; void set_name(const std::string& value); void set_name(std::string&& value); void set_name(const char* value); void set_name(const char* value, size_t size); std::string* mutable_name(); std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // optional string type = 4; bool has_type() const; private: bool _internal_has_type() const; public: void clear_type(); const std::string& type() const; void set_type(const std::string& value); void set_type(std::string&& value); void set_type(const char* value); void set_type(const char* value, size_t size); std::string* mutable_type(); std::string* release_type(); void set_allocated_type(std::string* type); private: const std::string& _internal_type() const; void _internal_set_type(const std::string& value); std::string* _internal_mutable_type(); public: // optional string engine = 7; bool has_engine() const; private: bool _internal_has_engine() const; public: void clear_engine(); const std::string& engine() const; void set_engine(const std::string& value); void set_engine(std::string&& value); void set_engine(const char* value); void set_engine(const char* value, size_t size); std::string* mutable_engine(); std::string* release_engine(); void set_allocated_engine(std::string* engine); private: const std::string& _internal_engine() const; void _internal_set_engine(const std::string& value); std::string* _internal_mutable_engine(); public: // optional string debug_info = 10; bool has_debug_info() const; private: bool _internal_has_debug_info() const; public: void clear_debug_info(); const std::string& debug_info() const; void set_debug_info(const std::string& value); void set_debug_info(std::string&& value); void set_debug_info(const char* value); void set_debug_info(const char* value, size_t size); std::string* mutable_debug_info(); std::string* release_debug_info(); void set_allocated_debug_info(std::string* debug_info); private: const std::string& _internal_debug_info() const; void _internal_set_debug_info(const std::string& value); std::string* _internal_mutable_debug_info(); public: // optional string domain = 11; bool has_domain() const; private: bool _internal_has_domain() const; public: void clear_domain(); const std::string& domain() const; void set_domain(const std::string& value); void set_domain(std::string&& value); void set_domain(const char* value); void set_domain(const char* value, size_t size); std::string* mutable_domain(); std::string* release_domain(); void set_allocated_domain(std::string* domain); private: const std::string& _internal_domain() const; void _internal_set_domain(const std::string& value); std::string* _internal_mutable_domain(); public: // optional .caffe2.DeviceOption device_option = 6; bool has_device_option() const; private: bool _internal_has_device_option() const; public: void clear_device_option(); const ::caffe2::DeviceOption& device_option() const; ::caffe2::DeviceOption* release_device_option(); ::caffe2::DeviceOption* mutable_device_option(); void set_allocated_device_option(::caffe2::DeviceOption* device_option); private: const ::caffe2::DeviceOption& _internal_device_option() const; ::caffe2::DeviceOption* _internal_mutable_device_option(); public: void unsafe_arena_set_allocated_device_option( ::caffe2::DeviceOption* device_option); ::caffe2::DeviceOption* unsafe_arena_release_device_option(); // optional int64 op_version = 12; bool has_op_version() const; private: bool _internal_has_op_version() const; public: void clear_op_version(); ::PROTOBUF_NAMESPACE_ID::int64 op_version() const; void set_op_version(::PROTOBUF_NAMESPACE_ID::int64 value); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_op_version() const; void _internal_set_op_version(::PROTOBUF_NAMESPACE_ID::int64 value); public: // optional bool is_gradient_op = 9 [default = false]; bool has_is_gradient_op() const; private: bool _internal_has_is_gradient_op() const; public: void clear_is_gradient_op(); bool is_gradient_op() const; void set_is_gradient_op(bool value); private: bool _internal_is_gradient_op() const; void _internal_set_is_gradient_op(bool value); public: // @@protoc_insertion_point(class_scope:caffe2.OperatorDef) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField input_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField output_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument > arg_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField control_input_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr engine_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr debug_info_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_; ::caffe2::DeviceOption* device_option_; ::PROTOBUF_NAMESPACE_ID::int64 op_version_; bool is_gradient_op_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API MapFieldEntry PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.MapFieldEntry) */ { public: inline MapFieldEntry() : MapFieldEntry(nullptr) {} virtual ~MapFieldEntry(); MapFieldEntry(const MapFieldEntry& from); MapFieldEntry(MapFieldEntry&& from) noexcept : MapFieldEntry() { *this = ::std::move(from); } inline MapFieldEntry& operator=(const MapFieldEntry& from) { CopyFrom(from); return *this; } inline MapFieldEntry& operator=(MapFieldEntry&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const MapFieldEntry& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const MapFieldEntry* internal_default_instance() { return reinterpret_cast( &_MapFieldEntry_default_instance_); } static int const kIndexInFileMessages = 12; friend void swap(MapFieldEntry& a, MapFieldEntry& b) { a.Swap(&b); } inline void Swap(MapFieldEntry* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(MapFieldEntry* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline MapFieldEntry* New() const final { return CreateMaybeMessage(nullptr); } MapFieldEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const MapFieldEntry& from); void MergeFrom(const MapFieldEntry& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(MapFieldEntry* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.MapFieldEntry"; } protected: explicit MapFieldEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kKeyFieldNumber = 1, kValFieldNumber = 2, }; // required string key = 1; bool has_key() const; private: bool _internal_has_key() const; public: void clear_key(); const std::string& key() const; void set_key(const std::string& value); void set_key(std::string&& value); void set_key(const char* value); void set_key(const char* value, size_t size); std::string* mutable_key(); std::string* release_key(); void set_allocated_key(std::string* key); private: const std::string& _internal_key() const; void _internal_set_key(const std::string& value); std::string* _internal_mutable_key(); public: // required string val = 2; bool has_val() const; private: bool _internal_has_val() const; public: void clear_val(); const std::string& val() const; void set_val(const std::string& value); void set_val(std::string&& value); void set_val(const char* value); void set_val(const char* value, size_t size); std::string* mutable_val(); std::string* release_val(); void set_allocated_val(std::string* val); private: const std::string& _internal_val() const; void _internal_set_val(const std::string& value); std::string* _internal_mutable_val(); public: // @@protoc_insertion_point(class_scope:caffe2.MapFieldEntry) private: class _Internal; // helper for ByteSizeLong() size_t RequiredFieldsByteSizeFallback() const; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr val_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API BackendOptions PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.BackendOptions) */ { public: inline BackendOptions() : BackendOptions(nullptr) {} virtual ~BackendOptions(); BackendOptions(const BackendOptions& from); BackendOptions(BackendOptions&& from) noexcept : BackendOptions() { *this = ::std::move(from); } inline BackendOptions& operator=(const BackendOptions& from) { CopyFrom(from); return *this; } inline BackendOptions& operator=(BackendOptions&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const BackendOptions& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const BackendOptions* internal_default_instance() { return reinterpret_cast( &_BackendOptions_default_instance_); } static int const kIndexInFileMessages = 13; friend void swap(BackendOptions& a, BackendOptions& b) { a.Swap(&b); } inline void Swap(BackendOptions* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BackendOptions* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline BackendOptions* New() const final { return CreateMaybeMessage(nullptr); } BackendOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const BackendOptions& from); void MergeFrom(const BackendOptions& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(BackendOptions* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.BackendOptions"; } protected: explicit BackendOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kOptionFieldNumber = 2, kBackendNameFieldNumber = 1, }; // repeated .caffe2.MapFieldEntry option = 2; int option_size() const; private: int _internal_option_size() const; public: void clear_option(); ::caffe2::MapFieldEntry* mutable_option(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry >* mutable_option(); private: const ::caffe2::MapFieldEntry& _internal_option(int index) const; ::caffe2::MapFieldEntry* _internal_add_option(); public: const ::caffe2::MapFieldEntry& option(int index) const; ::caffe2::MapFieldEntry* add_option(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry >& option() const; // required string backend_name = 1; bool has_backend_name() const; private: bool _internal_has_backend_name() const; public: void clear_backend_name(); const std::string& backend_name() const; void set_backend_name(const std::string& value); void set_backend_name(std::string&& value); void set_backend_name(const char* value); void set_backend_name(const char* value, size_t size); std::string* mutable_backend_name(); std::string* release_backend_name(); void set_allocated_backend_name(std::string* backend_name); private: const std::string& _internal_backend_name() const; void _internal_set_backend_name(const std::string& value); std::string* _internal_mutable_backend_name(); public: // @@protoc_insertion_point(class_scope:caffe2.BackendOptions) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry > option_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr backend_name_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API PartitionInfo PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.PartitionInfo) */ { public: inline PartitionInfo() : PartitionInfo(nullptr) {} virtual ~PartitionInfo(); PartitionInfo(const PartitionInfo& from); PartitionInfo(PartitionInfo&& from) noexcept : PartitionInfo() { *this = ::std::move(from); } inline PartitionInfo& operator=(const PartitionInfo& from) { CopyFrom(from); return *this; } inline PartitionInfo& operator=(PartitionInfo&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const PartitionInfo& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const PartitionInfo* internal_default_instance() { return reinterpret_cast( &_PartitionInfo_default_instance_); } static int const kIndexInFileMessages = 14; friend void swap(PartitionInfo& a, PartitionInfo& b) { a.Swap(&b); } inline void Swap(PartitionInfo* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PartitionInfo* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline PartitionInfo* New() const final { return CreateMaybeMessage(nullptr); } PartitionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const PartitionInfo& from); void MergeFrom(const PartitionInfo& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(PartitionInfo* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.PartitionInfo"; } protected: explicit PartitionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDeviceIdFieldNumber = 2, kBackendOptionsFieldNumber = 4, kNameFieldNumber = 1, kExtraInfoFieldNumber = 3, }; // repeated int32 device_id = 2; int device_id_size() const; private: int _internal_device_id_size() const; public: void clear_device_id(); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_device_id(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& _internal_device_id() const; void _internal_add_device_id(::PROTOBUF_NAMESPACE_ID::int32 value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* _internal_mutable_device_id(); public: ::PROTOBUF_NAMESPACE_ID::int32 device_id(int index) const; void set_device_id(int index, ::PROTOBUF_NAMESPACE_ID::int32 value); void add_device_id(::PROTOBUF_NAMESPACE_ID::int32 value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& device_id() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* mutable_device_id(); // repeated .caffe2.BackendOptions backend_options = 4; int backend_options_size() const; private: int _internal_backend_options_size() const; public: void clear_backend_options(); ::caffe2::BackendOptions* mutable_backend_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions >* mutable_backend_options(); private: const ::caffe2::BackendOptions& _internal_backend_options(int index) const; ::caffe2::BackendOptions* _internal_add_backend_options(); public: const ::caffe2::BackendOptions& backend_options(int index) const; ::caffe2::BackendOptions* add_backend_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions >& backend_options() const; // required string name = 1; bool has_name() const; private: bool _internal_has_name() const; public: void clear_name(); const std::string& name() const; void set_name(const std::string& value); void set_name(std::string&& value); void set_name(const char* value); void set_name(const char* value, size_t size); std::string* mutable_name(); std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // optional string extra_info = 3; bool has_extra_info() const; private: bool _internal_has_extra_info() const; public: void clear_extra_info(); const std::string& extra_info() const; void set_extra_info(const std::string& value); void set_extra_info(std::string&& value); void set_extra_info(const char* value); void set_extra_info(const char* value, size_t size); std::string* mutable_extra_info(); std::string* release_extra_info(); void set_allocated_extra_info(std::string* extra_info); private: const std::string& _internal_extra_info() const; void _internal_set_extra_info(const std::string& value); std::string* _internal_mutable_extra_info(); public: // @@protoc_insertion_point(class_scope:caffe2.PartitionInfo) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > device_id_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions > backend_options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extra_info_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API NetDef PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.NetDef) */ { public: inline NetDef() : NetDef(nullptr) {} virtual ~NetDef(); NetDef(const NetDef& from); NetDef(NetDef&& from) noexcept : NetDef() { *this = ::std::move(from); } inline NetDef& operator=(const NetDef& from) { CopyFrom(from); return *this; } inline NetDef& operator=(NetDef&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const NetDef& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const NetDef* internal_default_instance() { return reinterpret_cast( &_NetDef_default_instance_); } static int const kIndexInFileMessages = 15; friend void swap(NetDef& a, NetDef& b) { a.Swap(&b); } inline void Swap(NetDef* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NetDef* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline NetDef* New() const final { return CreateMaybeMessage(nullptr); } NetDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const NetDef& from); void MergeFrom(const NetDef& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(NetDef* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.NetDef"; } protected: explicit NetDef(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kOpFieldNumber = 2, kArgFieldNumber = 6, kExternalInputFieldNumber = 7, kExternalOutputFieldNumber = 8, kPartitionInfoFieldNumber = 9, kNameFieldNumber = 1, kTypeFieldNumber = 3, kDeviceOptionFieldNumber = 5, kNumWorkersFieldNumber = 4, }; // repeated .caffe2.OperatorDef op = 2; int op_size() const; private: int _internal_op_size() const; public: void clear_op(); ::caffe2::OperatorDef* mutable_op(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef >* mutable_op(); private: const ::caffe2::OperatorDef& _internal_op(int index) const; ::caffe2::OperatorDef* _internal_add_op(); public: const ::caffe2::OperatorDef& op(int index) const; ::caffe2::OperatorDef* add_op(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef >& op() const; // repeated .caffe2.Argument arg = 6; int arg_size() const; private: int _internal_arg_size() const; public: void clear_arg(); ::caffe2::Argument* mutable_arg(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >* mutable_arg(); private: const ::caffe2::Argument& _internal_arg(int index) const; ::caffe2::Argument* _internal_add_arg(); public: const ::caffe2::Argument& arg(int index) const; ::caffe2::Argument* add_arg(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >& arg() const; // repeated string external_input = 7; int external_input_size() const; private: int _internal_external_input_size() const; public: void clear_external_input(); const std::string& external_input(int index) const; std::string* mutable_external_input(int index); void set_external_input(int index, const std::string& value); void set_external_input(int index, std::string&& value); void set_external_input(int index, const char* value); void set_external_input(int index, const char* value, size_t size); std::string* add_external_input(); void add_external_input(const std::string& value); void add_external_input(std::string&& value); void add_external_input(const char* value); void add_external_input(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& external_input() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_external_input(); private: const std::string& _internal_external_input(int index) const; std::string* _internal_add_external_input(); public: // repeated string external_output = 8; int external_output_size() const; private: int _internal_external_output_size() const; public: void clear_external_output(); const std::string& external_output(int index) const; std::string* mutable_external_output(int index); void set_external_output(int index, const std::string& value); void set_external_output(int index, std::string&& value); void set_external_output(int index, const char* value); void set_external_output(int index, const char* value, size_t size); std::string* add_external_output(); void add_external_output(const std::string& value); void add_external_output(std::string&& value); void add_external_output(const char* value); void add_external_output(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& external_output() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_external_output(); private: const std::string& _internal_external_output(int index) const; std::string* _internal_add_external_output(); public: // repeated .caffe2.PartitionInfo partition_info = 9; int partition_info_size() const; private: int _internal_partition_info_size() const; public: void clear_partition_info(); ::caffe2::PartitionInfo* mutable_partition_info(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo >* mutable_partition_info(); private: const ::caffe2::PartitionInfo& _internal_partition_info(int index) const; ::caffe2::PartitionInfo* _internal_add_partition_info(); public: const ::caffe2::PartitionInfo& partition_info(int index) const; ::caffe2::PartitionInfo* add_partition_info(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo >& partition_info() const; // optional string name = 1; bool has_name() const; private: bool _internal_has_name() const; public: void clear_name(); const std::string& name() const; void set_name(const std::string& value); void set_name(std::string&& value); void set_name(const char* value); void set_name(const char* value, size_t size); std::string* mutable_name(); std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // optional string type = 3; bool has_type() const; private: bool _internal_has_type() const; public: void clear_type(); const std::string& type() const; void set_type(const std::string& value); void set_type(std::string&& value); void set_type(const char* value); void set_type(const char* value, size_t size); std::string* mutable_type(); std::string* release_type(); void set_allocated_type(std::string* type); private: const std::string& _internal_type() const; void _internal_set_type(const std::string& value); std::string* _internal_mutable_type(); public: // optional .caffe2.DeviceOption device_option = 5; bool has_device_option() const; private: bool _internal_has_device_option() const; public: void clear_device_option(); const ::caffe2::DeviceOption& device_option() const; ::caffe2::DeviceOption* release_device_option(); ::caffe2::DeviceOption* mutable_device_option(); void set_allocated_device_option(::caffe2::DeviceOption* device_option); private: const ::caffe2::DeviceOption& _internal_device_option() const; ::caffe2::DeviceOption* _internal_mutable_device_option(); public: void unsafe_arena_set_allocated_device_option( ::caffe2::DeviceOption* device_option); ::caffe2::DeviceOption* unsafe_arena_release_device_option(); // optional int32 num_workers = 4; bool has_num_workers() const; private: bool _internal_has_num_workers() const; public: void clear_num_workers(); ::PROTOBUF_NAMESPACE_ID::int32 num_workers() const; void set_num_workers(::PROTOBUF_NAMESPACE_ID::int32 value); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_workers() const; void _internal_set_num_workers(::PROTOBUF_NAMESPACE_ID::int32 value); public: // @@protoc_insertion_point(class_scope:caffe2.NetDef) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef > op_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument > arg_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField external_input_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField external_output_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo > partition_info_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_; ::caffe2::DeviceOption* device_option_; ::PROTOBUF_NAMESPACE_ID::int32 num_workers_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API ExecutionStep PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.ExecutionStep) */ { public: inline ExecutionStep() : ExecutionStep(nullptr) {} virtual ~ExecutionStep(); ExecutionStep(const ExecutionStep& from); ExecutionStep(ExecutionStep&& from) noexcept : ExecutionStep() { *this = ::std::move(from); } inline ExecutionStep& operator=(const ExecutionStep& from) { CopyFrom(from); return *this; } inline ExecutionStep& operator=(ExecutionStep&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const ExecutionStep& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const ExecutionStep* internal_default_instance() { return reinterpret_cast( &_ExecutionStep_default_instance_); } static int const kIndexInFileMessages = 16; friend void swap(ExecutionStep& a, ExecutionStep& b) { a.Swap(&b); } inline void Swap(ExecutionStep* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ExecutionStep* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline ExecutionStep* New() const final { return CreateMaybeMessage(nullptr); } ExecutionStep* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const ExecutionStep& from); void MergeFrom(const ExecutionStep& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ExecutionStep* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.ExecutionStep"; } protected: explicit ExecutionStep(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kSubstepFieldNumber = 2, kNetworkFieldNumber = 3, kNameFieldNumber = 1, kCriteriaNetworkFieldNumber = 5, kReportNetFieldNumber = 7, kShouldStopBlobFieldNumber = 9, kNumIterFieldNumber = 4, kReportIntervalFieldNumber = 8, kConcurrentSubstepsFieldNumber = 6, kOnlyOnceFieldNumber = 10, kCreateWorkspaceFieldNumber = 12, kRunEveryMsFieldNumber = 11, kNumConcurrentInstancesFieldNumber = 13, }; // repeated .caffe2.ExecutionStep substep = 2; int substep_size() const; private: int _internal_substep_size() const; public: void clear_substep(); ::caffe2::ExecutionStep* mutable_substep(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >* mutable_substep(); private: const ::caffe2::ExecutionStep& _internal_substep(int index) const; ::caffe2::ExecutionStep* _internal_add_substep(); public: const ::caffe2::ExecutionStep& substep(int index) const; ::caffe2::ExecutionStep* add_substep(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >& substep() const; // repeated string network = 3; int network_size() const; private: int _internal_network_size() const; public: void clear_network(); const std::string& network(int index) const; std::string* mutable_network(int index); void set_network(int index, const std::string& value); void set_network(int index, std::string&& value); void set_network(int index, const char* value); void set_network(int index, const char* value, size_t size); std::string* add_network(); void add_network(const std::string& value); void add_network(std::string&& value); void add_network(const char* value); void add_network(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& network() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_network(); private: const std::string& _internal_network(int index) const; std::string* _internal_add_network(); public: // optional string name = 1; bool has_name() const; private: bool _internal_has_name() const; public: void clear_name(); const std::string& name() const; void set_name(const std::string& value); void set_name(std::string&& value); void set_name(const char* value); void set_name(const char* value, size_t size); std::string* mutable_name(); std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // optional string criteria_network = 5 [deprecated = true]; PROTOBUF_DEPRECATED bool has_criteria_network() const; private: bool _internal_has_criteria_network() const; public: PROTOBUF_DEPRECATED void clear_criteria_network(); PROTOBUF_DEPRECATED const std::string& criteria_network() const; PROTOBUF_DEPRECATED void set_criteria_network(const std::string& value); PROTOBUF_DEPRECATED void set_criteria_network(std::string&& value); PROTOBUF_DEPRECATED void set_criteria_network(const char* value); PROTOBUF_DEPRECATED void set_criteria_network(const char* value, size_t size); PROTOBUF_DEPRECATED std::string* mutable_criteria_network(); PROTOBUF_DEPRECATED std::string* release_criteria_network(); PROTOBUF_DEPRECATED void set_allocated_criteria_network(std::string* criteria_network); private: const std::string& _internal_criteria_network() const; void _internal_set_criteria_network(const std::string& value); std::string* _internal_mutable_criteria_network(); public: // optional string report_net = 7; bool has_report_net() const; private: bool _internal_has_report_net() const; public: void clear_report_net(); const std::string& report_net() const; void set_report_net(const std::string& value); void set_report_net(std::string&& value); void set_report_net(const char* value); void set_report_net(const char* value, size_t size); std::string* mutable_report_net(); std::string* release_report_net(); void set_allocated_report_net(std::string* report_net); private: const std::string& _internal_report_net() const; void _internal_set_report_net(const std::string& value); std::string* _internal_mutable_report_net(); public: // optional string should_stop_blob = 9; bool has_should_stop_blob() const; private: bool _internal_has_should_stop_blob() const; public: void clear_should_stop_blob(); const std::string& should_stop_blob() const; void set_should_stop_blob(const std::string& value); void set_should_stop_blob(std::string&& value); void set_should_stop_blob(const char* value); void set_should_stop_blob(const char* value, size_t size); std::string* mutable_should_stop_blob(); std::string* release_should_stop_blob(); void set_allocated_should_stop_blob(std::string* should_stop_blob); private: const std::string& _internal_should_stop_blob() const; void _internal_set_should_stop_blob(const std::string& value); std::string* _internal_mutable_should_stop_blob(); public: // optional int64 num_iter = 4; bool has_num_iter() const; private: bool _internal_has_num_iter() const; public: void clear_num_iter(); ::PROTOBUF_NAMESPACE_ID::int64 num_iter() const; void set_num_iter(::PROTOBUF_NAMESPACE_ID::int64 value); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_num_iter() const; void _internal_set_num_iter(::PROTOBUF_NAMESPACE_ID::int64 value); public: // optional int32 report_interval = 8; bool has_report_interval() const; private: bool _internal_has_report_interval() const; public: void clear_report_interval(); ::PROTOBUF_NAMESPACE_ID::int32 report_interval() const; void set_report_interval(::PROTOBUF_NAMESPACE_ID::int32 value); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_report_interval() const; void _internal_set_report_interval(::PROTOBUF_NAMESPACE_ID::int32 value); public: // optional bool concurrent_substeps = 6; bool has_concurrent_substeps() const; private: bool _internal_has_concurrent_substeps() const; public: void clear_concurrent_substeps(); bool concurrent_substeps() const; void set_concurrent_substeps(bool value); private: bool _internal_concurrent_substeps() const; void _internal_set_concurrent_substeps(bool value); public: // optional bool only_once = 10; bool has_only_once() const; private: bool _internal_has_only_once() const; public: void clear_only_once(); bool only_once() const; void set_only_once(bool value); private: bool _internal_only_once() const; void _internal_set_only_once(bool value); public: // optional bool create_workspace = 12; bool has_create_workspace() const; private: bool _internal_has_create_workspace() const; public: void clear_create_workspace(); bool create_workspace() const; void set_create_workspace(bool value); private: bool _internal_create_workspace() const; void _internal_set_create_workspace(bool value); public: // optional int64 run_every_ms = 11; bool has_run_every_ms() const; private: bool _internal_has_run_every_ms() const; public: void clear_run_every_ms(); ::PROTOBUF_NAMESPACE_ID::int64 run_every_ms() const; void set_run_every_ms(::PROTOBUF_NAMESPACE_ID::int64 value); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_run_every_ms() const; void _internal_set_run_every_ms(::PROTOBUF_NAMESPACE_ID::int64 value); public: // optional int32 num_concurrent_instances = 13; bool has_num_concurrent_instances() const; private: bool _internal_has_num_concurrent_instances() const; public: void clear_num_concurrent_instances(); ::PROTOBUF_NAMESPACE_ID::int32 num_concurrent_instances() const; void set_num_concurrent_instances(::PROTOBUF_NAMESPACE_ID::int32 value); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_concurrent_instances() const; void _internal_set_num_concurrent_instances(::PROTOBUF_NAMESPACE_ID::int32 value); public: // @@protoc_insertion_point(class_scope:caffe2.ExecutionStep) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep > substep_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField network_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr criteria_network_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr report_net_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr should_stop_blob_; ::PROTOBUF_NAMESPACE_ID::int64 num_iter_; ::PROTOBUF_NAMESPACE_ID::int32 report_interval_; bool concurrent_substeps_; bool only_once_; bool create_workspace_; ::PROTOBUF_NAMESPACE_ID::int64 run_every_ms_; ::PROTOBUF_NAMESPACE_ID::int32 num_concurrent_instances_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API PlanDef PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.PlanDef) */ { public: inline PlanDef() : PlanDef(nullptr) {} virtual ~PlanDef(); PlanDef(const PlanDef& from); PlanDef(PlanDef&& from) noexcept : PlanDef() { *this = ::std::move(from); } inline PlanDef& operator=(const PlanDef& from) { CopyFrom(from); return *this; } inline PlanDef& operator=(PlanDef&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const PlanDef& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const PlanDef* internal_default_instance() { return reinterpret_cast( &_PlanDef_default_instance_); } static int const kIndexInFileMessages = 17; friend void swap(PlanDef& a, PlanDef& b) { a.Swap(&b); } inline void Swap(PlanDef* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(PlanDef* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline PlanDef* New() const final { return CreateMaybeMessage(nullptr); } PlanDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const PlanDef& from); void MergeFrom(const PlanDef& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(PlanDef* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.PlanDef"; } protected: explicit PlanDef(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kNetworkFieldNumber = 2, kExecutionStepFieldNumber = 3, kNameFieldNumber = 1, }; // repeated .caffe2.NetDef network = 2; int network_size() const; private: int _internal_network_size() const; public: void clear_network(); ::caffe2::NetDef* mutable_network(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >* mutable_network(); private: const ::caffe2::NetDef& _internal_network(int index) const; ::caffe2::NetDef* _internal_add_network(); public: const ::caffe2::NetDef& network(int index) const; ::caffe2::NetDef* add_network(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >& network() const; // repeated .caffe2.ExecutionStep execution_step = 3; int execution_step_size() const; private: int _internal_execution_step_size() const; public: void clear_execution_step(); ::caffe2::ExecutionStep* mutable_execution_step(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >* mutable_execution_step(); private: const ::caffe2::ExecutionStep& _internal_execution_step(int index) const; ::caffe2::ExecutionStep* _internal_add_execution_step(); public: const ::caffe2::ExecutionStep& execution_step(int index) const; ::caffe2::ExecutionStep* add_execution_step(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >& execution_step() const; // optional string name = 1; bool has_name() const; private: bool _internal_has_name() const; public: void clear_name(); const std::string& name() const; void set_name(const std::string& value); void set_name(std::string&& value); void set_name(const char* value); void set_name(const char* value, size_t size); std::string* mutable_name(); std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // @@protoc_insertion_point(class_scope:caffe2.PlanDef) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef > network_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep > execution_step_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API BlobProto PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.BlobProto) */ { public: inline BlobProto() : BlobProto(nullptr) {} virtual ~BlobProto(); BlobProto(const BlobProto& from); BlobProto(BlobProto&& from) noexcept : BlobProto() { *this = ::std::move(from); } inline BlobProto& operator=(const BlobProto& from) { CopyFrom(from); return *this; } inline BlobProto& operator=(BlobProto&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const BlobProto& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const BlobProto* internal_default_instance() { return reinterpret_cast( &_BlobProto_default_instance_); } static int const kIndexInFileMessages = 18; friend void swap(BlobProto& a, BlobProto& b) { a.Swap(&b); } inline void Swap(BlobProto* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BlobProto* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline BlobProto* New() const final { return CreateMaybeMessage(nullptr); } BlobProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const BlobProto& from); void MergeFrom(const BlobProto& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(BlobProto* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.BlobProto"; } protected: explicit BlobProto(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kNameFieldNumber = 1, kTypeFieldNumber = 2, kContentFieldNumber = 4, kTensorFieldNumber = 3, kQtensorFieldNumber = 5, kContentNumChunksFieldNumber = 6, kContentChunkIdFieldNumber = 7, }; // optional string name = 1; bool has_name() const; private: bool _internal_has_name() const; public: void clear_name(); const std::string& name() const; void set_name(const std::string& value); void set_name(std::string&& value); void set_name(const char* value); void set_name(const char* value, size_t size); std::string* mutable_name(); std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // optional string type = 2; bool has_type() const; private: bool _internal_has_type() const; public: void clear_type(); const std::string& type() const; void set_type(const std::string& value); void set_type(std::string&& value); void set_type(const char* value); void set_type(const char* value, size_t size); std::string* mutable_type(); std::string* release_type(); void set_allocated_type(std::string* type); private: const std::string& _internal_type() const; void _internal_set_type(const std::string& value); std::string* _internal_mutable_type(); public: // optional bytes content = 4; bool has_content() const; private: bool _internal_has_content() const; public: void clear_content(); const std::string& content() const; void set_content(const std::string& value); void set_content(std::string&& value); void set_content(const char* value); void set_content(const void* value, size_t size); std::string* mutable_content(); std::string* release_content(); void set_allocated_content(std::string* content); private: const std::string& _internal_content() const; void _internal_set_content(const std::string& value); std::string* _internal_mutable_content(); public: // optional .caffe2.TensorProto tensor = 3; bool has_tensor() const; private: bool _internal_has_tensor() const; public: void clear_tensor(); const ::caffe2::TensorProto& tensor() const; ::caffe2::TensorProto* release_tensor(); ::caffe2::TensorProto* mutable_tensor(); void set_allocated_tensor(::caffe2::TensorProto* tensor); private: const ::caffe2::TensorProto& _internal_tensor() const; ::caffe2::TensorProto* _internal_mutable_tensor(); public: void unsafe_arena_set_allocated_tensor( ::caffe2::TensorProto* tensor); ::caffe2::TensorProto* unsafe_arena_release_tensor(); // optional .caffe2.QTensorProto qtensor = 5; bool has_qtensor() const; private: bool _internal_has_qtensor() const; public: void clear_qtensor(); const ::caffe2::QTensorProto& qtensor() const; ::caffe2::QTensorProto* release_qtensor(); ::caffe2::QTensorProto* mutable_qtensor(); void set_allocated_qtensor(::caffe2::QTensorProto* qtensor); private: const ::caffe2::QTensorProto& _internal_qtensor() const; ::caffe2::QTensorProto* _internal_mutable_qtensor(); public: void unsafe_arena_set_allocated_qtensor( ::caffe2::QTensorProto* qtensor); ::caffe2::QTensorProto* unsafe_arena_release_qtensor(); // optional int32 content_num_chunks = 6; bool has_content_num_chunks() const; private: bool _internal_has_content_num_chunks() const; public: void clear_content_num_chunks(); ::PROTOBUF_NAMESPACE_ID::int32 content_num_chunks() const; void set_content_num_chunks(::PROTOBUF_NAMESPACE_ID::int32 value); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_content_num_chunks() const; void _internal_set_content_num_chunks(::PROTOBUF_NAMESPACE_ID::int32 value); public: // optional int32 content_chunk_id = 7; bool has_content_chunk_id() const; private: bool _internal_has_content_chunk_id() const; public: void clear_content_chunk_id(); ::PROTOBUF_NAMESPACE_ID::int32 content_chunk_id() const; void set_content_chunk_id(::PROTOBUF_NAMESPACE_ID::int32 value); private: ::PROTOBUF_NAMESPACE_ID::int32 _internal_content_chunk_id() const; void _internal_set_content_chunk_id(::PROTOBUF_NAMESPACE_ID::int32 value); public: // @@protoc_insertion_point(class_scope:caffe2.BlobProto) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_; ::caffe2::TensorProto* tensor_; ::caffe2::QTensorProto* qtensor_; ::PROTOBUF_NAMESPACE_ID::int32 content_num_chunks_; ::PROTOBUF_NAMESPACE_ID::int32 content_chunk_id_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API DBReaderProto PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.DBReaderProto) */ { public: inline DBReaderProto() : DBReaderProto(nullptr) {} virtual ~DBReaderProto(); DBReaderProto(const DBReaderProto& from); DBReaderProto(DBReaderProto&& from) noexcept : DBReaderProto() { *this = ::std::move(from); } inline DBReaderProto& operator=(const DBReaderProto& from) { CopyFrom(from); return *this; } inline DBReaderProto& operator=(DBReaderProto&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const DBReaderProto& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const DBReaderProto* internal_default_instance() { return reinterpret_cast( &_DBReaderProto_default_instance_); } static int const kIndexInFileMessages = 19; friend void swap(DBReaderProto& a, DBReaderProto& b) { a.Swap(&b); } inline void Swap(DBReaderProto* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DBReaderProto* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline DBReaderProto* New() const final { return CreateMaybeMessage(nullptr); } DBReaderProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const DBReaderProto& from); void MergeFrom(const DBReaderProto& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DBReaderProto* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.DBReaderProto"; } protected: explicit DBReaderProto(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kNameFieldNumber = 1, kSourceFieldNumber = 2, kDbTypeFieldNumber = 3, kKeyFieldNumber = 4, }; // optional string name = 1; bool has_name() const; private: bool _internal_has_name() const; public: void clear_name(); const std::string& name() const; void set_name(const std::string& value); void set_name(std::string&& value); void set_name(const char* value); void set_name(const char* value, size_t size); std::string* mutable_name(); std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // optional string source = 2; bool has_source() const; private: bool _internal_has_source() const; public: void clear_source(); const std::string& source() const; void set_source(const std::string& value); void set_source(std::string&& value); void set_source(const char* value); void set_source(const char* value, size_t size); std::string* mutable_source(); std::string* release_source(); void set_allocated_source(std::string* source); private: const std::string& _internal_source() const; void _internal_set_source(const std::string& value); std::string* _internal_mutable_source(); public: // optional string db_type = 3; bool has_db_type() const; private: bool _internal_has_db_type() const; public: void clear_db_type(); const std::string& db_type() const; void set_db_type(const std::string& value); void set_db_type(std::string&& value); void set_db_type(const char* value); void set_db_type(const char* value, size_t size); std::string* mutable_db_type(); std::string* release_db_type(); void set_allocated_db_type(std::string* db_type); private: const std::string& _internal_db_type() const; void _internal_set_db_type(const std::string& value); std::string* _internal_mutable_db_type(); public: // optional string key = 4; bool has_key() const; private: bool _internal_has_key() const; public: void clear_key(); const std::string& key() const; void set_key(const std::string& value); void set_key(std::string&& value); void set_key(const char* value); void set_key(const char* value, size_t size); std::string* mutable_key(); std::string* release_key(); void set_allocated_key(std::string* key); private: const std::string& _internal_key() const; void _internal_set_key(const std::string& value); std::string* _internal_mutable_key(); public: // @@protoc_insertion_point(class_scope:caffe2.DBReaderProto) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr db_type_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API BlobSerializationOptions PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.BlobSerializationOptions) */ { public: inline BlobSerializationOptions() : BlobSerializationOptions(nullptr) {} virtual ~BlobSerializationOptions(); BlobSerializationOptions(const BlobSerializationOptions& from); BlobSerializationOptions(BlobSerializationOptions&& from) noexcept : BlobSerializationOptions() { *this = ::std::move(from); } inline BlobSerializationOptions& operator=(const BlobSerializationOptions& from) { CopyFrom(from); return *this; } inline BlobSerializationOptions& operator=(BlobSerializationOptions&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const BlobSerializationOptions& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const BlobSerializationOptions* internal_default_instance() { return reinterpret_cast( &_BlobSerializationOptions_default_instance_); } static int const kIndexInFileMessages = 20; friend void swap(BlobSerializationOptions& a, BlobSerializationOptions& b) { a.Swap(&b); } inline void Swap(BlobSerializationOptions* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(BlobSerializationOptions* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline BlobSerializationOptions* New() const final { return CreateMaybeMessage(nullptr); } BlobSerializationOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const BlobSerializationOptions& from); void MergeFrom(const BlobSerializationOptions& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(BlobSerializationOptions* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.BlobSerializationOptions"; } protected: explicit BlobSerializationOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- typedef BlobSerializationOptions_FloatFormat FloatFormat; static FloatFormat const FLOAT_DEFAULT = BlobSerializationOptions_FloatFormat_FLOAT_DEFAULT; static FloatFormat const FLOAT_PROTOBUF = BlobSerializationOptions_FloatFormat_FLOAT_PROTOBUF; static FloatFormat const FLOAT_BFLOAT16 = BlobSerializationOptions_FloatFormat_FLOAT_BFLOAT16; static inline bool FloatFormat_IsValid(int value) { return BlobSerializationOptions_FloatFormat_IsValid(value); } static FloatFormat const FloatFormat_MIN = BlobSerializationOptions_FloatFormat_FloatFormat_MIN; static FloatFormat const FloatFormat_MAX = BlobSerializationOptions_FloatFormat_FloatFormat_MAX; static int const FloatFormat_ARRAYSIZE = BlobSerializationOptions_FloatFormat_FloatFormat_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FloatFormat_descriptor() { return BlobSerializationOptions_FloatFormat_descriptor(); } template static inline const std::string& FloatFormat_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function FloatFormat_Name."); return BlobSerializationOptions_FloatFormat_Name(enum_t_value); } static inline bool FloatFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FloatFormat* value) { return BlobSerializationOptions_FloatFormat_Parse(name, value); } // accessors ------------------------------------------------------- enum : int { kBlobNameRegexFieldNumber = 1, kChunkSizeFieldNumber = 2, kFloatFormatFieldNumber = 3, }; // optional string blob_name_regex = 1; bool has_blob_name_regex() const; private: bool _internal_has_blob_name_regex() const; public: void clear_blob_name_regex(); const std::string& blob_name_regex() const; void set_blob_name_regex(const std::string& value); void set_blob_name_regex(std::string&& value); void set_blob_name_regex(const char* value); void set_blob_name_regex(const char* value, size_t size); std::string* mutable_blob_name_regex(); std::string* release_blob_name_regex(); void set_allocated_blob_name_regex(std::string* blob_name_regex); private: const std::string& _internal_blob_name_regex() const; void _internal_set_blob_name_regex(const std::string& value); std::string* _internal_mutable_blob_name_regex(); public: // optional int64 chunk_size = 2; bool has_chunk_size() const; private: bool _internal_has_chunk_size() const; public: void clear_chunk_size(); ::PROTOBUF_NAMESPACE_ID::int64 chunk_size() const; void set_chunk_size(::PROTOBUF_NAMESPACE_ID::int64 value); private: ::PROTOBUF_NAMESPACE_ID::int64 _internal_chunk_size() const; void _internal_set_chunk_size(::PROTOBUF_NAMESPACE_ID::int64 value); public: // optional .caffe2.BlobSerializationOptions.FloatFormat float_format = 3; bool has_float_format() const; private: bool _internal_has_float_format() const; public: void clear_float_format(); ::caffe2::BlobSerializationOptions_FloatFormat float_format() const; void set_float_format(::caffe2::BlobSerializationOptions_FloatFormat value); private: ::caffe2::BlobSerializationOptions_FloatFormat _internal_float_format() const; void _internal_set_float_format(::caffe2::BlobSerializationOptions_FloatFormat value); public: // @@protoc_insertion_point(class_scope:caffe2.BlobSerializationOptions) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blob_name_regex_; ::PROTOBUF_NAMESPACE_ID::int64 chunk_size_; int float_format_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // ------------------------------------------------------------------- class TORCH_API SerializationOptions PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.SerializationOptions) */ { public: inline SerializationOptions() : SerializationOptions(nullptr) {} virtual ~SerializationOptions(); SerializationOptions(const SerializationOptions& from); SerializationOptions(SerializationOptions&& from) noexcept : SerializationOptions() { *this = ::std::move(from); } inline SerializationOptions& operator=(const SerializationOptions& from) { CopyFrom(from); return *this; } inline SerializationOptions& operator=(SerializationOptions&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { CopyFrom(from); } return *this; } inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const { return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance); } inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() { return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return GetMetadataStatic().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } static const SerializationOptions& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY static inline const SerializationOptions* internal_default_instance() { return reinterpret_cast( &_SerializationOptions_default_instance_); } static int const kIndexInFileMessages = 21; friend void swap(SerializationOptions& a, SerializationOptions& b) { a.Swap(&b); } inline void Swap(SerializationOptions* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(SerializationOptions* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); } // implements Message ---------------------------------------------- inline SerializationOptions* New() const final { return CreateMaybeMessage(nullptr); } SerializationOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void CopyFrom(const SerializationOptions& from); void MergeFrom(const SerializationOptions& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SerializationOptions* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "caffe2.SerializationOptions"; } protected: explicit SerializationOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; private: static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto); return ::descriptor_table_caffe2_2fproto_2fcaffe2_2eproto.file_level_metadata[kIndexInFileMessages]; } public: // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kOptionsFieldNumber = 1, }; // repeated .caffe2.BlobSerializationOptions options = 1; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); ::caffe2::BlobSerializationOptions* mutable_options(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions >* mutable_options(); private: const ::caffe2::BlobSerializationOptions& _internal_options(int index) const; ::caffe2::BlobSerializationOptions* _internal_add_options(); public: const ::caffe2::BlobSerializationOptions& options(int index) const; ::caffe2::BlobSerializationOptions* add_options(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions >& options() const; // @@protoc_insertion_point(class_scope:caffe2.SerializationOptions) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions > options_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_caffe2_2fproto_2fcaffe2_2eproto; }; // =================================================================== // =================================================================== #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ // TensorProto_Segment // required int64 begin = 1; inline bool TensorProto_Segment::_internal_has_begin() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool TensorProto_Segment::has_begin() const { return _internal_has_begin(); } inline void TensorProto_Segment::clear_begin() { begin_ = PROTOBUF_LONGLONG(0); _has_bits_[0] &= ~0x00000001u; } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::_internal_begin() const { return begin_; } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::begin() const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.Segment.begin) return _internal_begin(); } inline void TensorProto_Segment::_internal_set_begin(::PROTOBUF_NAMESPACE_ID::int64 value) { _has_bits_[0] |= 0x00000001u; begin_ = value; } inline void TensorProto_Segment::set_begin(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_begin(value); // @@protoc_insertion_point(field_set:caffe2.TensorProto.Segment.begin) } // required int64 end = 2; inline bool TensorProto_Segment::_internal_has_end() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool TensorProto_Segment::has_end() const { return _internal_has_end(); } inline void TensorProto_Segment::clear_end() { end_ = PROTOBUF_LONGLONG(0); _has_bits_[0] &= ~0x00000002u; } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::_internal_end() const { return end_; } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto_Segment::end() const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.Segment.end) return _internal_end(); } inline void TensorProto_Segment::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int64 value) { _has_bits_[0] |= 0x00000002u; end_ = value; } inline void TensorProto_Segment::set_end(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_end(value); // @@protoc_insertion_point(field_set:caffe2.TensorProto.Segment.end) } // ------------------------------------------------------------------- // TensorProto // repeated int64 dims = 1; inline int TensorProto::_internal_dims_size() const { return dims_.size(); } inline int TensorProto::dims_size() const { return _internal_dims_size(); } inline void TensorProto::clear_dims() { dims_.Clear(); } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::_internal_dims(int index) const { return dims_.Get(index); } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::dims(int index) const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.dims) return _internal_dims(index); } inline void TensorProto::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { dims_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.TensorProto.dims) } inline void TensorProto::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) { dims_.Add(value); } inline void TensorProto::add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_add_dims(value); // @@protoc_insertion_point(field_add:caffe2.TensorProto.dims) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& TensorProto::_internal_dims() const { return dims_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& TensorProto::dims() const { // @@protoc_insertion_point(field_list:caffe2.TensorProto.dims) return _internal_dims(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* TensorProto::_internal_mutable_dims() { return &dims_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* TensorProto::mutable_dims() { // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.dims) return _internal_mutable_dims(); } // optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT]; inline bool TensorProto::_internal_has_data_type() const { bool value = (_has_bits_[0] & 0x00000040u) != 0; return value; } inline bool TensorProto::has_data_type() const { return _internal_has_data_type(); } inline void TensorProto::clear_data_type() { data_type_ = 1; _has_bits_[0] &= ~0x00000040u; } inline ::caffe2::TensorProto_DataType TensorProto::_internal_data_type() const { return static_cast< ::caffe2::TensorProto_DataType >(data_type_); } inline ::caffe2::TensorProto_DataType TensorProto::data_type() const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.data_type) return _internal_data_type(); } inline void TensorProto::_internal_set_data_type(::caffe2::TensorProto_DataType value) { assert(::caffe2::TensorProto_DataType_IsValid(value)); _has_bits_[0] |= 0x00000040u; data_type_ = value; } inline void TensorProto::set_data_type(::caffe2::TensorProto_DataType value) { _internal_set_data_type(value); // @@protoc_insertion_point(field_set:caffe2.TensorProto.data_type) } // optional uint32 data_format = 15 [default = 0]; inline bool TensorProto::_internal_has_data_format() const { bool value = (_has_bits_[0] & 0x00000020u) != 0; return value; } inline bool TensorProto::has_data_format() const { return _internal_has_data_format(); } inline void TensorProto::clear_data_format() { data_format_ = 0u; _has_bits_[0] &= ~0x00000020u; } inline ::PROTOBUF_NAMESPACE_ID::uint32 TensorProto::_internal_data_format() const { return data_format_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 TensorProto::data_format() const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.data_format) return _internal_data_format(); } inline void TensorProto::_internal_set_data_format(::PROTOBUF_NAMESPACE_ID::uint32 value) { _has_bits_[0] |= 0x00000020u; data_format_ = value; } inline void TensorProto::set_data_format(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_data_format(value); // @@protoc_insertion_point(field_set:caffe2.TensorProto.data_format) } // repeated float float_data = 3 [packed = true]; inline int TensorProto::_internal_float_data_size() const { return float_data_.size(); } inline int TensorProto::float_data_size() const { return _internal_float_data_size(); } inline void TensorProto::clear_float_data() { float_data_.Clear(); } inline float TensorProto::_internal_float_data(int index) const { return float_data_.Get(index); } inline float TensorProto::float_data(int index) const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.float_data) return _internal_float_data(index); } inline void TensorProto::set_float_data(int index, float value) { float_data_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.TensorProto.float_data) } inline void TensorProto::_internal_add_float_data(float value) { float_data_.Add(value); } inline void TensorProto::add_float_data(float value) { _internal_add_float_data(value); // @@protoc_insertion_point(field_add:caffe2.TensorProto.float_data) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& TensorProto::_internal_float_data() const { return float_data_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& TensorProto::float_data() const { // @@protoc_insertion_point(field_list:caffe2.TensorProto.float_data) return _internal_float_data(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* TensorProto::_internal_mutable_float_data() { return &float_data_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* TensorProto::mutable_float_data() { // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.float_data) return _internal_mutable_float_data(); } // repeated int32 int32_data = 4 [packed = true]; inline int TensorProto::_internal_int32_data_size() const { return int32_data_.size(); } inline int TensorProto::int32_data_size() const { return _internal_int32_data_size(); } inline void TensorProto::clear_int32_data() { int32_data_.Clear(); } inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::_internal_int32_data(int index) const { return int32_data_.Get(index); } inline ::PROTOBUF_NAMESPACE_ID::int32 TensorProto::int32_data(int index) const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.int32_data) return _internal_int32_data(index); } inline void TensorProto::set_int32_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { int32_data_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.TensorProto.int32_data) } inline void TensorProto::_internal_add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value) { int32_data_.Add(value); } inline void TensorProto::add_int32_data(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_add_int32_data(value); // @@protoc_insertion_point(field_add:caffe2.TensorProto.int32_data) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& TensorProto::_internal_int32_data() const { return int32_data_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& TensorProto::int32_data() const { // @@protoc_insertion_point(field_list:caffe2.TensorProto.int32_data) return _internal_int32_data(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* TensorProto::_internal_mutable_int32_data() { return &int32_data_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* TensorProto::mutable_int32_data() { // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.int32_data) return _internal_mutable_int32_data(); } // optional bytes byte_data = 5; inline bool TensorProto::_internal_has_byte_data() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool TensorProto::has_byte_data() const { return _internal_has_byte_data(); } inline void TensorProto::clear_byte_data() { byte_data_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& TensorProto::byte_data() const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.byte_data) return _internal_byte_data(); } inline void TensorProto::set_byte_data(const std::string& value) { _internal_set_byte_data(value); // @@protoc_insertion_point(field_set:caffe2.TensorProto.byte_data) } inline std::string* TensorProto::mutable_byte_data() { // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.byte_data) return _internal_mutable_byte_data(); } inline const std::string& TensorProto::_internal_byte_data() const { return byte_data_.Get(); } inline void TensorProto::_internal_set_byte_data(const std::string& value) { _has_bits_[0] |= 0x00000001u; byte_data_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void TensorProto::set_byte_data(std::string&& value) { _has_bits_[0] |= 0x00000001u; byte_data_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorProto.byte_data) } inline void TensorProto::set_byte_data(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; byte_data_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.byte_data) } inline void TensorProto::set_byte_data(const void* value, size_t size) { _has_bits_[0] |= 0x00000001u; byte_data_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.byte_data) } inline std::string* TensorProto::_internal_mutable_byte_data() { _has_bits_[0] |= 0x00000001u; return byte_data_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* TensorProto::release_byte_data() { // @@protoc_insertion_point(field_release:caffe2.TensorProto.byte_data) if (!_internal_has_byte_data()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return byte_data_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void TensorProto::set_allocated_byte_data(std::string* byte_data) { if (byte_data != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } byte_data_.SetAllocated(&GetEmptyStringAlreadyInited(), byte_data, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.byte_data) } // repeated bytes string_data = 6; inline int TensorProto::_internal_string_data_size() const { return string_data_.size(); } inline int TensorProto::string_data_size() const { return _internal_string_data_size(); } inline void TensorProto::clear_string_data() { string_data_.Clear(); } inline std::string* TensorProto::add_string_data() { // @@protoc_insertion_point(field_add_mutable:caffe2.TensorProto.string_data) return _internal_add_string_data(); } inline const std::string& TensorProto::_internal_string_data(int index) const { return string_data_.Get(index); } inline const std::string& TensorProto::string_data(int index) const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.string_data) return _internal_string_data(index); } inline std::string* TensorProto::mutable_string_data(int index) { // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.string_data) return string_data_.Mutable(index); } inline void TensorProto::set_string_data(int index, const std::string& value) { // @@protoc_insertion_point(field_set:caffe2.TensorProto.string_data) string_data_.Mutable(index)->assign(value); } inline void TensorProto::set_string_data(int index, std::string&& value) { // @@protoc_insertion_point(field_set:caffe2.TensorProto.string_data) string_data_.Mutable(index)->assign(std::move(value)); } inline void TensorProto::set_string_data(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); string_data_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.string_data) } inline void TensorProto::set_string_data(int index, const void* value, size_t size) { string_data_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.string_data) } inline std::string* TensorProto::_internal_add_string_data() { return string_data_.Add(); } inline void TensorProto::add_string_data(const std::string& value) { string_data_.Add()->assign(value); // @@protoc_insertion_point(field_add:caffe2.TensorProto.string_data) } inline void TensorProto::add_string_data(std::string&& value) { string_data_.Add(std::move(value)); // @@protoc_insertion_point(field_add:caffe2.TensorProto.string_data) } inline void TensorProto::add_string_data(const char* value) { GOOGLE_DCHECK(value != nullptr); string_data_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:caffe2.TensorProto.string_data) } inline void TensorProto::add_string_data(const void* value, size_t size) { string_data_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:caffe2.TensorProto.string_data) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& TensorProto::string_data() const { // @@protoc_insertion_point(field_list:caffe2.TensorProto.string_data) return string_data_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* TensorProto::mutable_string_data() { // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.string_data) return &string_data_; } // repeated double double_data = 9 [packed = true]; inline int TensorProto::_internal_double_data_size() const { return double_data_.size(); } inline int TensorProto::double_data_size() const { return _internal_double_data_size(); } inline void TensorProto::clear_double_data() { double_data_.Clear(); } inline double TensorProto::_internal_double_data(int index) const { return double_data_.Get(index); } inline double TensorProto::double_data(int index) const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.double_data) return _internal_double_data(index); } inline void TensorProto::set_double_data(int index, double value) { double_data_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.TensorProto.double_data) } inline void TensorProto::_internal_add_double_data(double value) { double_data_.Add(value); } inline void TensorProto::add_double_data(double value) { _internal_add_double_data(value); // @@protoc_insertion_point(field_add:caffe2.TensorProto.double_data) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& TensorProto::_internal_double_data() const { return double_data_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& TensorProto::double_data() const { // @@protoc_insertion_point(field_list:caffe2.TensorProto.double_data) return _internal_double_data(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* TensorProto::_internal_mutable_double_data() { return &double_data_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* TensorProto::mutable_double_data() { // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.double_data) return _internal_mutable_double_data(); } // repeated int64 int64_data = 10 [packed = true]; inline int TensorProto::_internal_int64_data_size() const { return int64_data_.size(); } inline int TensorProto::int64_data_size() const { return _internal_int64_data_size(); } inline void TensorProto::clear_int64_data() { int64_data_.Clear(); } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::_internal_int64_data(int index) const { return int64_data_.Get(index); } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorProto::int64_data(int index) const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.int64_data) return _internal_int64_data(index); } inline void TensorProto::set_int64_data(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { int64_data_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.TensorProto.int64_data) } inline void TensorProto::_internal_add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value) { int64_data_.Add(value); } inline void TensorProto::add_int64_data(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_add_int64_data(value); // @@protoc_insertion_point(field_add:caffe2.TensorProto.int64_data) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& TensorProto::_internal_int64_data() const { return int64_data_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& TensorProto::int64_data() const { // @@protoc_insertion_point(field_list:caffe2.TensorProto.int64_data) return _internal_int64_data(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* TensorProto::_internal_mutable_int64_data() { return &int64_data_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* TensorProto::mutable_int64_data() { // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProto.int64_data) return _internal_mutable_int64_data(); } // optional bytes raw_data = 13; inline bool TensorProto::_internal_has_raw_data() const { bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool TensorProto::has_raw_data() const { return _internal_has_raw_data(); } inline void TensorProto::clear_raw_data() { raw_data_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000004u; } inline const std::string& TensorProto::raw_data() const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.raw_data) return _internal_raw_data(); } inline void TensorProto::set_raw_data(const std::string& value) { _internal_set_raw_data(value); // @@protoc_insertion_point(field_set:caffe2.TensorProto.raw_data) } inline std::string* TensorProto::mutable_raw_data() { // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.raw_data) return _internal_mutable_raw_data(); } inline const std::string& TensorProto::_internal_raw_data() const { return raw_data_.Get(); } inline void TensorProto::_internal_set_raw_data(const std::string& value) { _has_bits_[0] |= 0x00000004u; raw_data_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void TensorProto::set_raw_data(std::string&& value) { _has_bits_[0] |= 0x00000004u; raw_data_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorProto.raw_data) } inline void TensorProto::set_raw_data(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000004u; raw_data_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.raw_data) } inline void TensorProto::set_raw_data(const void* value, size_t size) { _has_bits_[0] |= 0x00000004u; raw_data_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.raw_data) } inline std::string* TensorProto::_internal_mutable_raw_data() { _has_bits_[0] |= 0x00000004u; return raw_data_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* TensorProto::release_raw_data() { // @@protoc_insertion_point(field_release:caffe2.TensorProto.raw_data) if (!_internal_has_raw_data()) { return nullptr; } _has_bits_[0] &= ~0x00000004u; return raw_data_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void TensorProto::set_allocated_raw_data(std::string* raw_data) { if (raw_data != nullptr) { _has_bits_[0] |= 0x00000004u; } else { _has_bits_[0] &= ~0x00000004u; } raw_data_.SetAllocated(&GetEmptyStringAlreadyInited(), raw_data, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.raw_data) } // optional string name = 7; inline bool TensorProto::_internal_has_name() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool TensorProto::has_name() const { return _internal_has_name(); } inline void TensorProto::clear_name() { name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000002u; } inline const std::string& TensorProto::name() const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.name) return _internal_name(); } inline void TensorProto::set_name(const std::string& value) { _internal_set_name(value); // @@protoc_insertion_point(field_set:caffe2.TensorProto.name) } inline std::string* TensorProto::mutable_name() { // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.name) return _internal_mutable_name(); } inline const std::string& TensorProto::_internal_name() const { return name_.Get(); } inline void TensorProto::_internal_set_name(const std::string& value) { _has_bits_[0] |= 0x00000002u; name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void TensorProto::set_name(std::string&& value) { _has_bits_[0] |= 0x00000002u; name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorProto.name) } inline void TensorProto::set_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000002u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.TensorProto.name) } inline void TensorProto::set_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000002u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.TensorProto.name) } inline std::string* TensorProto::_internal_mutable_name() { _has_bits_[0] |= 0x00000002u; return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* TensorProto::release_name() { // @@protoc_insertion_point(field_release:caffe2.TensorProto.name) if (!_internal_has_name()) { return nullptr; } _has_bits_[0] &= ~0x00000002u; return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void TensorProto::set_allocated_name(std::string* name) { if (name != nullptr) { _has_bits_[0] |= 0x00000002u; } else { _has_bits_[0] &= ~0x00000002u; } name_.SetAllocated(&GetEmptyStringAlreadyInited(), name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.name) } // optional .caffe2.DeviceOption device_detail = 8; inline bool TensorProto::_internal_has_device_detail() const { bool value = (_has_bits_[0] & 0x00000008u) != 0; PROTOBUF_ASSUME(!value || device_detail_ != nullptr); return value; } inline bool TensorProto::has_device_detail() const { return _internal_has_device_detail(); } inline void TensorProto::clear_device_detail() { if (device_detail_ != nullptr) device_detail_->Clear(); _has_bits_[0] &= ~0x00000008u; } inline const ::caffe2::DeviceOption& TensorProto::_internal_device_detail() const { const ::caffe2::DeviceOption* p = device_detail_; return p != nullptr ? *p : *reinterpret_cast( &::caffe2::_DeviceOption_default_instance_); } inline const ::caffe2::DeviceOption& TensorProto::device_detail() const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.device_detail) return _internal_device_detail(); } inline void TensorProto::unsafe_arena_set_allocated_device_detail( ::caffe2::DeviceOption* device_detail) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_detail_); } device_detail_ = device_detail; if (device_detail) { _has_bits_[0] |= 0x00000008u; } else { _has_bits_[0] &= ~0x00000008u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.TensorProto.device_detail) } inline ::caffe2::DeviceOption* TensorProto::release_device_detail() { _has_bits_[0] &= ~0x00000008u; ::caffe2::DeviceOption* temp = device_detail_; device_detail_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } inline ::caffe2::DeviceOption* TensorProto::unsafe_arena_release_device_detail() { // @@protoc_insertion_point(field_release:caffe2.TensorProto.device_detail) _has_bits_[0] &= ~0x00000008u; ::caffe2::DeviceOption* temp = device_detail_; device_detail_ = nullptr; return temp; } inline ::caffe2::DeviceOption* TensorProto::_internal_mutable_device_detail() { _has_bits_[0] |= 0x00000008u; if (device_detail_ == nullptr) { auto* p = CreateMaybeMessage<::caffe2::DeviceOption>(GetArena()); device_detail_ = p; } return device_detail_; } inline ::caffe2::DeviceOption* TensorProto::mutable_device_detail() { // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.device_detail) return _internal_mutable_device_detail(); } inline void TensorProto::set_allocated_device_detail(::caffe2::DeviceOption* device_detail) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete device_detail_; } if (device_detail) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(device_detail); if (message_arena != submessage_arena) { device_detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, device_detail, submessage_arena); } _has_bits_[0] |= 0x00000008u; } else { _has_bits_[0] &= ~0x00000008u; } device_detail_ = device_detail; // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.device_detail) } // optional .caffe2.TensorProto.Segment segment = 11; inline bool TensorProto::_internal_has_segment() const { bool value = (_has_bits_[0] & 0x00000010u) != 0; PROTOBUF_ASSUME(!value || segment_ != nullptr); return value; } inline bool TensorProto::has_segment() const { return _internal_has_segment(); } inline void TensorProto::clear_segment() { if (segment_ != nullptr) segment_->Clear(); _has_bits_[0] &= ~0x00000010u; } inline const ::caffe2::TensorProto_Segment& TensorProto::_internal_segment() const { const ::caffe2::TensorProto_Segment* p = segment_; return p != nullptr ? *p : *reinterpret_cast( &::caffe2::_TensorProto_Segment_default_instance_); } inline const ::caffe2::TensorProto_Segment& TensorProto::segment() const { // @@protoc_insertion_point(field_get:caffe2.TensorProto.segment) return _internal_segment(); } inline void TensorProto::unsafe_arena_set_allocated_segment( ::caffe2::TensorProto_Segment* segment) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(segment_); } segment_ = segment; if (segment) { _has_bits_[0] |= 0x00000010u; } else { _has_bits_[0] &= ~0x00000010u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.TensorProto.segment) } inline ::caffe2::TensorProto_Segment* TensorProto::release_segment() { _has_bits_[0] &= ~0x00000010u; ::caffe2::TensorProto_Segment* temp = segment_; segment_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } inline ::caffe2::TensorProto_Segment* TensorProto::unsafe_arena_release_segment() { // @@protoc_insertion_point(field_release:caffe2.TensorProto.segment) _has_bits_[0] &= ~0x00000010u; ::caffe2::TensorProto_Segment* temp = segment_; segment_ = nullptr; return temp; } inline ::caffe2::TensorProto_Segment* TensorProto::_internal_mutable_segment() { _has_bits_[0] |= 0x00000010u; if (segment_ == nullptr) { auto* p = CreateMaybeMessage<::caffe2::TensorProto_Segment>(GetArena()); segment_ = p; } return segment_; } inline ::caffe2::TensorProto_Segment* TensorProto::mutable_segment() { // @@protoc_insertion_point(field_mutable:caffe2.TensorProto.segment) return _internal_mutable_segment(); } inline void TensorProto::set_allocated_segment(::caffe2::TensorProto_Segment* segment) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete segment_; } if (segment) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(segment); if (message_arena != submessage_arena) { segment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, segment, submessage_arena); } _has_bits_[0] |= 0x00000010u; } else { _has_bits_[0] &= ~0x00000010u; } segment_ = segment; // @@protoc_insertion_point(field_set_allocated:caffe2.TensorProto.segment) } // ------------------------------------------------------------------- // QTensorProto // repeated int64 dims = 1; inline int QTensorProto::_internal_dims_size() const { return dims_.size(); } inline int QTensorProto::dims_size() const { return _internal_dims_size(); } inline void QTensorProto::clear_dims() { dims_.Clear(); } inline ::PROTOBUF_NAMESPACE_ID::int64 QTensorProto::_internal_dims(int index) const { return dims_.Get(index); } inline ::PROTOBUF_NAMESPACE_ID::int64 QTensorProto::dims(int index) const { // @@protoc_insertion_point(field_get:caffe2.QTensorProto.dims) return _internal_dims(index); } inline void QTensorProto::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { dims_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.QTensorProto.dims) } inline void QTensorProto::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) { dims_.Add(value); } inline void QTensorProto::add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_add_dims(value); // @@protoc_insertion_point(field_add:caffe2.QTensorProto.dims) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& QTensorProto::_internal_dims() const { return dims_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& QTensorProto::dims() const { // @@protoc_insertion_point(field_list:caffe2.QTensorProto.dims) return _internal_dims(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* QTensorProto::_internal_mutable_dims() { return &dims_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* QTensorProto::mutable_dims() { // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.dims) return _internal_mutable_dims(); } // required int32 precision = 2; inline bool QTensorProto::_internal_has_precision() const { bool value = (_has_bits_[0] & 0x00000008u) != 0; return value; } inline bool QTensorProto::has_precision() const { return _internal_has_precision(); } inline void QTensorProto::clear_precision() { precision_ = 0; _has_bits_[0] &= ~0x00000008u; } inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::_internal_precision() const { return precision_; } inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::precision() const { // @@protoc_insertion_point(field_get:caffe2.QTensorProto.precision) return _internal_precision(); } inline void QTensorProto::_internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { _has_bits_[0] |= 0x00000008u; precision_ = value; } inline void QTensorProto::set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_precision(value); // @@protoc_insertion_point(field_set:caffe2.QTensorProto.precision) } // required double scale = 3; inline bool QTensorProto::_internal_has_scale() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool QTensorProto::has_scale() const { return _internal_has_scale(); } inline void QTensorProto::clear_scale() { scale_ = 0; _has_bits_[0] &= ~0x00000002u; } inline double QTensorProto::_internal_scale() const { return scale_; } inline double QTensorProto::scale() const { // @@protoc_insertion_point(field_get:caffe2.QTensorProto.scale) return _internal_scale(); } inline void QTensorProto::_internal_set_scale(double value) { _has_bits_[0] |= 0x00000002u; scale_ = value; } inline void QTensorProto::set_scale(double value) { _internal_set_scale(value); // @@protoc_insertion_point(field_set:caffe2.QTensorProto.scale) } // required double bias = 4; inline bool QTensorProto::_internal_has_bias() const { bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool QTensorProto::has_bias() const { return _internal_has_bias(); } inline void QTensorProto::clear_bias() { bias_ = 0; _has_bits_[0] &= ~0x00000004u; } inline double QTensorProto::_internal_bias() const { return bias_; } inline double QTensorProto::bias() const { // @@protoc_insertion_point(field_get:caffe2.QTensorProto.bias) return _internal_bias(); } inline void QTensorProto::_internal_set_bias(double value) { _has_bits_[0] |= 0x00000004u; bias_ = value; } inline void QTensorProto::set_bias(double value) { _internal_set_bias(value); // @@protoc_insertion_point(field_set:caffe2.QTensorProto.bias) } // required bool is_signed = 5; inline bool QTensorProto::_internal_has_is_signed() const { bool value = (_has_bits_[0] & 0x00000010u) != 0; return value; } inline bool QTensorProto::has_is_signed() const { return _internal_has_is_signed(); } inline void QTensorProto::clear_is_signed() { is_signed_ = false; _has_bits_[0] &= ~0x00000010u; } inline bool QTensorProto::_internal_is_signed() const { return is_signed_; } inline bool QTensorProto::is_signed() const { // @@protoc_insertion_point(field_get:caffe2.QTensorProto.is_signed) return _internal_is_signed(); } inline void QTensorProto::_internal_set_is_signed(bool value) { _has_bits_[0] |= 0x00000010u; is_signed_ = value; } inline void QTensorProto::set_is_signed(bool value) { _internal_set_is_signed(value); // @@protoc_insertion_point(field_set:caffe2.QTensorProto.is_signed) } // repeated int32 data = 6 [packed = true]; inline int QTensorProto::_internal_data_size() const { return data_.size(); } inline int QTensorProto::data_size() const { return _internal_data_size(); } inline void QTensorProto::clear_data() { data_.Clear(); } inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::_internal_data(int index) const { return data_.Get(index); } inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::data(int index) const { // @@protoc_insertion_point(field_get:caffe2.QTensorProto.data) return _internal_data(index); } inline void QTensorProto::set_data(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { data_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.QTensorProto.data) } inline void QTensorProto::_internal_add_data(::PROTOBUF_NAMESPACE_ID::int32 value) { data_.Add(value); } inline void QTensorProto::add_data(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_add_data(value); // @@protoc_insertion_point(field_add:caffe2.QTensorProto.data) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& QTensorProto::_internal_data() const { return data_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& QTensorProto::data() const { // @@protoc_insertion_point(field_list:caffe2.QTensorProto.data) return _internal_data(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* QTensorProto::_internal_mutable_data() { return &data_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* QTensorProto::mutable_data() { // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.data) return _internal_mutable_data(); } // optional string name = 7; inline bool QTensorProto::_internal_has_name() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool QTensorProto::has_name() const { return _internal_has_name(); } inline void QTensorProto::clear_name() { name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& QTensorProto::name() const { // @@protoc_insertion_point(field_get:caffe2.QTensorProto.name) return _internal_name(); } inline void QTensorProto::set_name(const std::string& value) { _internal_set_name(value); // @@protoc_insertion_point(field_set:caffe2.QTensorProto.name) } inline std::string* QTensorProto::mutable_name() { // @@protoc_insertion_point(field_mutable:caffe2.QTensorProto.name) return _internal_mutable_name(); } inline const std::string& QTensorProto::_internal_name() const { return name_.Get(); } inline void QTensorProto::_internal_set_name(const std::string& value) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void QTensorProto::set_name(std::string&& value) { _has_bits_[0] |= 0x00000001u; name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.QTensorProto.name) } inline void QTensorProto::set_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.QTensorProto.name) } inline void QTensorProto::set_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.QTensorProto.name) } inline std::string* QTensorProto::_internal_mutable_name() { _has_bits_[0] |= 0x00000001u; return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* QTensorProto::release_name() { // @@protoc_insertion_point(field_release:caffe2.QTensorProto.name) if (!_internal_has_name()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void QTensorProto::set_allocated_name(std::string* name) { if (name != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } name_.SetAllocated(&GetEmptyStringAlreadyInited(), name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.QTensorProto.name) } // optional .caffe2.TensorProto.DataType data_type = 8 [default = INT32]; inline bool QTensorProto::_internal_has_data_type() const { bool value = (_has_bits_[0] & 0x00000080u) != 0; return value; } inline bool QTensorProto::has_data_type() const { return _internal_has_data_type(); } inline void QTensorProto::clear_data_type() { data_type_ = 2; _has_bits_[0] &= ~0x00000080u; } inline ::caffe2::TensorProto_DataType QTensorProto::_internal_data_type() const { return static_cast< ::caffe2::TensorProto_DataType >(data_type_); } inline ::caffe2::TensorProto_DataType QTensorProto::data_type() const { // @@protoc_insertion_point(field_get:caffe2.QTensorProto.data_type) return _internal_data_type(); } inline void QTensorProto::_internal_set_data_type(::caffe2::TensorProto_DataType value) { assert(::caffe2::TensorProto_DataType_IsValid(value)); _has_bits_[0] |= 0x00000080u; data_type_ = value; } inline void QTensorProto::set_data_type(::caffe2::TensorProto_DataType value) { _internal_set_data_type(value); // @@protoc_insertion_point(field_set:caffe2.QTensorProto.data_type) } // repeated double scales = 9; inline int QTensorProto::_internal_scales_size() const { return scales_.size(); } inline int QTensorProto::scales_size() const { return _internal_scales_size(); } inline void QTensorProto::clear_scales() { scales_.Clear(); } inline double QTensorProto::_internal_scales(int index) const { return scales_.Get(index); } inline double QTensorProto::scales(int index) const { // @@protoc_insertion_point(field_get:caffe2.QTensorProto.scales) return _internal_scales(index); } inline void QTensorProto::set_scales(int index, double value) { scales_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.QTensorProto.scales) } inline void QTensorProto::_internal_add_scales(double value) { scales_.Add(value); } inline void QTensorProto::add_scales(double value) { _internal_add_scales(value); // @@protoc_insertion_point(field_add:caffe2.QTensorProto.scales) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& QTensorProto::_internal_scales() const { return scales_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& QTensorProto::scales() const { // @@protoc_insertion_point(field_list:caffe2.QTensorProto.scales) return _internal_scales(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* QTensorProto::_internal_mutable_scales() { return &scales_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* QTensorProto::mutable_scales() { // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.scales) return _internal_mutable_scales(); } // repeated double biases = 10; inline int QTensorProto::_internal_biases_size() const { return biases_.size(); } inline int QTensorProto::biases_size() const { return _internal_biases_size(); } inline void QTensorProto::clear_biases() { biases_.Clear(); } inline double QTensorProto::_internal_biases(int index) const { return biases_.Get(index); } inline double QTensorProto::biases(int index) const { // @@protoc_insertion_point(field_get:caffe2.QTensorProto.biases) return _internal_biases(index); } inline void QTensorProto::set_biases(int index, double value) { biases_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.QTensorProto.biases) } inline void QTensorProto::_internal_add_biases(double value) { biases_.Add(value); } inline void QTensorProto::add_biases(double value) { _internal_add_biases(value); // @@protoc_insertion_point(field_add:caffe2.QTensorProto.biases) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& QTensorProto::_internal_biases() const { return biases_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& QTensorProto::biases() const { // @@protoc_insertion_point(field_list:caffe2.QTensorProto.biases) return _internal_biases(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* QTensorProto::_internal_mutable_biases() { return &biases_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* QTensorProto::mutable_biases() { // @@protoc_insertion_point(field_mutable_list:caffe2.QTensorProto.biases) return _internal_mutable_biases(); } // optional int32 axis = 11; inline bool QTensorProto::_internal_has_axis() const { bool value = (_has_bits_[0] & 0x00000040u) != 0; return value; } inline bool QTensorProto::has_axis() const { return _internal_has_axis(); } inline void QTensorProto::clear_axis() { axis_ = 0; _has_bits_[0] &= ~0x00000040u; } inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::_internal_axis() const { return axis_; } inline ::PROTOBUF_NAMESPACE_ID::int32 QTensorProto::axis() const { // @@protoc_insertion_point(field_get:caffe2.QTensorProto.axis) return _internal_axis(); } inline void QTensorProto::_internal_set_axis(::PROTOBUF_NAMESPACE_ID::int32 value) { _has_bits_[0] |= 0x00000040u; axis_ = value; } inline void QTensorProto::set_axis(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_axis(value); // @@protoc_insertion_point(field_set:caffe2.QTensorProto.axis) } // optional bool is_multiparam = 12 [default = false]; inline bool QTensorProto::_internal_has_is_multiparam() const { bool value = (_has_bits_[0] & 0x00000020u) != 0; return value; } inline bool QTensorProto::has_is_multiparam() const { return _internal_has_is_multiparam(); } inline void QTensorProto::clear_is_multiparam() { is_multiparam_ = false; _has_bits_[0] &= ~0x00000020u; } inline bool QTensorProto::_internal_is_multiparam() const { return is_multiparam_; } inline bool QTensorProto::is_multiparam() const { // @@protoc_insertion_point(field_get:caffe2.QTensorProto.is_multiparam) return _internal_is_multiparam(); } inline void QTensorProto::_internal_set_is_multiparam(bool value) { _has_bits_[0] |= 0x00000020u; is_multiparam_ = value; } inline void QTensorProto::set_is_multiparam(bool value) { _internal_set_is_multiparam(value); // @@protoc_insertion_point(field_set:caffe2.QTensorProto.is_multiparam) } // ------------------------------------------------------------------- // TensorProtos // repeated .caffe2.TensorProto protos = 1; inline int TensorProtos::_internal_protos_size() const { return protos_.size(); } inline int TensorProtos::protos_size() const { return _internal_protos_size(); } inline void TensorProtos::clear_protos() { protos_.Clear(); } inline ::caffe2::TensorProto* TensorProtos::mutable_protos(int index) { // @@protoc_insertion_point(field_mutable:caffe2.TensorProtos.protos) return protos_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >* TensorProtos::mutable_protos() { // @@protoc_insertion_point(field_mutable_list:caffe2.TensorProtos.protos) return &protos_; } inline const ::caffe2::TensorProto& TensorProtos::_internal_protos(int index) const { return protos_.Get(index); } inline const ::caffe2::TensorProto& TensorProtos::protos(int index) const { // @@protoc_insertion_point(field_get:caffe2.TensorProtos.protos) return _internal_protos(index); } inline ::caffe2::TensorProto* TensorProtos::_internal_add_protos() { return protos_.Add(); } inline ::caffe2::TensorProto* TensorProtos::add_protos() { // @@protoc_insertion_point(field_add:caffe2.TensorProtos.protos) return _internal_add_protos(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >& TensorProtos::protos() const { // @@protoc_insertion_point(field_list:caffe2.TensorProtos.protos) return protos_; } // ------------------------------------------------------------------- // TensorShape // repeated int64 dims = 1; inline int TensorShape::_internal_dims_size() const { return dims_.size(); } inline int TensorShape::dims_size() const { return _internal_dims_size(); } inline void TensorShape::clear_dims() { dims_.Clear(); } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorShape::_internal_dims(int index) const { return dims_.Get(index); } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorShape::dims(int index) const { // @@protoc_insertion_point(field_get:caffe2.TensorShape.dims) return _internal_dims(index); } inline void TensorShape::set_dims(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { dims_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.TensorShape.dims) } inline void TensorShape::_internal_add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) { dims_.Add(value); } inline void TensorShape::add_dims(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_add_dims(value); // @@protoc_insertion_point(field_add:caffe2.TensorShape.dims) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& TensorShape::_internal_dims() const { return dims_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& TensorShape::dims() const { // @@protoc_insertion_point(field_list:caffe2.TensorShape.dims) return _internal_dims(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* TensorShape::_internal_mutable_dims() { return &dims_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* TensorShape::mutable_dims() { // @@protoc_insertion_point(field_mutable_list:caffe2.TensorShape.dims) return _internal_mutable_dims(); } // optional .caffe2.TensorProto.DataType data_type = 2 [default = FLOAT]; inline bool TensorShape::_internal_has_data_type() const { bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool TensorShape::has_data_type() const { return _internal_has_data_type(); } inline void TensorShape::clear_data_type() { data_type_ = 1; _has_bits_[0] &= ~0x00000004u; } inline ::caffe2::TensorProto_DataType TensorShape::_internal_data_type() const { return static_cast< ::caffe2::TensorProto_DataType >(data_type_); } inline ::caffe2::TensorProto_DataType TensorShape::data_type() const { // @@protoc_insertion_point(field_get:caffe2.TensorShape.data_type) return _internal_data_type(); } inline void TensorShape::_internal_set_data_type(::caffe2::TensorProto_DataType value) { assert(::caffe2::TensorProto_DataType_IsValid(value)); _has_bits_[0] |= 0x00000004u; data_type_ = value; } inline void TensorShape::set_data_type(::caffe2::TensorProto_DataType value) { _internal_set_data_type(value); // @@protoc_insertion_point(field_set:caffe2.TensorShape.data_type) } // repeated int32 unknown_dims = 3; inline int TensorShape::_internal_unknown_dims_size() const { return unknown_dims_.size(); } inline int TensorShape::unknown_dims_size() const { return _internal_unknown_dims_size(); } inline void TensorShape::clear_unknown_dims() { unknown_dims_.Clear(); } inline ::PROTOBUF_NAMESPACE_ID::int32 TensorShape::_internal_unknown_dims(int index) const { return unknown_dims_.Get(index); } inline ::PROTOBUF_NAMESPACE_ID::int32 TensorShape::unknown_dims(int index) const { // @@protoc_insertion_point(field_get:caffe2.TensorShape.unknown_dims) return _internal_unknown_dims(index); } inline void TensorShape::set_unknown_dims(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { unknown_dims_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.TensorShape.unknown_dims) } inline void TensorShape::_internal_add_unknown_dims(::PROTOBUF_NAMESPACE_ID::int32 value) { unknown_dims_.Add(value); } inline void TensorShape::add_unknown_dims(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_add_unknown_dims(value); // @@protoc_insertion_point(field_add:caffe2.TensorShape.unknown_dims) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& TensorShape::_internal_unknown_dims() const { return unknown_dims_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& TensorShape::unknown_dims() const { // @@protoc_insertion_point(field_list:caffe2.TensorShape.unknown_dims) return _internal_unknown_dims(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* TensorShape::_internal_mutable_unknown_dims() { return &unknown_dims_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* TensorShape::mutable_unknown_dims() { // @@protoc_insertion_point(field_mutable_list:caffe2.TensorShape.unknown_dims) return _internal_mutable_unknown_dims(); } // optional bool unknown_shape = 4 [default = false]; inline bool TensorShape::_internal_has_unknown_shape() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool TensorShape::has_unknown_shape() const { return _internal_has_unknown_shape(); } inline void TensorShape::clear_unknown_shape() { unknown_shape_ = false; _has_bits_[0] &= ~0x00000002u; } inline bool TensorShape::_internal_unknown_shape() const { return unknown_shape_; } inline bool TensorShape::unknown_shape() const { // @@protoc_insertion_point(field_get:caffe2.TensorShape.unknown_shape) return _internal_unknown_shape(); } inline void TensorShape::_internal_set_unknown_shape(bool value) { _has_bits_[0] |= 0x00000002u; unknown_shape_ = value; } inline void TensorShape::set_unknown_shape(bool value) { _internal_set_unknown_shape(value); // @@protoc_insertion_point(field_set:caffe2.TensorShape.unknown_shape) } // optional string name = 5; inline bool TensorShape::_internal_has_name() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool TensorShape::has_name() const { return _internal_has_name(); } inline void TensorShape::clear_name() { name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& TensorShape::name() const { // @@protoc_insertion_point(field_get:caffe2.TensorShape.name) return _internal_name(); } inline void TensorShape::set_name(const std::string& value) { _internal_set_name(value); // @@protoc_insertion_point(field_set:caffe2.TensorShape.name) } inline std::string* TensorShape::mutable_name() { // @@protoc_insertion_point(field_mutable:caffe2.TensorShape.name) return _internal_mutable_name(); } inline const std::string& TensorShape::_internal_name() const { return name_.Get(); } inline void TensorShape::_internal_set_name(const std::string& value) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void TensorShape::set_name(std::string&& value) { _has_bits_[0] |= 0x00000001u; name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorShape.name) } inline void TensorShape::set_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.TensorShape.name) } inline void TensorShape::set_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.TensorShape.name) } inline std::string* TensorShape::_internal_mutable_name() { _has_bits_[0] |= 0x00000001u; return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* TensorShape::release_name() { // @@protoc_insertion_point(field_release:caffe2.TensorShape.name) if (!_internal_has_name()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void TensorShape::set_allocated_name(std::string* name) { if (name != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } name_.SetAllocated(&GetEmptyStringAlreadyInited(), name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.TensorShape.name) } // ------------------------------------------------------------------- // TensorShapes // repeated .caffe2.TensorShape shapes = 1; inline int TensorShapes::_internal_shapes_size() const { return shapes_.size(); } inline int TensorShapes::shapes_size() const { return _internal_shapes_size(); } inline void TensorShapes::clear_shapes() { shapes_.Clear(); } inline ::caffe2::TensorShape* TensorShapes::mutable_shapes(int index) { // @@protoc_insertion_point(field_mutable:caffe2.TensorShapes.shapes) return shapes_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape >* TensorShapes::mutable_shapes() { // @@protoc_insertion_point(field_mutable_list:caffe2.TensorShapes.shapes) return &shapes_; } inline const ::caffe2::TensorShape& TensorShapes::_internal_shapes(int index) const { return shapes_.Get(index); } inline const ::caffe2::TensorShape& TensorShapes::shapes(int index) const { // @@protoc_insertion_point(field_get:caffe2.TensorShapes.shapes) return _internal_shapes(index); } inline ::caffe2::TensorShape* TensorShapes::_internal_add_shapes() { return shapes_.Add(); } inline ::caffe2::TensorShape* TensorShapes::add_shapes() { // @@protoc_insertion_point(field_add:caffe2.TensorShapes.shapes) return _internal_add_shapes(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorShape >& TensorShapes::shapes() const { // @@protoc_insertion_point(field_list:caffe2.TensorShapes.shapes) return shapes_; } // ------------------------------------------------------------------- // TensorBoundShape // optional .caffe2.TensorShape shape = 1; inline bool TensorBoundShape::_internal_has_shape() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; PROTOBUF_ASSUME(!value || shape_ != nullptr); return value; } inline bool TensorBoundShape::has_shape() const { return _internal_has_shape(); } inline void TensorBoundShape::clear_shape() { if (shape_ != nullptr) shape_->Clear(); _has_bits_[0] &= ~0x00000002u; } inline const ::caffe2::TensorShape& TensorBoundShape::_internal_shape() const { const ::caffe2::TensorShape* p = shape_; return p != nullptr ? *p : *reinterpret_cast( &::caffe2::_TensorShape_default_instance_); } inline const ::caffe2::TensorShape& TensorBoundShape::shape() const { // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.shape) return _internal_shape(); } inline void TensorBoundShape::unsafe_arena_set_allocated_shape( ::caffe2::TensorShape* shape) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_); } shape_ = shape; if (shape) { _has_bits_[0] |= 0x00000002u; } else { _has_bits_[0] &= ~0x00000002u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.TensorBoundShape.shape) } inline ::caffe2::TensorShape* TensorBoundShape::release_shape() { _has_bits_[0] &= ~0x00000002u; ::caffe2::TensorShape* temp = shape_; shape_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } inline ::caffe2::TensorShape* TensorBoundShape::unsafe_arena_release_shape() { // @@protoc_insertion_point(field_release:caffe2.TensorBoundShape.shape) _has_bits_[0] &= ~0x00000002u; ::caffe2::TensorShape* temp = shape_; shape_ = nullptr; return temp; } inline ::caffe2::TensorShape* TensorBoundShape::_internal_mutable_shape() { _has_bits_[0] |= 0x00000002u; if (shape_ == nullptr) { auto* p = CreateMaybeMessage<::caffe2::TensorShape>(GetArena()); shape_ = p; } return shape_; } inline ::caffe2::TensorShape* TensorBoundShape::mutable_shape() { // @@protoc_insertion_point(field_mutable:caffe2.TensorBoundShape.shape) return _internal_mutable_shape(); } inline void TensorBoundShape::set_allocated_shape(::caffe2::TensorShape* shape) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete shape_; } if (shape) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(shape); if (message_arena != submessage_arena) { shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, shape, submessage_arena); } _has_bits_[0] |= 0x00000002u; } else { _has_bits_[0] &= ~0x00000002u; } shape_ = shape; // @@protoc_insertion_point(field_set_allocated:caffe2.TensorBoundShape.shape) } // repeated .caffe2.TensorBoundShape.DimType dim_type = 2; inline int TensorBoundShape::_internal_dim_type_size() const { return dim_type_.size(); } inline int TensorBoundShape::dim_type_size() const { return _internal_dim_type_size(); } inline void TensorBoundShape::clear_dim_type() { dim_type_.Clear(); } inline ::caffe2::TensorBoundShape_DimType TensorBoundShape::_internal_dim_type(int index) const { return static_cast< ::caffe2::TensorBoundShape_DimType >(dim_type_.Get(index)); } inline ::caffe2::TensorBoundShape_DimType TensorBoundShape::dim_type(int index) const { // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.dim_type) return _internal_dim_type(index); } inline void TensorBoundShape::set_dim_type(int index, ::caffe2::TensorBoundShape_DimType value) { assert(::caffe2::TensorBoundShape_DimType_IsValid(value)); dim_type_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.TensorBoundShape.dim_type) } inline void TensorBoundShape::_internal_add_dim_type(::caffe2::TensorBoundShape_DimType value) { assert(::caffe2::TensorBoundShape_DimType_IsValid(value)); dim_type_.Add(value); } inline void TensorBoundShape::add_dim_type(::caffe2::TensorBoundShape_DimType value) { // @@protoc_insertion_point(field_add:caffe2.TensorBoundShape.dim_type) _internal_add_dim_type(value); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& TensorBoundShape::dim_type() const { // @@protoc_insertion_point(field_list:caffe2.TensorBoundShape.dim_type) return dim_type_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* TensorBoundShape::_internal_mutable_dim_type() { return &dim_type_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* TensorBoundShape::mutable_dim_type() { // @@protoc_insertion_point(field_mutable_list:caffe2.TensorBoundShape.dim_type) return _internal_mutable_dim_type(); } // optional string name = 3; inline bool TensorBoundShape::_internal_has_name() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool TensorBoundShape::has_name() const { return _internal_has_name(); } inline void TensorBoundShape::clear_name() { name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& TensorBoundShape::name() const { // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.name) return _internal_name(); } inline void TensorBoundShape::set_name(const std::string& value) { _internal_set_name(value); // @@protoc_insertion_point(field_set:caffe2.TensorBoundShape.name) } inline std::string* TensorBoundShape::mutable_name() { // @@protoc_insertion_point(field_mutable:caffe2.TensorBoundShape.name) return _internal_mutable_name(); } inline const std::string& TensorBoundShape::_internal_name() const { return name_.Get(); } inline void TensorBoundShape::_internal_set_name(const std::string& value) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void TensorBoundShape::set_name(std::string&& value) { _has_bits_[0] |= 0x00000001u; name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.TensorBoundShape.name) } inline void TensorBoundShape::set_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.TensorBoundShape.name) } inline void TensorBoundShape::set_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.TensorBoundShape.name) } inline std::string* TensorBoundShape::_internal_mutable_name() { _has_bits_[0] |= 0x00000001u; return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* TensorBoundShape::release_name() { // @@protoc_insertion_point(field_release:caffe2.TensorBoundShape.name) if (!_internal_has_name()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void TensorBoundShape::set_allocated_name(std::string* name) { if (name != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } name_.SetAllocated(&GetEmptyStringAlreadyInited(), name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.TensorBoundShape.name) } // optional bool shape_is_final = 4; inline bool TensorBoundShape::_internal_has_shape_is_final() const { bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool TensorBoundShape::has_shape_is_final() const { return _internal_has_shape_is_final(); } inline void TensorBoundShape::clear_shape_is_final() { shape_is_final_ = false; _has_bits_[0] &= ~0x00000004u; } inline bool TensorBoundShape::_internal_shape_is_final() const { return shape_is_final_; } inline bool TensorBoundShape::shape_is_final() const { // @@protoc_insertion_point(field_get:caffe2.TensorBoundShape.shape_is_final) return _internal_shape_is_final(); } inline void TensorBoundShape::_internal_set_shape_is_final(bool value) { _has_bits_[0] |= 0x00000004u; shape_is_final_ = value; } inline void TensorBoundShape::set_shape_is_final(bool value) { _internal_set_shape_is_final(value); // @@protoc_insertion_point(field_set:caffe2.TensorBoundShape.shape_is_final) } // ------------------------------------------------------------------- // TensorBoundShapes // repeated .caffe2.TensorBoundShape shapes = 1; inline int TensorBoundShapes::_internal_shapes_size() const { return shapes_.size(); } inline int TensorBoundShapes::shapes_size() const { return _internal_shapes_size(); } inline void TensorBoundShapes::clear_shapes() { shapes_.Clear(); } inline ::caffe2::TensorBoundShape* TensorBoundShapes::mutable_shapes(int index) { // @@protoc_insertion_point(field_mutable:caffe2.TensorBoundShapes.shapes) return shapes_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape >* TensorBoundShapes::mutable_shapes() { // @@protoc_insertion_point(field_mutable_list:caffe2.TensorBoundShapes.shapes) return &shapes_; } inline const ::caffe2::TensorBoundShape& TensorBoundShapes::_internal_shapes(int index) const { return shapes_.Get(index); } inline const ::caffe2::TensorBoundShape& TensorBoundShapes::shapes(int index) const { // @@protoc_insertion_point(field_get:caffe2.TensorBoundShapes.shapes) return _internal_shapes(index); } inline ::caffe2::TensorBoundShape* TensorBoundShapes::_internal_add_shapes() { return shapes_.Add(); } inline ::caffe2::TensorBoundShape* TensorBoundShapes::add_shapes() { // @@protoc_insertion_point(field_add:caffe2.TensorBoundShapes.shapes) return _internal_add_shapes(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorBoundShape >& TensorBoundShapes::shapes() const { // @@protoc_insertion_point(field_list:caffe2.TensorBoundShapes.shapes) return shapes_; } // optional int64 max_batch_size = 2; inline bool TensorBoundShapes::_internal_has_max_batch_size() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool TensorBoundShapes::has_max_batch_size() const { return _internal_has_max_batch_size(); } inline void TensorBoundShapes::clear_max_batch_size() { max_batch_size_ = PROTOBUF_LONGLONG(0); _has_bits_[0] &= ~0x00000001u; } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorBoundShapes::_internal_max_batch_size() const { return max_batch_size_; } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorBoundShapes::max_batch_size() const { // @@protoc_insertion_point(field_get:caffe2.TensorBoundShapes.max_batch_size) return _internal_max_batch_size(); } inline void TensorBoundShapes::_internal_set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value) { _has_bits_[0] |= 0x00000001u; max_batch_size_ = value; } inline void TensorBoundShapes::set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_max_batch_size(value); // @@protoc_insertion_point(field_set:caffe2.TensorBoundShapes.max_batch_size) } // optional int64 max_feature_len = 3; inline bool TensorBoundShapes::_internal_has_max_feature_len() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool TensorBoundShapes::has_max_feature_len() const { return _internal_has_max_feature_len(); } inline void TensorBoundShapes::clear_max_feature_len() { max_feature_len_ = PROTOBUF_LONGLONG(0); _has_bits_[0] &= ~0x00000002u; } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorBoundShapes::_internal_max_feature_len() const { return max_feature_len_; } inline ::PROTOBUF_NAMESPACE_ID::int64 TensorBoundShapes::max_feature_len() const { // @@protoc_insertion_point(field_get:caffe2.TensorBoundShapes.max_feature_len) return _internal_max_feature_len(); } inline void TensorBoundShapes::_internal_set_max_feature_len(::PROTOBUF_NAMESPACE_ID::int64 value) { _has_bits_[0] |= 0x00000002u; max_feature_len_ = value; } inline void TensorBoundShapes::set_max_feature_len(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_max_feature_len(value); // @@protoc_insertion_point(field_set:caffe2.TensorBoundShapes.max_feature_len) } // ------------------------------------------------------------------- // AOTConfig // required int64 max_batch_size = 1; inline bool AOTConfig::_internal_has_max_batch_size() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool AOTConfig::has_max_batch_size() const { return _internal_has_max_batch_size(); } inline void AOTConfig::clear_max_batch_size() { max_batch_size_ = PROTOBUF_LONGLONG(0); _has_bits_[0] &= ~0x00000002u; } inline ::PROTOBUF_NAMESPACE_ID::int64 AOTConfig::_internal_max_batch_size() const { return max_batch_size_; } inline ::PROTOBUF_NAMESPACE_ID::int64 AOTConfig::max_batch_size() const { // @@protoc_insertion_point(field_get:caffe2.AOTConfig.max_batch_size) return _internal_max_batch_size(); } inline void AOTConfig::_internal_set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value) { _has_bits_[0] |= 0x00000002u; max_batch_size_ = value; } inline void AOTConfig::set_max_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_max_batch_size(value); // @@protoc_insertion_point(field_set:caffe2.AOTConfig.max_batch_size) } // required int64 max_seq_size = 2; inline bool AOTConfig::_internal_has_max_seq_size() const { bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool AOTConfig::has_max_seq_size() const { return _internal_has_max_seq_size(); } inline void AOTConfig::clear_max_seq_size() { max_seq_size_ = PROTOBUF_LONGLONG(0); _has_bits_[0] &= ~0x00000004u; } inline ::PROTOBUF_NAMESPACE_ID::int64 AOTConfig::_internal_max_seq_size() const { return max_seq_size_; } inline ::PROTOBUF_NAMESPACE_ID::int64 AOTConfig::max_seq_size() const { // @@protoc_insertion_point(field_get:caffe2.AOTConfig.max_seq_size) return _internal_max_seq_size(); } inline void AOTConfig::_internal_set_max_seq_size(::PROTOBUF_NAMESPACE_ID::int64 value) { _has_bits_[0] |= 0x00000004u; max_seq_size_ = value; } inline void AOTConfig::set_max_seq_size(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_max_seq_size(value); // @@protoc_insertion_point(field_set:caffe2.AOTConfig.max_seq_size) } // required bool in_batch_broadcast = 3; inline bool AOTConfig::_internal_has_in_batch_broadcast() const { bool value = (_has_bits_[0] & 0x00000008u) != 0; return value; } inline bool AOTConfig::has_in_batch_broadcast() const { return _internal_has_in_batch_broadcast(); } inline void AOTConfig::clear_in_batch_broadcast() { in_batch_broadcast_ = false; _has_bits_[0] &= ~0x00000008u; } inline bool AOTConfig::_internal_in_batch_broadcast() const { return in_batch_broadcast_; } inline bool AOTConfig::in_batch_broadcast() const { // @@protoc_insertion_point(field_get:caffe2.AOTConfig.in_batch_broadcast) return _internal_in_batch_broadcast(); } inline void AOTConfig::_internal_set_in_batch_broadcast(bool value) { _has_bits_[0] |= 0x00000008u; in_batch_broadcast_ = value; } inline void AOTConfig::set_in_batch_broadcast(bool value) { _internal_set_in_batch_broadcast(value); // @@protoc_insertion_point(field_set:caffe2.AOTConfig.in_batch_broadcast) } // optional string onnxifi_blacklist_ops = 4; inline bool AOTConfig::_internal_has_onnxifi_blacklist_ops() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool AOTConfig::has_onnxifi_blacklist_ops() const { return _internal_has_onnxifi_blacklist_ops(); } inline void AOTConfig::clear_onnxifi_blacklist_ops() { onnxifi_blacklist_ops_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& AOTConfig::onnxifi_blacklist_ops() const { // @@protoc_insertion_point(field_get:caffe2.AOTConfig.onnxifi_blacklist_ops) return _internal_onnxifi_blacklist_ops(); } inline void AOTConfig::set_onnxifi_blacklist_ops(const std::string& value) { _internal_set_onnxifi_blacklist_ops(value); // @@protoc_insertion_point(field_set:caffe2.AOTConfig.onnxifi_blacklist_ops) } inline std::string* AOTConfig::mutable_onnxifi_blacklist_ops() { // @@protoc_insertion_point(field_mutable:caffe2.AOTConfig.onnxifi_blacklist_ops) return _internal_mutable_onnxifi_blacklist_ops(); } inline const std::string& AOTConfig::_internal_onnxifi_blacklist_ops() const { return onnxifi_blacklist_ops_.Get(); } inline void AOTConfig::_internal_set_onnxifi_blacklist_ops(const std::string& value) { _has_bits_[0] |= 0x00000001u; onnxifi_blacklist_ops_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void AOTConfig::set_onnxifi_blacklist_ops(std::string&& value) { _has_bits_[0] |= 0x00000001u; onnxifi_blacklist_ops_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.AOTConfig.onnxifi_blacklist_ops) } inline void AOTConfig::set_onnxifi_blacklist_ops(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; onnxifi_blacklist_ops_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.AOTConfig.onnxifi_blacklist_ops) } inline void AOTConfig::set_onnxifi_blacklist_ops(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; onnxifi_blacklist_ops_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.AOTConfig.onnxifi_blacklist_ops) } inline std::string* AOTConfig::_internal_mutable_onnxifi_blacklist_ops() { _has_bits_[0] |= 0x00000001u; return onnxifi_blacklist_ops_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* AOTConfig::release_onnxifi_blacklist_ops() { // @@protoc_insertion_point(field_release:caffe2.AOTConfig.onnxifi_blacklist_ops) if (!_internal_has_onnxifi_blacklist_ops()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return onnxifi_blacklist_ops_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void AOTConfig::set_allocated_onnxifi_blacklist_ops(std::string* onnxifi_blacklist_ops) { if (onnxifi_blacklist_ops != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } onnxifi_blacklist_ops_.SetAllocated(&GetEmptyStringAlreadyInited(), onnxifi_blacklist_ops, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.AOTConfig.onnxifi_blacklist_ops) } // optional int32 onnxifi_min_ops = 5; inline bool AOTConfig::_internal_has_onnxifi_min_ops() const { bool value = (_has_bits_[0] & 0x00000010u) != 0; return value; } inline bool AOTConfig::has_onnxifi_min_ops() const { return _internal_has_onnxifi_min_ops(); } inline void AOTConfig::clear_onnxifi_min_ops() { onnxifi_min_ops_ = 0; _has_bits_[0] &= ~0x00000010u; } inline ::PROTOBUF_NAMESPACE_ID::int32 AOTConfig::_internal_onnxifi_min_ops() const { return onnxifi_min_ops_; } inline ::PROTOBUF_NAMESPACE_ID::int32 AOTConfig::onnxifi_min_ops() const { // @@protoc_insertion_point(field_get:caffe2.AOTConfig.onnxifi_min_ops) return _internal_onnxifi_min_ops(); } inline void AOTConfig::_internal_set_onnxifi_min_ops(::PROTOBUF_NAMESPACE_ID::int32 value) { _has_bits_[0] |= 0x00000010u; onnxifi_min_ops_ = value; } inline void AOTConfig::set_onnxifi_min_ops(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_onnxifi_min_ops(value); // @@protoc_insertion_point(field_set:caffe2.AOTConfig.onnxifi_min_ops) } // ------------------------------------------------------------------- // Argument // optional string name = 1; inline bool Argument::_internal_has_name() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool Argument::has_name() const { return _internal_has_name(); } inline void Argument::clear_name() { name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& Argument::name() const { // @@protoc_insertion_point(field_get:caffe2.Argument.name) return _internal_name(); } inline void Argument::set_name(const std::string& value) { _internal_set_name(value); // @@protoc_insertion_point(field_set:caffe2.Argument.name) } inline std::string* Argument::mutable_name() { // @@protoc_insertion_point(field_mutable:caffe2.Argument.name) return _internal_mutable_name(); } inline const std::string& Argument::_internal_name() const { return name_.Get(); } inline void Argument::_internal_set_name(const std::string& value) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void Argument::set_name(std::string&& value) { _has_bits_[0] |= 0x00000001u; name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.Argument.name) } inline void Argument::set_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.Argument.name) } inline void Argument::set_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.Argument.name) } inline std::string* Argument::_internal_mutable_name() { _has_bits_[0] |= 0x00000001u; return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* Argument::release_name() { // @@protoc_insertion_point(field_release:caffe2.Argument.name) if (!_internal_has_name()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void Argument::set_allocated_name(std::string* name) { if (name != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } name_.SetAllocated(&GetEmptyStringAlreadyInited(), name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.name) } // optional float f = 2; inline bool Argument::_internal_has_f() const { bool value = (_has_bits_[0] & 0x00000020u) != 0; return value; } inline bool Argument::has_f() const { return _internal_has_f(); } inline void Argument::clear_f() { f_ = 0; _has_bits_[0] &= ~0x00000020u; } inline float Argument::_internal_f() const { return f_; } inline float Argument::f() const { // @@protoc_insertion_point(field_get:caffe2.Argument.f) return _internal_f(); } inline void Argument::_internal_set_f(float value) { _has_bits_[0] |= 0x00000020u; f_ = value; } inline void Argument::set_f(float value) { _internal_set_f(value); // @@protoc_insertion_point(field_set:caffe2.Argument.f) } // optional int64 i = 3; inline bool Argument::_internal_has_i() const { bool value = (_has_bits_[0] & 0x00000010u) != 0; return value; } inline bool Argument::has_i() const { return _internal_has_i(); } inline void Argument::clear_i() { i_ = PROTOBUF_LONGLONG(0); _has_bits_[0] &= ~0x00000010u; } inline ::PROTOBUF_NAMESPACE_ID::int64 Argument::_internal_i() const { return i_; } inline ::PROTOBUF_NAMESPACE_ID::int64 Argument::i() const { // @@protoc_insertion_point(field_get:caffe2.Argument.i) return _internal_i(); } inline void Argument::_internal_set_i(::PROTOBUF_NAMESPACE_ID::int64 value) { _has_bits_[0] |= 0x00000010u; i_ = value; } inline void Argument::set_i(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_i(value); // @@protoc_insertion_point(field_set:caffe2.Argument.i) } // optional bytes s = 4; inline bool Argument::_internal_has_s() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool Argument::has_s() const { return _internal_has_s(); } inline void Argument::clear_s() { s_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000002u; } inline const std::string& Argument::s() const { // @@protoc_insertion_point(field_get:caffe2.Argument.s) return _internal_s(); } inline void Argument::set_s(const std::string& value) { _internal_set_s(value); // @@protoc_insertion_point(field_set:caffe2.Argument.s) } inline std::string* Argument::mutable_s() { // @@protoc_insertion_point(field_mutable:caffe2.Argument.s) return _internal_mutable_s(); } inline const std::string& Argument::_internal_s() const { return s_.Get(); } inline void Argument::_internal_set_s(const std::string& value) { _has_bits_[0] |= 0x00000002u; s_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void Argument::set_s(std::string&& value) { _has_bits_[0] |= 0x00000002u; s_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.Argument.s) } inline void Argument::set_s(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000002u; s_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.Argument.s) } inline void Argument::set_s(const void* value, size_t size) { _has_bits_[0] |= 0x00000002u; s_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.Argument.s) } inline std::string* Argument::_internal_mutable_s() { _has_bits_[0] |= 0x00000002u; return s_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* Argument::release_s() { // @@protoc_insertion_point(field_release:caffe2.Argument.s) if (!_internal_has_s()) { return nullptr; } _has_bits_[0] &= ~0x00000002u; return s_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void Argument::set_allocated_s(std::string* s) { if (s != nullptr) { _has_bits_[0] |= 0x00000002u; } else { _has_bits_[0] &= ~0x00000002u; } s_.SetAllocated(&GetEmptyStringAlreadyInited(), s, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.s) } // optional .caffe2.TensorProto t = 10; inline bool Argument::_internal_has_t() const { bool value = (_has_bits_[0] & 0x00000008u) != 0; PROTOBUF_ASSUME(!value || t_ != nullptr); return value; } inline bool Argument::has_t() const { return _internal_has_t(); } inline void Argument::clear_t() { if (t_ != nullptr) t_->Clear(); _has_bits_[0] &= ~0x00000008u; } inline const ::caffe2::TensorProto& Argument::_internal_t() const { const ::caffe2::TensorProto* p = t_; return p != nullptr ? *p : *reinterpret_cast( &::caffe2::_TensorProto_default_instance_); } inline const ::caffe2::TensorProto& Argument::t() const { // @@protoc_insertion_point(field_get:caffe2.Argument.t) return _internal_t(); } inline void Argument::unsafe_arena_set_allocated_t( ::caffe2::TensorProto* t) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(t_); } t_ = t; if (t) { _has_bits_[0] |= 0x00000008u; } else { _has_bits_[0] &= ~0x00000008u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.Argument.t) } inline ::caffe2::TensorProto* Argument::release_t() { _has_bits_[0] &= ~0x00000008u; ::caffe2::TensorProto* temp = t_; t_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } inline ::caffe2::TensorProto* Argument::unsafe_arena_release_t() { // @@protoc_insertion_point(field_release:caffe2.Argument.t) _has_bits_[0] &= ~0x00000008u; ::caffe2::TensorProto* temp = t_; t_ = nullptr; return temp; } inline ::caffe2::TensorProto* Argument::_internal_mutable_t() { _has_bits_[0] |= 0x00000008u; if (t_ == nullptr) { auto* p = CreateMaybeMessage<::caffe2::TensorProto>(GetArena()); t_ = p; } return t_; } inline ::caffe2::TensorProto* Argument::mutable_t() { // @@protoc_insertion_point(field_mutable:caffe2.Argument.t) return _internal_mutable_t(); } inline void Argument::set_allocated_t(::caffe2::TensorProto* t) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete t_; } if (t) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(t); if (message_arena != submessage_arena) { t = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, t, submessage_arena); } _has_bits_[0] |= 0x00000008u; } else { _has_bits_[0] &= ~0x00000008u; } t_ = t; // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.t) } // optional .caffe2.NetDef n = 8; inline bool Argument::_internal_has_n() const { bool value = (_has_bits_[0] & 0x00000004u) != 0; PROTOBUF_ASSUME(!value || n_ != nullptr); return value; } inline bool Argument::has_n() const { return _internal_has_n(); } inline void Argument::clear_n() { if (n_ != nullptr) n_->Clear(); _has_bits_[0] &= ~0x00000004u; } inline const ::caffe2::NetDef& Argument::_internal_n() const { const ::caffe2::NetDef* p = n_; return p != nullptr ? *p : *reinterpret_cast( &::caffe2::_NetDef_default_instance_); } inline const ::caffe2::NetDef& Argument::n() const { // @@protoc_insertion_point(field_get:caffe2.Argument.n) return _internal_n(); } inline void Argument::unsafe_arena_set_allocated_n( ::caffe2::NetDef* n) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(n_); } n_ = n; if (n) { _has_bits_[0] |= 0x00000004u; } else { _has_bits_[0] &= ~0x00000004u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.Argument.n) } inline ::caffe2::NetDef* Argument::release_n() { _has_bits_[0] &= ~0x00000004u; ::caffe2::NetDef* temp = n_; n_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } inline ::caffe2::NetDef* Argument::unsafe_arena_release_n() { // @@protoc_insertion_point(field_release:caffe2.Argument.n) _has_bits_[0] &= ~0x00000004u; ::caffe2::NetDef* temp = n_; n_ = nullptr; return temp; } inline ::caffe2::NetDef* Argument::_internal_mutable_n() { _has_bits_[0] |= 0x00000004u; if (n_ == nullptr) { auto* p = CreateMaybeMessage<::caffe2::NetDef>(GetArena()); n_ = p; } return n_; } inline ::caffe2::NetDef* Argument::mutable_n() { // @@protoc_insertion_point(field_mutable:caffe2.Argument.n) return _internal_mutable_n(); } inline void Argument::set_allocated_n(::caffe2::NetDef* n) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete n_; } if (n) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(n); if (message_arena != submessage_arena) { n = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, n, submessage_arena); } _has_bits_[0] |= 0x00000004u; } else { _has_bits_[0] &= ~0x00000004u; } n_ = n; // @@protoc_insertion_point(field_set_allocated:caffe2.Argument.n) } // repeated float floats = 5; inline int Argument::_internal_floats_size() const { return floats_.size(); } inline int Argument::floats_size() const { return _internal_floats_size(); } inline void Argument::clear_floats() { floats_.Clear(); } inline float Argument::_internal_floats(int index) const { return floats_.Get(index); } inline float Argument::floats(int index) const { // @@protoc_insertion_point(field_get:caffe2.Argument.floats) return _internal_floats(index); } inline void Argument::set_floats(int index, float value) { floats_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.Argument.floats) } inline void Argument::_internal_add_floats(float value) { floats_.Add(value); } inline void Argument::add_floats(float value) { _internal_add_floats(value); // @@protoc_insertion_point(field_add:caffe2.Argument.floats) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& Argument::_internal_floats() const { return floats_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& Argument::floats() const { // @@protoc_insertion_point(field_list:caffe2.Argument.floats) return _internal_floats(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* Argument::_internal_mutable_floats() { return &floats_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* Argument::mutable_floats() { // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.floats) return _internal_mutable_floats(); } // repeated int64 ints = 6; inline int Argument::_internal_ints_size() const { return ints_.size(); } inline int Argument::ints_size() const { return _internal_ints_size(); } inline void Argument::clear_ints() { ints_.Clear(); } inline ::PROTOBUF_NAMESPACE_ID::int64 Argument::_internal_ints(int index) const { return ints_.Get(index); } inline ::PROTOBUF_NAMESPACE_ID::int64 Argument::ints(int index) const { // @@protoc_insertion_point(field_get:caffe2.Argument.ints) return _internal_ints(index); } inline void Argument::set_ints(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { ints_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.Argument.ints) } inline void Argument::_internal_add_ints(::PROTOBUF_NAMESPACE_ID::int64 value) { ints_.Add(value); } inline void Argument::add_ints(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_add_ints(value); // @@protoc_insertion_point(field_add:caffe2.Argument.ints) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& Argument::_internal_ints() const { return ints_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& Argument::ints() const { // @@protoc_insertion_point(field_list:caffe2.Argument.ints) return _internal_ints(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* Argument::_internal_mutable_ints() { return &ints_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* Argument::mutable_ints() { // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.ints) return _internal_mutable_ints(); } // repeated bytes strings = 7; inline int Argument::_internal_strings_size() const { return strings_.size(); } inline int Argument::strings_size() const { return _internal_strings_size(); } inline void Argument::clear_strings() { strings_.Clear(); } inline std::string* Argument::add_strings() { // @@protoc_insertion_point(field_add_mutable:caffe2.Argument.strings) return _internal_add_strings(); } inline const std::string& Argument::_internal_strings(int index) const { return strings_.Get(index); } inline const std::string& Argument::strings(int index) const { // @@protoc_insertion_point(field_get:caffe2.Argument.strings) return _internal_strings(index); } inline std::string* Argument::mutable_strings(int index) { // @@protoc_insertion_point(field_mutable:caffe2.Argument.strings) return strings_.Mutable(index); } inline void Argument::set_strings(int index, const std::string& value) { // @@protoc_insertion_point(field_set:caffe2.Argument.strings) strings_.Mutable(index)->assign(value); } inline void Argument::set_strings(int index, std::string&& value) { // @@protoc_insertion_point(field_set:caffe2.Argument.strings) strings_.Mutable(index)->assign(std::move(value)); } inline void Argument::set_strings(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); strings_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:caffe2.Argument.strings) } inline void Argument::set_strings(int index, const void* value, size_t size) { strings_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:caffe2.Argument.strings) } inline std::string* Argument::_internal_add_strings() { return strings_.Add(); } inline void Argument::add_strings(const std::string& value) { strings_.Add()->assign(value); // @@protoc_insertion_point(field_add:caffe2.Argument.strings) } inline void Argument::add_strings(std::string&& value) { strings_.Add(std::move(value)); // @@protoc_insertion_point(field_add:caffe2.Argument.strings) } inline void Argument::add_strings(const char* value) { GOOGLE_DCHECK(value != nullptr); strings_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:caffe2.Argument.strings) } inline void Argument::add_strings(const void* value, size_t size) { strings_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:caffe2.Argument.strings) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& Argument::strings() const { // @@protoc_insertion_point(field_list:caffe2.Argument.strings) return strings_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* Argument::mutable_strings() { // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.strings) return &strings_; } // repeated .caffe2.TensorProto tensors = 11; inline int Argument::_internal_tensors_size() const { return tensors_.size(); } inline int Argument::tensors_size() const { return _internal_tensors_size(); } inline void Argument::clear_tensors() { tensors_.Clear(); } inline ::caffe2::TensorProto* Argument::mutable_tensors(int index) { // @@protoc_insertion_point(field_mutable:caffe2.Argument.tensors) return tensors_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >* Argument::mutable_tensors() { // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.tensors) return &tensors_; } inline const ::caffe2::TensorProto& Argument::_internal_tensors(int index) const { return tensors_.Get(index); } inline const ::caffe2::TensorProto& Argument::tensors(int index) const { // @@protoc_insertion_point(field_get:caffe2.Argument.tensors) return _internal_tensors(index); } inline ::caffe2::TensorProto* Argument::_internal_add_tensors() { return tensors_.Add(); } inline ::caffe2::TensorProto* Argument::add_tensors() { // @@protoc_insertion_point(field_add:caffe2.Argument.tensors) return _internal_add_tensors(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::TensorProto >& Argument::tensors() const { // @@protoc_insertion_point(field_list:caffe2.Argument.tensors) return tensors_; } // repeated .caffe2.NetDef nets = 9; inline int Argument::_internal_nets_size() const { return nets_.size(); } inline int Argument::nets_size() const { return _internal_nets_size(); } inline void Argument::clear_nets() { nets_.Clear(); } inline ::caffe2::NetDef* Argument::mutable_nets(int index) { // @@protoc_insertion_point(field_mutable:caffe2.Argument.nets) return nets_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >* Argument::mutable_nets() { // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.nets) return &nets_; } inline const ::caffe2::NetDef& Argument::_internal_nets(int index) const { return nets_.Get(index); } inline const ::caffe2::NetDef& Argument::nets(int index) const { // @@protoc_insertion_point(field_get:caffe2.Argument.nets) return _internal_nets(index); } inline ::caffe2::NetDef* Argument::_internal_add_nets() { return nets_.Add(); } inline ::caffe2::NetDef* Argument::add_nets() { // @@protoc_insertion_point(field_add:caffe2.Argument.nets) return _internal_add_nets(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >& Argument::nets() const { // @@protoc_insertion_point(field_list:caffe2.Argument.nets) return nets_; } // repeated .caffe2.QTensorProto qtensors = 12; inline int Argument::_internal_qtensors_size() const { return qtensors_.size(); } inline int Argument::qtensors_size() const { return _internal_qtensors_size(); } inline void Argument::clear_qtensors() { qtensors_.Clear(); } inline ::caffe2::QTensorProto* Argument::mutable_qtensors(int index) { // @@protoc_insertion_point(field_mutable:caffe2.Argument.qtensors) return qtensors_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto >* Argument::mutable_qtensors() { // @@protoc_insertion_point(field_mutable_list:caffe2.Argument.qtensors) return &qtensors_; } inline const ::caffe2::QTensorProto& Argument::_internal_qtensors(int index) const { return qtensors_.Get(index); } inline const ::caffe2::QTensorProto& Argument::qtensors(int index) const { // @@protoc_insertion_point(field_get:caffe2.Argument.qtensors) return _internal_qtensors(index); } inline ::caffe2::QTensorProto* Argument::_internal_add_qtensors() { return qtensors_.Add(); } inline ::caffe2::QTensorProto* Argument::add_qtensors() { // @@protoc_insertion_point(field_add:caffe2.Argument.qtensors) return _internal_add_qtensors(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::QTensorProto >& Argument::qtensors() const { // @@protoc_insertion_point(field_list:caffe2.Argument.qtensors) return qtensors_; } // ------------------------------------------------------------------- // DeviceOption // optional int32 device_type = 1 [default = 0]; inline bool DeviceOption::_internal_has_device_type() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool DeviceOption::has_device_type() const { return _internal_has_device_type(); } inline void DeviceOption::clear_device_type() { device_type_ = 0; _has_bits_[0] &= ~0x00000002u; } inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::_internal_device_type() const { return device_type_; } inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::device_type() const { // @@protoc_insertion_point(field_get:caffe2.DeviceOption.device_type) return _internal_device_type(); } inline void DeviceOption::_internal_set_device_type(::PROTOBUF_NAMESPACE_ID::int32 value) { _has_bits_[0] |= 0x00000002u; device_type_ = value; } inline void DeviceOption::set_device_type(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_device_type(value); // @@protoc_insertion_point(field_set:caffe2.DeviceOption.device_type) } // optional int32 device_id = 2; inline bool DeviceOption::_internal_has_device_id() const { bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool DeviceOption::has_device_id() const { return _internal_has_device_id(); } inline void DeviceOption::clear_device_id() { device_id_ = 0; _has_bits_[0] &= ~0x00000004u; } inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::_internal_device_id() const { return device_id_; } inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::device_id() const { // @@protoc_insertion_point(field_get:caffe2.DeviceOption.device_id) return _internal_device_id(); } inline void DeviceOption::_internal_set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) { _has_bits_[0] |= 0x00000004u; device_id_ = value; } inline void DeviceOption::set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_device_id(value); // @@protoc_insertion_point(field_set:caffe2.DeviceOption.device_id) } // optional uint32 random_seed = 3; inline bool DeviceOption::_internal_has_random_seed() const { bool value = (_has_bits_[0] & 0x00000008u) != 0; return value; } inline bool DeviceOption::has_random_seed() const { return _internal_has_random_seed(); } inline void DeviceOption::clear_random_seed() { random_seed_ = 0u; _has_bits_[0] &= ~0x00000008u; } inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceOption::_internal_random_seed() const { return random_seed_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceOption::random_seed() const { // @@protoc_insertion_point(field_get:caffe2.DeviceOption.random_seed) return _internal_random_seed(); } inline void DeviceOption::_internal_set_random_seed(::PROTOBUF_NAMESPACE_ID::uint32 value) { _has_bits_[0] |= 0x00000008u; random_seed_ = value; } inline void DeviceOption::set_random_seed(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_random_seed(value); // @@protoc_insertion_point(field_set:caffe2.DeviceOption.random_seed) } // optional string node_name = 4; inline bool DeviceOption::_internal_has_node_name() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool DeviceOption::has_node_name() const { return _internal_has_node_name(); } inline void DeviceOption::clear_node_name() { node_name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& DeviceOption::node_name() const { // @@protoc_insertion_point(field_get:caffe2.DeviceOption.node_name) return _internal_node_name(); } inline void DeviceOption::set_node_name(const std::string& value) { _internal_set_node_name(value); // @@protoc_insertion_point(field_set:caffe2.DeviceOption.node_name) } inline std::string* DeviceOption::mutable_node_name() { // @@protoc_insertion_point(field_mutable:caffe2.DeviceOption.node_name) return _internal_mutable_node_name(); } inline const std::string& DeviceOption::_internal_node_name() const { return node_name_.Get(); } inline void DeviceOption::_internal_set_node_name(const std::string& value) { _has_bits_[0] |= 0x00000001u; node_name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void DeviceOption::set_node_name(std::string&& value) { _has_bits_[0] |= 0x00000001u; node_name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.DeviceOption.node_name) } inline void DeviceOption::set_node_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; node_name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.DeviceOption.node_name) } inline void DeviceOption::set_node_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; node_name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.DeviceOption.node_name) } inline std::string* DeviceOption::_internal_mutable_node_name() { _has_bits_[0] |= 0x00000001u; return node_name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* DeviceOption::release_node_name() { // @@protoc_insertion_point(field_release:caffe2.DeviceOption.node_name) if (!_internal_has_node_name()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return node_name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void DeviceOption::set_allocated_node_name(std::string* node_name) { if (node_name != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } node_name_.SetAllocated(&GetEmptyStringAlreadyInited(), node_name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.DeviceOption.node_name) } // optional int32 numa_node_id = 5; inline bool DeviceOption::_internal_has_numa_node_id() const { bool value = (_has_bits_[0] & 0x00000010u) != 0; return value; } inline bool DeviceOption::has_numa_node_id() const { return _internal_has_numa_node_id(); } inline void DeviceOption::clear_numa_node_id() { numa_node_id_ = 0; _has_bits_[0] &= ~0x00000010u; } inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::_internal_numa_node_id() const { return numa_node_id_; } inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceOption::numa_node_id() const { // @@protoc_insertion_point(field_get:caffe2.DeviceOption.numa_node_id) return _internal_numa_node_id(); } inline void DeviceOption::_internal_set_numa_node_id(::PROTOBUF_NAMESPACE_ID::int32 value) { _has_bits_[0] |= 0x00000010u; numa_node_id_ = value; } inline void DeviceOption::set_numa_node_id(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_numa_node_id(value); // @@protoc_insertion_point(field_set:caffe2.DeviceOption.numa_node_id) } // repeated string extra_info = 6; inline int DeviceOption::_internal_extra_info_size() const { return extra_info_.size(); } inline int DeviceOption::extra_info_size() const { return _internal_extra_info_size(); } inline void DeviceOption::clear_extra_info() { extra_info_.Clear(); } inline std::string* DeviceOption::add_extra_info() { // @@protoc_insertion_point(field_add_mutable:caffe2.DeviceOption.extra_info) return _internal_add_extra_info(); } inline const std::string& DeviceOption::_internal_extra_info(int index) const { return extra_info_.Get(index); } inline const std::string& DeviceOption::extra_info(int index) const { // @@protoc_insertion_point(field_get:caffe2.DeviceOption.extra_info) return _internal_extra_info(index); } inline std::string* DeviceOption::mutable_extra_info(int index) { // @@protoc_insertion_point(field_mutable:caffe2.DeviceOption.extra_info) return extra_info_.Mutable(index); } inline void DeviceOption::set_extra_info(int index, const std::string& value) { // @@protoc_insertion_point(field_set:caffe2.DeviceOption.extra_info) extra_info_.Mutable(index)->assign(value); } inline void DeviceOption::set_extra_info(int index, std::string&& value) { // @@protoc_insertion_point(field_set:caffe2.DeviceOption.extra_info) extra_info_.Mutable(index)->assign(std::move(value)); } inline void DeviceOption::set_extra_info(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); extra_info_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:caffe2.DeviceOption.extra_info) } inline void DeviceOption::set_extra_info(int index, const char* value, size_t size) { extra_info_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:caffe2.DeviceOption.extra_info) } inline std::string* DeviceOption::_internal_add_extra_info() { return extra_info_.Add(); } inline void DeviceOption::add_extra_info(const std::string& value) { extra_info_.Add()->assign(value); // @@protoc_insertion_point(field_add:caffe2.DeviceOption.extra_info) } inline void DeviceOption::add_extra_info(std::string&& value) { extra_info_.Add(std::move(value)); // @@protoc_insertion_point(field_add:caffe2.DeviceOption.extra_info) } inline void DeviceOption::add_extra_info(const char* value) { GOOGLE_DCHECK(value != nullptr); extra_info_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:caffe2.DeviceOption.extra_info) } inline void DeviceOption::add_extra_info(const char* value, size_t size) { extra_info_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:caffe2.DeviceOption.extra_info) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& DeviceOption::extra_info() const { // @@protoc_insertion_point(field_list:caffe2.DeviceOption.extra_info) return extra_info_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* DeviceOption::mutable_extra_info() { // @@protoc_insertion_point(field_mutable_list:caffe2.DeviceOption.extra_info) return &extra_info_; } // ------------------------------------------------------------------- // OperatorDef // repeated string input = 1; inline int OperatorDef::_internal_input_size() const { return input_.size(); } inline int OperatorDef::input_size() const { return _internal_input_size(); } inline void OperatorDef::clear_input() { input_.Clear(); } inline std::string* OperatorDef::add_input() { // @@protoc_insertion_point(field_add_mutable:caffe2.OperatorDef.input) return _internal_add_input(); } inline const std::string& OperatorDef::_internal_input(int index) const { return input_.Get(index); } inline const std::string& OperatorDef::input(int index) const { // @@protoc_insertion_point(field_get:caffe2.OperatorDef.input) return _internal_input(index); } inline std::string* OperatorDef::mutable_input(int index) { // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.input) return input_.Mutable(index); } inline void OperatorDef::set_input(int index, const std::string& value) { // @@protoc_insertion_point(field_set:caffe2.OperatorDef.input) input_.Mutable(index)->assign(value); } inline void OperatorDef::set_input(int index, std::string&& value) { // @@protoc_insertion_point(field_set:caffe2.OperatorDef.input) input_.Mutable(index)->assign(std::move(value)); } inline void OperatorDef::set_input(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); input_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.input) } inline void OperatorDef::set_input(int index, const char* value, size_t size) { input_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.input) } inline std::string* OperatorDef::_internal_add_input() { return input_.Add(); } inline void OperatorDef::add_input(const std::string& value) { input_.Add()->assign(value); // @@protoc_insertion_point(field_add:caffe2.OperatorDef.input) } inline void OperatorDef::add_input(std::string&& value) { input_.Add(std::move(value)); // @@protoc_insertion_point(field_add:caffe2.OperatorDef.input) } inline void OperatorDef::add_input(const char* value) { GOOGLE_DCHECK(value != nullptr); input_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:caffe2.OperatorDef.input) } inline void OperatorDef::add_input(const char* value, size_t size) { input_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:caffe2.OperatorDef.input) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& OperatorDef::input() const { // @@protoc_insertion_point(field_list:caffe2.OperatorDef.input) return input_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* OperatorDef::mutable_input() { // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.input) return &input_; } // repeated string output = 2; inline int OperatorDef::_internal_output_size() const { return output_.size(); } inline int OperatorDef::output_size() const { return _internal_output_size(); } inline void OperatorDef::clear_output() { output_.Clear(); } inline std::string* OperatorDef::add_output() { // @@protoc_insertion_point(field_add_mutable:caffe2.OperatorDef.output) return _internal_add_output(); } inline const std::string& OperatorDef::_internal_output(int index) const { return output_.Get(index); } inline const std::string& OperatorDef::output(int index) const { // @@protoc_insertion_point(field_get:caffe2.OperatorDef.output) return _internal_output(index); } inline std::string* OperatorDef::mutable_output(int index) { // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.output) return output_.Mutable(index); } inline void OperatorDef::set_output(int index, const std::string& value) { // @@protoc_insertion_point(field_set:caffe2.OperatorDef.output) output_.Mutable(index)->assign(value); } inline void OperatorDef::set_output(int index, std::string&& value) { // @@protoc_insertion_point(field_set:caffe2.OperatorDef.output) output_.Mutable(index)->assign(std::move(value)); } inline void OperatorDef::set_output(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); output_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.output) } inline void OperatorDef::set_output(int index, const char* value, size_t size) { output_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.output) } inline std::string* OperatorDef::_internal_add_output() { return output_.Add(); } inline void OperatorDef::add_output(const std::string& value) { output_.Add()->assign(value); // @@protoc_insertion_point(field_add:caffe2.OperatorDef.output) } inline void OperatorDef::add_output(std::string&& value) { output_.Add(std::move(value)); // @@protoc_insertion_point(field_add:caffe2.OperatorDef.output) } inline void OperatorDef::add_output(const char* value) { GOOGLE_DCHECK(value != nullptr); output_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:caffe2.OperatorDef.output) } inline void OperatorDef::add_output(const char* value, size_t size) { output_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:caffe2.OperatorDef.output) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& OperatorDef::output() const { // @@protoc_insertion_point(field_list:caffe2.OperatorDef.output) return output_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* OperatorDef::mutable_output() { // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.output) return &output_; } // optional string name = 3; inline bool OperatorDef::_internal_has_name() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool OperatorDef::has_name() const { return _internal_has_name(); } inline void OperatorDef::clear_name() { name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& OperatorDef::name() const { // @@protoc_insertion_point(field_get:caffe2.OperatorDef.name) return _internal_name(); } inline void OperatorDef::set_name(const std::string& value) { _internal_set_name(value); // @@protoc_insertion_point(field_set:caffe2.OperatorDef.name) } inline std::string* OperatorDef::mutable_name() { // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.name) return _internal_mutable_name(); } inline const std::string& OperatorDef::_internal_name() const { return name_.Get(); } inline void OperatorDef::_internal_set_name(const std::string& value) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void OperatorDef::set_name(std::string&& value) { _has_bits_[0] |= 0x00000001u; name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.name) } inline void OperatorDef::set_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.name) } inline void OperatorDef::set_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.name) } inline std::string* OperatorDef::_internal_mutable_name() { _has_bits_[0] |= 0x00000001u; return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* OperatorDef::release_name() { // @@protoc_insertion_point(field_release:caffe2.OperatorDef.name) if (!_internal_has_name()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void OperatorDef::set_allocated_name(std::string* name) { if (name != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } name_.SetAllocated(&GetEmptyStringAlreadyInited(), name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.name) } // optional string type = 4; inline bool OperatorDef::_internal_has_type() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool OperatorDef::has_type() const { return _internal_has_type(); } inline void OperatorDef::clear_type() { type_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000002u; } inline const std::string& OperatorDef::type() const { // @@protoc_insertion_point(field_get:caffe2.OperatorDef.type) return _internal_type(); } inline void OperatorDef::set_type(const std::string& value) { _internal_set_type(value); // @@protoc_insertion_point(field_set:caffe2.OperatorDef.type) } inline std::string* OperatorDef::mutable_type() { // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.type) return _internal_mutable_type(); } inline const std::string& OperatorDef::_internal_type() const { return type_.Get(); } inline void OperatorDef::_internal_set_type(const std::string& value) { _has_bits_[0] |= 0x00000002u; type_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void OperatorDef::set_type(std::string&& value) { _has_bits_[0] |= 0x00000002u; type_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.type) } inline void OperatorDef::set_type(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000002u; type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.type) } inline void OperatorDef::set_type(const char* value, size_t size) { _has_bits_[0] |= 0x00000002u; type_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.type) } inline std::string* OperatorDef::_internal_mutable_type() { _has_bits_[0] |= 0x00000002u; return type_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* OperatorDef::release_type() { // @@protoc_insertion_point(field_release:caffe2.OperatorDef.type) if (!_internal_has_type()) { return nullptr; } _has_bits_[0] &= ~0x00000002u; return type_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void OperatorDef::set_allocated_type(std::string* type) { if (type != nullptr) { _has_bits_[0] |= 0x00000002u; } else { _has_bits_[0] &= ~0x00000002u; } type_.SetAllocated(&GetEmptyStringAlreadyInited(), type, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.type) } // repeated .caffe2.Argument arg = 5; inline int OperatorDef::_internal_arg_size() const { return arg_.size(); } inline int OperatorDef::arg_size() const { return _internal_arg_size(); } inline void OperatorDef::clear_arg() { arg_.Clear(); } inline ::caffe2::Argument* OperatorDef::mutable_arg(int index) { // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.arg) return arg_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >* OperatorDef::mutable_arg() { // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.arg) return &arg_; } inline const ::caffe2::Argument& OperatorDef::_internal_arg(int index) const { return arg_.Get(index); } inline const ::caffe2::Argument& OperatorDef::arg(int index) const { // @@protoc_insertion_point(field_get:caffe2.OperatorDef.arg) return _internal_arg(index); } inline ::caffe2::Argument* OperatorDef::_internal_add_arg() { return arg_.Add(); } inline ::caffe2::Argument* OperatorDef::add_arg() { // @@protoc_insertion_point(field_add:caffe2.OperatorDef.arg) return _internal_add_arg(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >& OperatorDef::arg() const { // @@protoc_insertion_point(field_list:caffe2.OperatorDef.arg) return arg_; } // optional .caffe2.DeviceOption device_option = 6; inline bool OperatorDef::_internal_has_device_option() const { bool value = (_has_bits_[0] & 0x00000020u) != 0; PROTOBUF_ASSUME(!value || device_option_ != nullptr); return value; } inline bool OperatorDef::has_device_option() const { return _internal_has_device_option(); } inline void OperatorDef::clear_device_option() { if (device_option_ != nullptr) device_option_->Clear(); _has_bits_[0] &= ~0x00000020u; } inline const ::caffe2::DeviceOption& OperatorDef::_internal_device_option() const { const ::caffe2::DeviceOption* p = device_option_; return p != nullptr ? *p : *reinterpret_cast( &::caffe2::_DeviceOption_default_instance_); } inline const ::caffe2::DeviceOption& OperatorDef::device_option() const { // @@protoc_insertion_point(field_get:caffe2.OperatorDef.device_option) return _internal_device_option(); } inline void OperatorDef::unsafe_arena_set_allocated_device_option( ::caffe2::DeviceOption* device_option) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_option_); } device_option_ = device_option; if (device_option) { _has_bits_[0] |= 0x00000020u; } else { _has_bits_[0] &= ~0x00000020u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.OperatorDef.device_option) } inline ::caffe2::DeviceOption* OperatorDef::release_device_option() { _has_bits_[0] &= ~0x00000020u; ::caffe2::DeviceOption* temp = device_option_; device_option_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } inline ::caffe2::DeviceOption* OperatorDef::unsafe_arena_release_device_option() { // @@protoc_insertion_point(field_release:caffe2.OperatorDef.device_option) _has_bits_[0] &= ~0x00000020u; ::caffe2::DeviceOption* temp = device_option_; device_option_ = nullptr; return temp; } inline ::caffe2::DeviceOption* OperatorDef::_internal_mutable_device_option() { _has_bits_[0] |= 0x00000020u; if (device_option_ == nullptr) { auto* p = CreateMaybeMessage<::caffe2::DeviceOption>(GetArena()); device_option_ = p; } return device_option_; } inline ::caffe2::DeviceOption* OperatorDef::mutable_device_option() { // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.device_option) return _internal_mutable_device_option(); } inline void OperatorDef::set_allocated_device_option(::caffe2::DeviceOption* device_option) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete device_option_; } if (device_option) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(device_option); if (message_arena != submessage_arena) { device_option = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, device_option, submessage_arena); } _has_bits_[0] |= 0x00000020u; } else { _has_bits_[0] &= ~0x00000020u; } device_option_ = device_option; // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.device_option) } // optional string engine = 7; inline bool OperatorDef::_internal_has_engine() const { bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool OperatorDef::has_engine() const { return _internal_has_engine(); } inline void OperatorDef::clear_engine() { engine_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000004u; } inline const std::string& OperatorDef::engine() const { // @@protoc_insertion_point(field_get:caffe2.OperatorDef.engine) return _internal_engine(); } inline void OperatorDef::set_engine(const std::string& value) { _internal_set_engine(value); // @@protoc_insertion_point(field_set:caffe2.OperatorDef.engine) } inline std::string* OperatorDef::mutable_engine() { // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.engine) return _internal_mutable_engine(); } inline const std::string& OperatorDef::_internal_engine() const { return engine_.Get(); } inline void OperatorDef::_internal_set_engine(const std::string& value) { _has_bits_[0] |= 0x00000004u; engine_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void OperatorDef::set_engine(std::string&& value) { _has_bits_[0] |= 0x00000004u; engine_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.engine) } inline void OperatorDef::set_engine(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000004u; engine_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.engine) } inline void OperatorDef::set_engine(const char* value, size_t size) { _has_bits_[0] |= 0x00000004u; engine_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.engine) } inline std::string* OperatorDef::_internal_mutable_engine() { _has_bits_[0] |= 0x00000004u; return engine_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* OperatorDef::release_engine() { // @@protoc_insertion_point(field_release:caffe2.OperatorDef.engine) if (!_internal_has_engine()) { return nullptr; } _has_bits_[0] &= ~0x00000004u; return engine_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void OperatorDef::set_allocated_engine(std::string* engine) { if (engine != nullptr) { _has_bits_[0] |= 0x00000004u; } else { _has_bits_[0] &= ~0x00000004u; } engine_.SetAllocated(&GetEmptyStringAlreadyInited(), engine, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.engine) } // repeated string control_input = 8; inline int OperatorDef::_internal_control_input_size() const { return control_input_.size(); } inline int OperatorDef::control_input_size() const { return _internal_control_input_size(); } inline void OperatorDef::clear_control_input() { control_input_.Clear(); } inline std::string* OperatorDef::add_control_input() { // @@protoc_insertion_point(field_add_mutable:caffe2.OperatorDef.control_input) return _internal_add_control_input(); } inline const std::string& OperatorDef::_internal_control_input(int index) const { return control_input_.Get(index); } inline const std::string& OperatorDef::control_input(int index) const { // @@protoc_insertion_point(field_get:caffe2.OperatorDef.control_input) return _internal_control_input(index); } inline std::string* OperatorDef::mutable_control_input(int index) { // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.control_input) return control_input_.Mutable(index); } inline void OperatorDef::set_control_input(int index, const std::string& value) { // @@protoc_insertion_point(field_set:caffe2.OperatorDef.control_input) control_input_.Mutable(index)->assign(value); } inline void OperatorDef::set_control_input(int index, std::string&& value) { // @@protoc_insertion_point(field_set:caffe2.OperatorDef.control_input) control_input_.Mutable(index)->assign(std::move(value)); } inline void OperatorDef::set_control_input(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); control_input_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.control_input) } inline void OperatorDef::set_control_input(int index, const char* value, size_t size) { control_input_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.control_input) } inline std::string* OperatorDef::_internal_add_control_input() { return control_input_.Add(); } inline void OperatorDef::add_control_input(const std::string& value) { control_input_.Add()->assign(value); // @@protoc_insertion_point(field_add:caffe2.OperatorDef.control_input) } inline void OperatorDef::add_control_input(std::string&& value) { control_input_.Add(std::move(value)); // @@protoc_insertion_point(field_add:caffe2.OperatorDef.control_input) } inline void OperatorDef::add_control_input(const char* value) { GOOGLE_DCHECK(value != nullptr); control_input_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:caffe2.OperatorDef.control_input) } inline void OperatorDef::add_control_input(const char* value, size_t size) { control_input_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:caffe2.OperatorDef.control_input) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& OperatorDef::control_input() const { // @@protoc_insertion_point(field_list:caffe2.OperatorDef.control_input) return control_input_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* OperatorDef::mutable_control_input() { // @@protoc_insertion_point(field_mutable_list:caffe2.OperatorDef.control_input) return &control_input_; } // optional bool is_gradient_op = 9 [default = false]; inline bool OperatorDef::_internal_has_is_gradient_op() const { bool value = (_has_bits_[0] & 0x00000080u) != 0; return value; } inline bool OperatorDef::has_is_gradient_op() const { return _internal_has_is_gradient_op(); } inline void OperatorDef::clear_is_gradient_op() { is_gradient_op_ = false; _has_bits_[0] &= ~0x00000080u; } inline bool OperatorDef::_internal_is_gradient_op() const { return is_gradient_op_; } inline bool OperatorDef::is_gradient_op() const { // @@protoc_insertion_point(field_get:caffe2.OperatorDef.is_gradient_op) return _internal_is_gradient_op(); } inline void OperatorDef::_internal_set_is_gradient_op(bool value) { _has_bits_[0] |= 0x00000080u; is_gradient_op_ = value; } inline void OperatorDef::set_is_gradient_op(bool value) { _internal_set_is_gradient_op(value); // @@protoc_insertion_point(field_set:caffe2.OperatorDef.is_gradient_op) } // optional string debug_info = 10; inline bool OperatorDef::_internal_has_debug_info() const { bool value = (_has_bits_[0] & 0x00000008u) != 0; return value; } inline bool OperatorDef::has_debug_info() const { return _internal_has_debug_info(); } inline void OperatorDef::clear_debug_info() { debug_info_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000008u; } inline const std::string& OperatorDef::debug_info() const { // @@protoc_insertion_point(field_get:caffe2.OperatorDef.debug_info) return _internal_debug_info(); } inline void OperatorDef::set_debug_info(const std::string& value) { _internal_set_debug_info(value); // @@protoc_insertion_point(field_set:caffe2.OperatorDef.debug_info) } inline std::string* OperatorDef::mutable_debug_info() { // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.debug_info) return _internal_mutable_debug_info(); } inline const std::string& OperatorDef::_internal_debug_info() const { return debug_info_.Get(); } inline void OperatorDef::_internal_set_debug_info(const std::string& value) { _has_bits_[0] |= 0x00000008u; debug_info_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void OperatorDef::set_debug_info(std::string&& value) { _has_bits_[0] |= 0x00000008u; debug_info_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.debug_info) } inline void OperatorDef::set_debug_info(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000008u; debug_info_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.debug_info) } inline void OperatorDef::set_debug_info(const char* value, size_t size) { _has_bits_[0] |= 0x00000008u; debug_info_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.debug_info) } inline std::string* OperatorDef::_internal_mutable_debug_info() { _has_bits_[0] |= 0x00000008u; return debug_info_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* OperatorDef::release_debug_info() { // @@protoc_insertion_point(field_release:caffe2.OperatorDef.debug_info) if (!_internal_has_debug_info()) { return nullptr; } _has_bits_[0] &= ~0x00000008u; return debug_info_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void OperatorDef::set_allocated_debug_info(std::string* debug_info) { if (debug_info != nullptr) { _has_bits_[0] |= 0x00000008u; } else { _has_bits_[0] &= ~0x00000008u; } debug_info_.SetAllocated(&GetEmptyStringAlreadyInited(), debug_info, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.debug_info) } // optional string domain = 11; inline bool OperatorDef::_internal_has_domain() const { bool value = (_has_bits_[0] & 0x00000010u) != 0; return value; } inline bool OperatorDef::has_domain() const { return _internal_has_domain(); } inline void OperatorDef::clear_domain() { domain_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000010u; } inline const std::string& OperatorDef::domain() const { // @@protoc_insertion_point(field_get:caffe2.OperatorDef.domain) return _internal_domain(); } inline void OperatorDef::set_domain(const std::string& value) { _internal_set_domain(value); // @@protoc_insertion_point(field_set:caffe2.OperatorDef.domain) } inline std::string* OperatorDef::mutable_domain() { // @@protoc_insertion_point(field_mutable:caffe2.OperatorDef.domain) return _internal_mutable_domain(); } inline const std::string& OperatorDef::_internal_domain() const { return domain_.Get(); } inline void OperatorDef::_internal_set_domain(const std::string& value) { _has_bits_[0] |= 0x00000010u; domain_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void OperatorDef::set_domain(std::string&& value) { _has_bits_[0] |= 0x00000010u; domain_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.OperatorDef.domain) } inline void OperatorDef::set_domain(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000010u; domain_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.OperatorDef.domain) } inline void OperatorDef::set_domain(const char* value, size_t size) { _has_bits_[0] |= 0x00000010u; domain_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.OperatorDef.domain) } inline std::string* OperatorDef::_internal_mutable_domain() { _has_bits_[0] |= 0x00000010u; return domain_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* OperatorDef::release_domain() { // @@protoc_insertion_point(field_release:caffe2.OperatorDef.domain) if (!_internal_has_domain()) { return nullptr; } _has_bits_[0] &= ~0x00000010u; return domain_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void OperatorDef::set_allocated_domain(std::string* domain) { if (domain != nullptr) { _has_bits_[0] |= 0x00000010u; } else { _has_bits_[0] &= ~0x00000010u; } domain_.SetAllocated(&GetEmptyStringAlreadyInited(), domain, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.OperatorDef.domain) } // optional int64 op_version = 12; inline bool OperatorDef::_internal_has_op_version() const { bool value = (_has_bits_[0] & 0x00000040u) != 0; return value; } inline bool OperatorDef::has_op_version() const { return _internal_has_op_version(); } inline void OperatorDef::clear_op_version() { op_version_ = PROTOBUF_LONGLONG(0); _has_bits_[0] &= ~0x00000040u; } inline ::PROTOBUF_NAMESPACE_ID::int64 OperatorDef::_internal_op_version() const { return op_version_; } inline ::PROTOBUF_NAMESPACE_ID::int64 OperatorDef::op_version() const { // @@protoc_insertion_point(field_get:caffe2.OperatorDef.op_version) return _internal_op_version(); } inline void OperatorDef::_internal_set_op_version(::PROTOBUF_NAMESPACE_ID::int64 value) { _has_bits_[0] |= 0x00000040u; op_version_ = value; } inline void OperatorDef::set_op_version(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_op_version(value); // @@protoc_insertion_point(field_set:caffe2.OperatorDef.op_version) } // ------------------------------------------------------------------- // MapFieldEntry // required string key = 1; inline bool MapFieldEntry::_internal_has_key() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool MapFieldEntry::has_key() const { return _internal_has_key(); } inline void MapFieldEntry::clear_key() { key_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& MapFieldEntry::key() const { // @@protoc_insertion_point(field_get:caffe2.MapFieldEntry.key) return _internal_key(); } inline void MapFieldEntry::set_key(const std::string& value) { _internal_set_key(value); // @@protoc_insertion_point(field_set:caffe2.MapFieldEntry.key) } inline std::string* MapFieldEntry::mutable_key() { // @@protoc_insertion_point(field_mutable:caffe2.MapFieldEntry.key) return _internal_mutable_key(); } inline const std::string& MapFieldEntry::_internal_key() const { return key_.Get(); } inline void MapFieldEntry::_internal_set_key(const std::string& value) { _has_bits_[0] |= 0x00000001u; key_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void MapFieldEntry::set_key(std::string&& value) { _has_bits_[0] |= 0x00000001u; key_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.MapFieldEntry.key) } inline void MapFieldEntry::set_key(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; key_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.MapFieldEntry.key) } inline void MapFieldEntry::set_key(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; key_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.MapFieldEntry.key) } inline std::string* MapFieldEntry::_internal_mutable_key() { _has_bits_[0] |= 0x00000001u; return key_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* MapFieldEntry::release_key() { // @@protoc_insertion_point(field_release:caffe2.MapFieldEntry.key) if (!_internal_has_key()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return key_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void MapFieldEntry::set_allocated_key(std::string* key) { if (key != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } key_.SetAllocated(&GetEmptyStringAlreadyInited(), key, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.MapFieldEntry.key) } // required string val = 2; inline bool MapFieldEntry::_internal_has_val() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool MapFieldEntry::has_val() const { return _internal_has_val(); } inline void MapFieldEntry::clear_val() { val_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000002u; } inline const std::string& MapFieldEntry::val() const { // @@protoc_insertion_point(field_get:caffe2.MapFieldEntry.val) return _internal_val(); } inline void MapFieldEntry::set_val(const std::string& value) { _internal_set_val(value); // @@protoc_insertion_point(field_set:caffe2.MapFieldEntry.val) } inline std::string* MapFieldEntry::mutable_val() { // @@protoc_insertion_point(field_mutable:caffe2.MapFieldEntry.val) return _internal_mutable_val(); } inline const std::string& MapFieldEntry::_internal_val() const { return val_.Get(); } inline void MapFieldEntry::_internal_set_val(const std::string& value) { _has_bits_[0] |= 0x00000002u; val_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void MapFieldEntry::set_val(std::string&& value) { _has_bits_[0] |= 0x00000002u; val_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.MapFieldEntry.val) } inline void MapFieldEntry::set_val(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000002u; val_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.MapFieldEntry.val) } inline void MapFieldEntry::set_val(const char* value, size_t size) { _has_bits_[0] |= 0x00000002u; val_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.MapFieldEntry.val) } inline std::string* MapFieldEntry::_internal_mutable_val() { _has_bits_[0] |= 0x00000002u; return val_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* MapFieldEntry::release_val() { // @@protoc_insertion_point(field_release:caffe2.MapFieldEntry.val) if (!_internal_has_val()) { return nullptr; } _has_bits_[0] &= ~0x00000002u; return val_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void MapFieldEntry::set_allocated_val(std::string* val) { if (val != nullptr) { _has_bits_[0] |= 0x00000002u; } else { _has_bits_[0] &= ~0x00000002u; } val_.SetAllocated(&GetEmptyStringAlreadyInited(), val, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.MapFieldEntry.val) } // ------------------------------------------------------------------- // BackendOptions // required string backend_name = 1; inline bool BackendOptions::_internal_has_backend_name() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool BackendOptions::has_backend_name() const { return _internal_has_backend_name(); } inline void BackendOptions::clear_backend_name() { backend_name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& BackendOptions::backend_name() const { // @@protoc_insertion_point(field_get:caffe2.BackendOptions.backend_name) return _internal_backend_name(); } inline void BackendOptions::set_backend_name(const std::string& value) { _internal_set_backend_name(value); // @@protoc_insertion_point(field_set:caffe2.BackendOptions.backend_name) } inline std::string* BackendOptions::mutable_backend_name() { // @@protoc_insertion_point(field_mutable:caffe2.BackendOptions.backend_name) return _internal_mutable_backend_name(); } inline const std::string& BackendOptions::_internal_backend_name() const { return backend_name_.Get(); } inline void BackendOptions::_internal_set_backend_name(const std::string& value) { _has_bits_[0] |= 0x00000001u; backend_name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void BackendOptions::set_backend_name(std::string&& value) { _has_bits_[0] |= 0x00000001u; backend_name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.BackendOptions.backend_name) } inline void BackendOptions::set_backend_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; backend_name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.BackendOptions.backend_name) } inline void BackendOptions::set_backend_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; backend_name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.BackendOptions.backend_name) } inline std::string* BackendOptions::_internal_mutable_backend_name() { _has_bits_[0] |= 0x00000001u; return backend_name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* BackendOptions::release_backend_name() { // @@protoc_insertion_point(field_release:caffe2.BackendOptions.backend_name) if (!_internal_has_backend_name()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return backend_name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void BackendOptions::set_allocated_backend_name(std::string* backend_name) { if (backend_name != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } backend_name_.SetAllocated(&GetEmptyStringAlreadyInited(), backend_name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.BackendOptions.backend_name) } // repeated .caffe2.MapFieldEntry option = 2; inline int BackendOptions::_internal_option_size() const { return option_.size(); } inline int BackendOptions::option_size() const { return _internal_option_size(); } inline void BackendOptions::clear_option() { option_.Clear(); } inline ::caffe2::MapFieldEntry* BackendOptions::mutable_option(int index) { // @@protoc_insertion_point(field_mutable:caffe2.BackendOptions.option) return option_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry >* BackendOptions::mutable_option() { // @@protoc_insertion_point(field_mutable_list:caffe2.BackendOptions.option) return &option_; } inline const ::caffe2::MapFieldEntry& BackendOptions::_internal_option(int index) const { return option_.Get(index); } inline const ::caffe2::MapFieldEntry& BackendOptions::option(int index) const { // @@protoc_insertion_point(field_get:caffe2.BackendOptions.option) return _internal_option(index); } inline ::caffe2::MapFieldEntry* BackendOptions::_internal_add_option() { return option_.Add(); } inline ::caffe2::MapFieldEntry* BackendOptions::add_option() { // @@protoc_insertion_point(field_add:caffe2.BackendOptions.option) return _internal_add_option(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::MapFieldEntry >& BackendOptions::option() const { // @@protoc_insertion_point(field_list:caffe2.BackendOptions.option) return option_; } // ------------------------------------------------------------------- // PartitionInfo // required string name = 1; inline bool PartitionInfo::_internal_has_name() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool PartitionInfo::has_name() const { return _internal_has_name(); } inline void PartitionInfo::clear_name() { name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& PartitionInfo::name() const { // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.name) return _internal_name(); } inline void PartitionInfo::set_name(const std::string& value) { _internal_set_name(value); // @@protoc_insertion_point(field_set:caffe2.PartitionInfo.name) } inline std::string* PartitionInfo::mutable_name() { // @@protoc_insertion_point(field_mutable:caffe2.PartitionInfo.name) return _internal_mutable_name(); } inline const std::string& PartitionInfo::_internal_name() const { return name_.Get(); } inline void PartitionInfo::_internal_set_name(const std::string& value) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void PartitionInfo::set_name(std::string&& value) { _has_bits_[0] |= 0x00000001u; name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.PartitionInfo.name) } inline void PartitionInfo::set_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.PartitionInfo.name) } inline void PartitionInfo::set_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.PartitionInfo.name) } inline std::string* PartitionInfo::_internal_mutable_name() { _has_bits_[0] |= 0x00000001u; return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* PartitionInfo::release_name() { // @@protoc_insertion_point(field_release:caffe2.PartitionInfo.name) if (!_internal_has_name()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void PartitionInfo::set_allocated_name(std::string* name) { if (name != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } name_.SetAllocated(&GetEmptyStringAlreadyInited(), name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.PartitionInfo.name) } // repeated int32 device_id = 2; inline int PartitionInfo::_internal_device_id_size() const { return device_id_.size(); } inline int PartitionInfo::device_id_size() const { return _internal_device_id_size(); } inline void PartitionInfo::clear_device_id() { device_id_.Clear(); } inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionInfo::_internal_device_id(int index) const { return device_id_.Get(index); } inline ::PROTOBUF_NAMESPACE_ID::int32 PartitionInfo::device_id(int index) const { // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.device_id) return _internal_device_id(index); } inline void PartitionInfo::set_device_id(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { device_id_.Set(index, value); // @@protoc_insertion_point(field_set:caffe2.PartitionInfo.device_id) } inline void PartitionInfo::_internal_add_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) { device_id_.Add(value); } inline void PartitionInfo::add_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_add_device_id(value); // @@protoc_insertion_point(field_add:caffe2.PartitionInfo.device_id) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& PartitionInfo::_internal_device_id() const { return device_id_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& PartitionInfo::device_id() const { // @@protoc_insertion_point(field_list:caffe2.PartitionInfo.device_id) return _internal_device_id(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* PartitionInfo::_internal_mutable_device_id() { return &device_id_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* PartitionInfo::mutable_device_id() { // @@protoc_insertion_point(field_mutable_list:caffe2.PartitionInfo.device_id) return _internal_mutable_device_id(); } // optional string extra_info = 3; inline bool PartitionInfo::_internal_has_extra_info() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool PartitionInfo::has_extra_info() const { return _internal_has_extra_info(); } inline void PartitionInfo::clear_extra_info() { extra_info_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000002u; } inline const std::string& PartitionInfo::extra_info() const { // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.extra_info) return _internal_extra_info(); } inline void PartitionInfo::set_extra_info(const std::string& value) { _internal_set_extra_info(value); // @@protoc_insertion_point(field_set:caffe2.PartitionInfo.extra_info) } inline std::string* PartitionInfo::mutable_extra_info() { // @@protoc_insertion_point(field_mutable:caffe2.PartitionInfo.extra_info) return _internal_mutable_extra_info(); } inline const std::string& PartitionInfo::_internal_extra_info() const { return extra_info_.Get(); } inline void PartitionInfo::_internal_set_extra_info(const std::string& value) { _has_bits_[0] |= 0x00000002u; extra_info_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void PartitionInfo::set_extra_info(std::string&& value) { _has_bits_[0] |= 0x00000002u; extra_info_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.PartitionInfo.extra_info) } inline void PartitionInfo::set_extra_info(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000002u; extra_info_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.PartitionInfo.extra_info) } inline void PartitionInfo::set_extra_info(const char* value, size_t size) { _has_bits_[0] |= 0x00000002u; extra_info_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.PartitionInfo.extra_info) } inline std::string* PartitionInfo::_internal_mutable_extra_info() { _has_bits_[0] |= 0x00000002u; return extra_info_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* PartitionInfo::release_extra_info() { // @@protoc_insertion_point(field_release:caffe2.PartitionInfo.extra_info) if (!_internal_has_extra_info()) { return nullptr; } _has_bits_[0] &= ~0x00000002u; return extra_info_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void PartitionInfo::set_allocated_extra_info(std::string* extra_info) { if (extra_info != nullptr) { _has_bits_[0] |= 0x00000002u; } else { _has_bits_[0] &= ~0x00000002u; } extra_info_.SetAllocated(&GetEmptyStringAlreadyInited(), extra_info, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.PartitionInfo.extra_info) } // repeated .caffe2.BackendOptions backend_options = 4; inline int PartitionInfo::_internal_backend_options_size() const { return backend_options_.size(); } inline int PartitionInfo::backend_options_size() const { return _internal_backend_options_size(); } inline void PartitionInfo::clear_backend_options() { backend_options_.Clear(); } inline ::caffe2::BackendOptions* PartitionInfo::mutable_backend_options(int index) { // @@protoc_insertion_point(field_mutable:caffe2.PartitionInfo.backend_options) return backend_options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions >* PartitionInfo::mutable_backend_options() { // @@protoc_insertion_point(field_mutable_list:caffe2.PartitionInfo.backend_options) return &backend_options_; } inline const ::caffe2::BackendOptions& PartitionInfo::_internal_backend_options(int index) const { return backend_options_.Get(index); } inline const ::caffe2::BackendOptions& PartitionInfo::backend_options(int index) const { // @@protoc_insertion_point(field_get:caffe2.PartitionInfo.backend_options) return _internal_backend_options(index); } inline ::caffe2::BackendOptions* PartitionInfo::_internal_add_backend_options() { return backend_options_.Add(); } inline ::caffe2::BackendOptions* PartitionInfo::add_backend_options() { // @@protoc_insertion_point(field_add:caffe2.PartitionInfo.backend_options) return _internal_add_backend_options(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BackendOptions >& PartitionInfo::backend_options() const { // @@protoc_insertion_point(field_list:caffe2.PartitionInfo.backend_options) return backend_options_; } // ------------------------------------------------------------------- // NetDef // optional string name = 1; inline bool NetDef::_internal_has_name() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool NetDef::has_name() const { return _internal_has_name(); } inline void NetDef::clear_name() { name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& NetDef::name() const { // @@protoc_insertion_point(field_get:caffe2.NetDef.name) return _internal_name(); } inline void NetDef::set_name(const std::string& value) { _internal_set_name(value); // @@protoc_insertion_point(field_set:caffe2.NetDef.name) } inline std::string* NetDef::mutable_name() { // @@protoc_insertion_point(field_mutable:caffe2.NetDef.name) return _internal_mutable_name(); } inline const std::string& NetDef::_internal_name() const { return name_.Get(); } inline void NetDef::_internal_set_name(const std::string& value) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void NetDef::set_name(std::string&& value) { _has_bits_[0] |= 0x00000001u; name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.NetDef.name) } inline void NetDef::set_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.NetDef.name) } inline void NetDef::set_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.name) } inline std::string* NetDef::_internal_mutable_name() { _has_bits_[0] |= 0x00000001u; return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* NetDef::release_name() { // @@protoc_insertion_point(field_release:caffe2.NetDef.name) if (!_internal_has_name()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void NetDef::set_allocated_name(std::string* name) { if (name != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } name_.SetAllocated(&GetEmptyStringAlreadyInited(), name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.NetDef.name) } // repeated .caffe2.OperatorDef op = 2; inline int NetDef::_internal_op_size() const { return op_.size(); } inline int NetDef::op_size() const { return _internal_op_size(); } inline void NetDef::clear_op() { op_.Clear(); } inline ::caffe2::OperatorDef* NetDef::mutable_op(int index) { // @@protoc_insertion_point(field_mutable:caffe2.NetDef.op) return op_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef >* NetDef::mutable_op() { // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.op) return &op_; } inline const ::caffe2::OperatorDef& NetDef::_internal_op(int index) const { return op_.Get(index); } inline const ::caffe2::OperatorDef& NetDef::op(int index) const { // @@protoc_insertion_point(field_get:caffe2.NetDef.op) return _internal_op(index); } inline ::caffe2::OperatorDef* NetDef::_internal_add_op() { return op_.Add(); } inline ::caffe2::OperatorDef* NetDef::add_op() { // @@protoc_insertion_point(field_add:caffe2.NetDef.op) return _internal_add_op(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::OperatorDef >& NetDef::op() const { // @@protoc_insertion_point(field_list:caffe2.NetDef.op) return op_; } // optional string type = 3; inline bool NetDef::_internal_has_type() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool NetDef::has_type() const { return _internal_has_type(); } inline void NetDef::clear_type() { type_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000002u; } inline const std::string& NetDef::type() const { // @@protoc_insertion_point(field_get:caffe2.NetDef.type) return _internal_type(); } inline void NetDef::set_type(const std::string& value) { _internal_set_type(value); // @@protoc_insertion_point(field_set:caffe2.NetDef.type) } inline std::string* NetDef::mutable_type() { // @@protoc_insertion_point(field_mutable:caffe2.NetDef.type) return _internal_mutable_type(); } inline const std::string& NetDef::_internal_type() const { return type_.Get(); } inline void NetDef::_internal_set_type(const std::string& value) { _has_bits_[0] |= 0x00000002u; type_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void NetDef::set_type(std::string&& value) { _has_bits_[0] |= 0x00000002u; type_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.NetDef.type) } inline void NetDef::set_type(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000002u; type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.NetDef.type) } inline void NetDef::set_type(const char* value, size_t size) { _has_bits_[0] |= 0x00000002u; type_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.type) } inline std::string* NetDef::_internal_mutable_type() { _has_bits_[0] |= 0x00000002u; return type_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* NetDef::release_type() { // @@protoc_insertion_point(field_release:caffe2.NetDef.type) if (!_internal_has_type()) { return nullptr; } _has_bits_[0] &= ~0x00000002u; return type_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void NetDef::set_allocated_type(std::string* type) { if (type != nullptr) { _has_bits_[0] |= 0x00000002u; } else { _has_bits_[0] &= ~0x00000002u; } type_.SetAllocated(&GetEmptyStringAlreadyInited(), type, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.NetDef.type) } // optional int32 num_workers = 4; inline bool NetDef::_internal_has_num_workers() const { bool value = (_has_bits_[0] & 0x00000008u) != 0; return value; } inline bool NetDef::has_num_workers() const { return _internal_has_num_workers(); } inline void NetDef::clear_num_workers() { num_workers_ = 0; _has_bits_[0] &= ~0x00000008u; } inline ::PROTOBUF_NAMESPACE_ID::int32 NetDef::_internal_num_workers() const { return num_workers_; } inline ::PROTOBUF_NAMESPACE_ID::int32 NetDef::num_workers() const { // @@protoc_insertion_point(field_get:caffe2.NetDef.num_workers) return _internal_num_workers(); } inline void NetDef::_internal_set_num_workers(::PROTOBUF_NAMESPACE_ID::int32 value) { _has_bits_[0] |= 0x00000008u; num_workers_ = value; } inline void NetDef::set_num_workers(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_num_workers(value); // @@protoc_insertion_point(field_set:caffe2.NetDef.num_workers) } // optional .caffe2.DeviceOption device_option = 5; inline bool NetDef::_internal_has_device_option() const { bool value = (_has_bits_[0] & 0x00000004u) != 0; PROTOBUF_ASSUME(!value || device_option_ != nullptr); return value; } inline bool NetDef::has_device_option() const { return _internal_has_device_option(); } inline void NetDef::clear_device_option() { if (device_option_ != nullptr) device_option_->Clear(); _has_bits_[0] &= ~0x00000004u; } inline const ::caffe2::DeviceOption& NetDef::_internal_device_option() const { const ::caffe2::DeviceOption* p = device_option_; return p != nullptr ? *p : *reinterpret_cast( &::caffe2::_DeviceOption_default_instance_); } inline const ::caffe2::DeviceOption& NetDef::device_option() const { // @@protoc_insertion_point(field_get:caffe2.NetDef.device_option) return _internal_device_option(); } inline void NetDef::unsafe_arena_set_allocated_device_option( ::caffe2::DeviceOption* device_option) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_option_); } device_option_ = device_option; if (device_option) { _has_bits_[0] |= 0x00000004u; } else { _has_bits_[0] &= ~0x00000004u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.NetDef.device_option) } inline ::caffe2::DeviceOption* NetDef::release_device_option() { _has_bits_[0] &= ~0x00000004u; ::caffe2::DeviceOption* temp = device_option_; device_option_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } inline ::caffe2::DeviceOption* NetDef::unsafe_arena_release_device_option() { // @@protoc_insertion_point(field_release:caffe2.NetDef.device_option) _has_bits_[0] &= ~0x00000004u; ::caffe2::DeviceOption* temp = device_option_; device_option_ = nullptr; return temp; } inline ::caffe2::DeviceOption* NetDef::_internal_mutable_device_option() { _has_bits_[0] |= 0x00000004u; if (device_option_ == nullptr) { auto* p = CreateMaybeMessage<::caffe2::DeviceOption>(GetArena()); device_option_ = p; } return device_option_; } inline ::caffe2::DeviceOption* NetDef::mutable_device_option() { // @@protoc_insertion_point(field_mutable:caffe2.NetDef.device_option) return _internal_mutable_device_option(); } inline void NetDef::set_allocated_device_option(::caffe2::DeviceOption* device_option) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete device_option_; } if (device_option) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(device_option); if (message_arena != submessage_arena) { device_option = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, device_option, submessage_arena); } _has_bits_[0] |= 0x00000004u; } else { _has_bits_[0] &= ~0x00000004u; } device_option_ = device_option; // @@protoc_insertion_point(field_set_allocated:caffe2.NetDef.device_option) } // repeated .caffe2.Argument arg = 6; inline int NetDef::_internal_arg_size() const { return arg_.size(); } inline int NetDef::arg_size() const { return _internal_arg_size(); } inline void NetDef::clear_arg() { arg_.Clear(); } inline ::caffe2::Argument* NetDef::mutable_arg(int index) { // @@protoc_insertion_point(field_mutable:caffe2.NetDef.arg) return arg_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >* NetDef::mutable_arg() { // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.arg) return &arg_; } inline const ::caffe2::Argument& NetDef::_internal_arg(int index) const { return arg_.Get(index); } inline const ::caffe2::Argument& NetDef::arg(int index) const { // @@protoc_insertion_point(field_get:caffe2.NetDef.arg) return _internal_arg(index); } inline ::caffe2::Argument* NetDef::_internal_add_arg() { return arg_.Add(); } inline ::caffe2::Argument* NetDef::add_arg() { // @@protoc_insertion_point(field_add:caffe2.NetDef.arg) return _internal_add_arg(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::Argument >& NetDef::arg() const { // @@protoc_insertion_point(field_list:caffe2.NetDef.arg) return arg_; } // repeated string external_input = 7; inline int NetDef::_internal_external_input_size() const { return external_input_.size(); } inline int NetDef::external_input_size() const { return _internal_external_input_size(); } inline void NetDef::clear_external_input() { external_input_.Clear(); } inline std::string* NetDef::add_external_input() { // @@protoc_insertion_point(field_add_mutable:caffe2.NetDef.external_input) return _internal_add_external_input(); } inline const std::string& NetDef::_internal_external_input(int index) const { return external_input_.Get(index); } inline const std::string& NetDef::external_input(int index) const { // @@protoc_insertion_point(field_get:caffe2.NetDef.external_input) return _internal_external_input(index); } inline std::string* NetDef::mutable_external_input(int index) { // @@protoc_insertion_point(field_mutable:caffe2.NetDef.external_input) return external_input_.Mutable(index); } inline void NetDef::set_external_input(int index, const std::string& value) { // @@protoc_insertion_point(field_set:caffe2.NetDef.external_input) external_input_.Mutable(index)->assign(value); } inline void NetDef::set_external_input(int index, std::string&& value) { // @@protoc_insertion_point(field_set:caffe2.NetDef.external_input) external_input_.Mutable(index)->assign(std::move(value)); } inline void NetDef::set_external_input(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); external_input_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:caffe2.NetDef.external_input) } inline void NetDef::set_external_input(int index, const char* value, size_t size) { external_input_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.external_input) } inline std::string* NetDef::_internal_add_external_input() { return external_input_.Add(); } inline void NetDef::add_external_input(const std::string& value) { external_input_.Add()->assign(value); // @@protoc_insertion_point(field_add:caffe2.NetDef.external_input) } inline void NetDef::add_external_input(std::string&& value) { external_input_.Add(std::move(value)); // @@protoc_insertion_point(field_add:caffe2.NetDef.external_input) } inline void NetDef::add_external_input(const char* value) { GOOGLE_DCHECK(value != nullptr); external_input_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:caffe2.NetDef.external_input) } inline void NetDef::add_external_input(const char* value, size_t size) { external_input_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:caffe2.NetDef.external_input) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& NetDef::external_input() const { // @@protoc_insertion_point(field_list:caffe2.NetDef.external_input) return external_input_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* NetDef::mutable_external_input() { // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.external_input) return &external_input_; } // repeated string external_output = 8; inline int NetDef::_internal_external_output_size() const { return external_output_.size(); } inline int NetDef::external_output_size() const { return _internal_external_output_size(); } inline void NetDef::clear_external_output() { external_output_.Clear(); } inline std::string* NetDef::add_external_output() { // @@protoc_insertion_point(field_add_mutable:caffe2.NetDef.external_output) return _internal_add_external_output(); } inline const std::string& NetDef::_internal_external_output(int index) const { return external_output_.Get(index); } inline const std::string& NetDef::external_output(int index) const { // @@protoc_insertion_point(field_get:caffe2.NetDef.external_output) return _internal_external_output(index); } inline std::string* NetDef::mutable_external_output(int index) { // @@protoc_insertion_point(field_mutable:caffe2.NetDef.external_output) return external_output_.Mutable(index); } inline void NetDef::set_external_output(int index, const std::string& value) { // @@protoc_insertion_point(field_set:caffe2.NetDef.external_output) external_output_.Mutable(index)->assign(value); } inline void NetDef::set_external_output(int index, std::string&& value) { // @@protoc_insertion_point(field_set:caffe2.NetDef.external_output) external_output_.Mutable(index)->assign(std::move(value)); } inline void NetDef::set_external_output(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); external_output_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:caffe2.NetDef.external_output) } inline void NetDef::set_external_output(int index, const char* value, size_t size) { external_output_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:caffe2.NetDef.external_output) } inline std::string* NetDef::_internal_add_external_output() { return external_output_.Add(); } inline void NetDef::add_external_output(const std::string& value) { external_output_.Add()->assign(value); // @@protoc_insertion_point(field_add:caffe2.NetDef.external_output) } inline void NetDef::add_external_output(std::string&& value) { external_output_.Add(std::move(value)); // @@protoc_insertion_point(field_add:caffe2.NetDef.external_output) } inline void NetDef::add_external_output(const char* value) { GOOGLE_DCHECK(value != nullptr); external_output_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:caffe2.NetDef.external_output) } inline void NetDef::add_external_output(const char* value, size_t size) { external_output_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:caffe2.NetDef.external_output) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& NetDef::external_output() const { // @@protoc_insertion_point(field_list:caffe2.NetDef.external_output) return external_output_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* NetDef::mutable_external_output() { // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.external_output) return &external_output_; } // repeated .caffe2.PartitionInfo partition_info = 9; inline int NetDef::_internal_partition_info_size() const { return partition_info_.size(); } inline int NetDef::partition_info_size() const { return _internal_partition_info_size(); } inline void NetDef::clear_partition_info() { partition_info_.Clear(); } inline ::caffe2::PartitionInfo* NetDef::mutable_partition_info(int index) { // @@protoc_insertion_point(field_mutable:caffe2.NetDef.partition_info) return partition_info_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo >* NetDef::mutable_partition_info() { // @@protoc_insertion_point(field_mutable_list:caffe2.NetDef.partition_info) return &partition_info_; } inline const ::caffe2::PartitionInfo& NetDef::_internal_partition_info(int index) const { return partition_info_.Get(index); } inline const ::caffe2::PartitionInfo& NetDef::partition_info(int index) const { // @@protoc_insertion_point(field_get:caffe2.NetDef.partition_info) return _internal_partition_info(index); } inline ::caffe2::PartitionInfo* NetDef::_internal_add_partition_info() { return partition_info_.Add(); } inline ::caffe2::PartitionInfo* NetDef::add_partition_info() { // @@protoc_insertion_point(field_add:caffe2.NetDef.partition_info) return _internal_add_partition_info(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::PartitionInfo >& NetDef::partition_info() const { // @@protoc_insertion_point(field_list:caffe2.NetDef.partition_info) return partition_info_; } // ------------------------------------------------------------------- // ExecutionStep // optional string name = 1; inline bool ExecutionStep::_internal_has_name() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool ExecutionStep::has_name() const { return _internal_has_name(); } inline void ExecutionStep::clear_name() { name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& ExecutionStep::name() const { // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.name) return _internal_name(); } inline void ExecutionStep::set_name(const std::string& value) { _internal_set_name(value); // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.name) } inline std::string* ExecutionStep::mutable_name() { // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.name) return _internal_mutable_name(); } inline const std::string& ExecutionStep::_internal_name() const { return name_.Get(); } inline void ExecutionStep::_internal_set_name(const std::string& value) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void ExecutionStep::set_name(std::string&& value) { _has_bits_[0] |= 0x00000001u; name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.ExecutionStep.name) } inline void ExecutionStep::set_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.name) } inline void ExecutionStep::set_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.name) } inline std::string* ExecutionStep::_internal_mutable_name() { _has_bits_[0] |= 0x00000001u; return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* ExecutionStep::release_name() { // @@protoc_insertion_point(field_release:caffe2.ExecutionStep.name) if (!_internal_has_name()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void ExecutionStep::set_allocated_name(std::string* name) { if (name != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } name_.SetAllocated(&GetEmptyStringAlreadyInited(), name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.name) } // repeated .caffe2.ExecutionStep substep = 2; inline int ExecutionStep::_internal_substep_size() const { return substep_.size(); } inline int ExecutionStep::substep_size() const { return _internal_substep_size(); } inline void ExecutionStep::clear_substep() { substep_.Clear(); } inline ::caffe2::ExecutionStep* ExecutionStep::mutable_substep(int index) { // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.substep) return substep_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >* ExecutionStep::mutable_substep() { // @@protoc_insertion_point(field_mutable_list:caffe2.ExecutionStep.substep) return &substep_; } inline const ::caffe2::ExecutionStep& ExecutionStep::_internal_substep(int index) const { return substep_.Get(index); } inline const ::caffe2::ExecutionStep& ExecutionStep::substep(int index) const { // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.substep) return _internal_substep(index); } inline ::caffe2::ExecutionStep* ExecutionStep::_internal_add_substep() { return substep_.Add(); } inline ::caffe2::ExecutionStep* ExecutionStep::add_substep() { // @@protoc_insertion_point(field_add:caffe2.ExecutionStep.substep) return _internal_add_substep(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >& ExecutionStep::substep() const { // @@protoc_insertion_point(field_list:caffe2.ExecutionStep.substep) return substep_; } // repeated string network = 3; inline int ExecutionStep::_internal_network_size() const { return network_.size(); } inline int ExecutionStep::network_size() const { return _internal_network_size(); } inline void ExecutionStep::clear_network() { network_.Clear(); } inline std::string* ExecutionStep::add_network() { // @@protoc_insertion_point(field_add_mutable:caffe2.ExecutionStep.network) return _internal_add_network(); } inline const std::string& ExecutionStep::_internal_network(int index) const { return network_.Get(index); } inline const std::string& ExecutionStep::network(int index) const { // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.network) return _internal_network(index); } inline std::string* ExecutionStep::mutable_network(int index) { // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.network) return network_.Mutable(index); } inline void ExecutionStep::set_network(int index, const std::string& value) { // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.network) network_.Mutable(index)->assign(value); } inline void ExecutionStep::set_network(int index, std::string&& value) { // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.network) network_.Mutable(index)->assign(std::move(value)); } inline void ExecutionStep::set_network(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); network_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.network) } inline void ExecutionStep::set_network(int index, const char* value, size_t size) { network_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.network) } inline std::string* ExecutionStep::_internal_add_network() { return network_.Add(); } inline void ExecutionStep::add_network(const std::string& value) { network_.Add()->assign(value); // @@protoc_insertion_point(field_add:caffe2.ExecutionStep.network) } inline void ExecutionStep::add_network(std::string&& value) { network_.Add(std::move(value)); // @@protoc_insertion_point(field_add:caffe2.ExecutionStep.network) } inline void ExecutionStep::add_network(const char* value) { GOOGLE_DCHECK(value != nullptr); network_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:caffe2.ExecutionStep.network) } inline void ExecutionStep::add_network(const char* value, size_t size) { network_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:caffe2.ExecutionStep.network) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& ExecutionStep::network() const { // @@protoc_insertion_point(field_list:caffe2.ExecutionStep.network) return network_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* ExecutionStep::mutable_network() { // @@protoc_insertion_point(field_mutable_list:caffe2.ExecutionStep.network) return &network_; } // optional int64 num_iter = 4; inline bool ExecutionStep::_internal_has_num_iter() const { bool value = (_has_bits_[0] & 0x00000010u) != 0; return value; } inline bool ExecutionStep::has_num_iter() const { return _internal_has_num_iter(); } inline void ExecutionStep::clear_num_iter() { num_iter_ = PROTOBUF_LONGLONG(0); _has_bits_[0] &= ~0x00000010u; } inline ::PROTOBUF_NAMESPACE_ID::int64 ExecutionStep::_internal_num_iter() const { return num_iter_; } inline ::PROTOBUF_NAMESPACE_ID::int64 ExecutionStep::num_iter() const { // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.num_iter) return _internal_num_iter(); } inline void ExecutionStep::_internal_set_num_iter(::PROTOBUF_NAMESPACE_ID::int64 value) { _has_bits_[0] |= 0x00000010u; num_iter_ = value; } inline void ExecutionStep::set_num_iter(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_num_iter(value); // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.num_iter) } // optional string criteria_network = 5 [deprecated = true]; inline bool ExecutionStep::_internal_has_criteria_network() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool ExecutionStep::has_criteria_network() const { return _internal_has_criteria_network(); } inline void ExecutionStep::clear_criteria_network() { criteria_network_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000002u; } inline const std::string& ExecutionStep::criteria_network() const { // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.criteria_network) return _internal_criteria_network(); } inline void ExecutionStep::set_criteria_network(const std::string& value) { _internal_set_criteria_network(value); // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.criteria_network) } inline std::string* ExecutionStep::mutable_criteria_network() { // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.criteria_network) return _internal_mutable_criteria_network(); } inline const std::string& ExecutionStep::_internal_criteria_network() const { return criteria_network_.Get(); } inline void ExecutionStep::_internal_set_criteria_network(const std::string& value) { _has_bits_[0] |= 0x00000002u; criteria_network_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void ExecutionStep::set_criteria_network(std::string&& value) { _has_bits_[0] |= 0x00000002u; criteria_network_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.ExecutionStep.criteria_network) } inline void ExecutionStep::set_criteria_network(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000002u; criteria_network_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.criteria_network) } inline void ExecutionStep::set_criteria_network(const char* value, size_t size) { _has_bits_[0] |= 0x00000002u; criteria_network_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.criteria_network) } inline std::string* ExecutionStep::_internal_mutable_criteria_network() { _has_bits_[0] |= 0x00000002u; return criteria_network_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* ExecutionStep::release_criteria_network() { // @@protoc_insertion_point(field_release:caffe2.ExecutionStep.criteria_network) if (!_internal_has_criteria_network()) { return nullptr; } _has_bits_[0] &= ~0x00000002u; return criteria_network_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void ExecutionStep::set_allocated_criteria_network(std::string* criteria_network) { if (criteria_network != nullptr) { _has_bits_[0] |= 0x00000002u; } else { _has_bits_[0] &= ~0x00000002u; } criteria_network_.SetAllocated(&GetEmptyStringAlreadyInited(), criteria_network, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.criteria_network) } // optional string report_net = 7; inline bool ExecutionStep::_internal_has_report_net() const { bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool ExecutionStep::has_report_net() const { return _internal_has_report_net(); } inline void ExecutionStep::clear_report_net() { report_net_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000004u; } inline const std::string& ExecutionStep::report_net() const { // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.report_net) return _internal_report_net(); } inline void ExecutionStep::set_report_net(const std::string& value) { _internal_set_report_net(value); // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.report_net) } inline std::string* ExecutionStep::mutable_report_net() { // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.report_net) return _internal_mutable_report_net(); } inline const std::string& ExecutionStep::_internal_report_net() const { return report_net_.Get(); } inline void ExecutionStep::_internal_set_report_net(const std::string& value) { _has_bits_[0] |= 0x00000004u; report_net_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void ExecutionStep::set_report_net(std::string&& value) { _has_bits_[0] |= 0x00000004u; report_net_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.ExecutionStep.report_net) } inline void ExecutionStep::set_report_net(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000004u; report_net_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.report_net) } inline void ExecutionStep::set_report_net(const char* value, size_t size) { _has_bits_[0] |= 0x00000004u; report_net_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.report_net) } inline std::string* ExecutionStep::_internal_mutable_report_net() { _has_bits_[0] |= 0x00000004u; return report_net_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* ExecutionStep::release_report_net() { // @@protoc_insertion_point(field_release:caffe2.ExecutionStep.report_net) if (!_internal_has_report_net()) { return nullptr; } _has_bits_[0] &= ~0x00000004u; return report_net_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void ExecutionStep::set_allocated_report_net(std::string* report_net) { if (report_net != nullptr) { _has_bits_[0] |= 0x00000004u; } else { _has_bits_[0] &= ~0x00000004u; } report_net_.SetAllocated(&GetEmptyStringAlreadyInited(), report_net, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.report_net) } // optional int32 report_interval = 8; inline bool ExecutionStep::_internal_has_report_interval() const { bool value = (_has_bits_[0] & 0x00000020u) != 0; return value; } inline bool ExecutionStep::has_report_interval() const { return _internal_has_report_interval(); } inline void ExecutionStep::clear_report_interval() { report_interval_ = 0; _has_bits_[0] &= ~0x00000020u; } inline ::PROTOBUF_NAMESPACE_ID::int32 ExecutionStep::_internal_report_interval() const { return report_interval_; } inline ::PROTOBUF_NAMESPACE_ID::int32 ExecutionStep::report_interval() const { // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.report_interval) return _internal_report_interval(); } inline void ExecutionStep::_internal_set_report_interval(::PROTOBUF_NAMESPACE_ID::int32 value) { _has_bits_[0] |= 0x00000020u; report_interval_ = value; } inline void ExecutionStep::set_report_interval(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_report_interval(value); // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.report_interval) } // optional int64 run_every_ms = 11; inline bool ExecutionStep::_internal_has_run_every_ms() const { bool value = (_has_bits_[0] & 0x00000200u) != 0; return value; } inline bool ExecutionStep::has_run_every_ms() const { return _internal_has_run_every_ms(); } inline void ExecutionStep::clear_run_every_ms() { run_every_ms_ = PROTOBUF_LONGLONG(0); _has_bits_[0] &= ~0x00000200u; } inline ::PROTOBUF_NAMESPACE_ID::int64 ExecutionStep::_internal_run_every_ms() const { return run_every_ms_; } inline ::PROTOBUF_NAMESPACE_ID::int64 ExecutionStep::run_every_ms() const { // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.run_every_ms) return _internal_run_every_ms(); } inline void ExecutionStep::_internal_set_run_every_ms(::PROTOBUF_NAMESPACE_ID::int64 value) { _has_bits_[0] |= 0x00000200u; run_every_ms_ = value; } inline void ExecutionStep::set_run_every_ms(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_run_every_ms(value); // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.run_every_ms) } // optional bool concurrent_substeps = 6; inline bool ExecutionStep::_internal_has_concurrent_substeps() const { bool value = (_has_bits_[0] & 0x00000040u) != 0; return value; } inline bool ExecutionStep::has_concurrent_substeps() const { return _internal_has_concurrent_substeps(); } inline void ExecutionStep::clear_concurrent_substeps() { concurrent_substeps_ = false; _has_bits_[0] &= ~0x00000040u; } inline bool ExecutionStep::_internal_concurrent_substeps() const { return concurrent_substeps_; } inline bool ExecutionStep::concurrent_substeps() const { // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.concurrent_substeps) return _internal_concurrent_substeps(); } inline void ExecutionStep::_internal_set_concurrent_substeps(bool value) { _has_bits_[0] |= 0x00000040u; concurrent_substeps_ = value; } inline void ExecutionStep::set_concurrent_substeps(bool value) { _internal_set_concurrent_substeps(value); // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.concurrent_substeps) } // optional string should_stop_blob = 9; inline bool ExecutionStep::_internal_has_should_stop_blob() const { bool value = (_has_bits_[0] & 0x00000008u) != 0; return value; } inline bool ExecutionStep::has_should_stop_blob() const { return _internal_has_should_stop_blob(); } inline void ExecutionStep::clear_should_stop_blob() { should_stop_blob_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000008u; } inline const std::string& ExecutionStep::should_stop_blob() const { // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.should_stop_blob) return _internal_should_stop_blob(); } inline void ExecutionStep::set_should_stop_blob(const std::string& value) { _internal_set_should_stop_blob(value); // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.should_stop_blob) } inline std::string* ExecutionStep::mutable_should_stop_blob() { // @@protoc_insertion_point(field_mutable:caffe2.ExecutionStep.should_stop_blob) return _internal_mutable_should_stop_blob(); } inline const std::string& ExecutionStep::_internal_should_stop_blob() const { return should_stop_blob_.Get(); } inline void ExecutionStep::_internal_set_should_stop_blob(const std::string& value) { _has_bits_[0] |= 0x00000008u; should_stop_blob_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void ExecutionStep::set_should_stop_blob(std::string&& value) { _has_bits_[0] |= 0x00000008u; should_stop_blob_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.ExecutionStep.should_stop_blob) } inline void ExecutionStep::set_should_stop_blob(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000008u; should_stop_blob_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.ExecutionStep.should_stop_blob) } inline void ExecutionStep::set_should_stop_blob(const char* value, size_t size) { _has_bits_[0] |= 0x00000008u; should_stop_blob_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.ExecutionStep.should_stop_blob) } inline std::string* ExecutionStep::_internal_mutable_should_stop_blob() { _has_bits_[0] |= 0x00000008u; return should_stop_blob_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* ExecutionStep::release_should_stop_blob() { // @@protoc_insertion_point(field_release:caffe2.ExecutionStep.should_stop_blob) if (!_internal_has_should_stop_blob()) { return nullptr; } _has_bits_[0] &= ~0x00000008u; return should_stop_blob_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void ExecutionStep::set_allocated_should_stop_blob(std::string* should_stop_blob) { if (should_stop_blob != nullptr) { _has_bits_[0] |= 0x00000008u; } else { _has_bits_[0] &= ~0x00000008u; } should_stop_blob_.SetAllocated(&GetEmptyStringAlreadyInited(), should_stop_blob, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.ExecutionStep.should_stop_blob) } // optional bool only_once = 10; inline bool ExecutionStep::_internal_has_only_once() const { bool value = (_has_bits_[0] & 0x00000080u) != 0; return value; } inline bool ExecutionStep::has_only_once() const { return _internal_has_only_once(); } inline void ExecutionStep::clear_only_once() { only_once_ = false; _has_bits_[0] &= ~0x00000080u; } inline bool ExecutionStep::_internal_only_once() const { return only_once_; } inline bool ExecutionStep::only_once() const { // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.only_once) return _internal_only_once(); } inline void ExecutionStep::_internal_set_only_once(bool value) { _has_bits_[0] |= 0x00000080u; only_once_ = value; } inline void ExecutionStep::set_only_once(bool value) { _internal_set_only_once(value); // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.only_once) } // optional bool create_workspace = 12; inline bool ExecutionStep::_internal_has_create_workspace() const { bool value = (_has_bits_[0] & 0x00000100u) != 0; return value; } inline bool ExecutionStep::has_create_workspace() const { return _internal_has_create_workspace(); } inline void ExecutionStep::clear_create_workspace() { create_workspace_ = false; _has_bits_[0] &= ~0x00000100u; } inline bool ExecutionStep::_internal_create_workspace() const { return create_workspace_; } inline bool ExecutionStep::create_workspace() const { // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.create_workspace) return _internal_create_workspace(); } inline void ExecutionStep::_internal_set_create_workspace(bool value) { _has_bits_[0] |= 0x00000100u; create_workspace_ = value; } inline void ExecutionStep::set_create_workspace(bool value) { _internal_set_create_workspace(value); // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.create_workspace) } // optional int32 num_concurrent_instances = 13; inline bool ExecutionStep::_internal_has_num_concurrent_instances() const { bool value = (_has_bits_[0] & 0x00000400u) != 0; return value; } inline bool ExecutionStep::has_num_concurrent_instances() const { return _internal_has_num_concurrent_instances(); } inline void ExecutionStep::clear_num_concurrent_instances() { num_concurrent_instances_ = 0; _has_bits_[0] &= ~0x00000400u; } inline ::PROTOBUF_NAMESPACE_ID::int32 ExecutionStep::_internal_num_concurrent_instances() const { return num_concurrent_instances_; } inline ::PROTOBUF_NAMESPACE_ID::int32 ExecutionStep::num_concurrent_instances() const { // @@protoc_insertion_point(field_get:caffe2.ExecutionStep.num_concurrent_instances) return _internal_num_concurrent_instances(); } inline void ExecutionStep::_internal_set_num_concurrent_instances(::PROTOBUF_NAMESPACE_ID::int32 value) { _has_bits_[0] |= 0x00000400u; num_concurrent_instances_ = value; } inline void ExecutionStep::set_num_concurrent_instances(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_num_concurrent_instances(value); // @@protoc_insertion_point(field_set:caffe2.ExecutionStep.num_concurrent_instances) } // ------------------------------------------------------------------- // PlanDef // optional string name = 1; inline bool PlanDef::_internal_has_name() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool PlanDef::has_name() const { return _internal_has_name(); } inline void PlanDef::clear_name() { name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& PlanDef::name() const { // @@protoc_insertion_point(field_get:caffe2.PlanDef.name) return _internal_name(); } inline void PlanDef::set_name(const std::string& value) { _internal_set_name(value); // @@protoc_insertion_point(field_set:caffe2.PlanDef.name) } inline std::string* PlanDef::mutable_name() { // @@protoc_insertion_point(field_mutable:caffe2.PlanDef.name) return _internal_mutable_name(); } inline const std::string& PlanDef::_internal_name() const { return name_.Get(); } inline void PlanDef::_internal_set_name(const std::string& value) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void PlanDef::set_name(std::string&& value) { _has_bits_[0] |= 0x00000001u; name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.PlanDef.name) } inline void PlanDef::set_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.PlanDef.name) } inline void PlanDef::set_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.PlanDef.name) } inline std::string* PlanDef::_internal_mutable_name() { _has_bits_[0] |= 0x00000001u; return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* PlanDef::release_name() { // @@protoc_insertion_point(field_release:caffe2.PlanDef.name) if (!_internal_has_name()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void PlanDef::set_allocated_name(std::string* name) { if (name != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } name_.SetAllocated(&GetEmptyStringAlreadyInited(), name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.PlanDef.name) } // repeated .caffe2.NetDef network = 2; inline int PlanDef::_internal_network_size() const { return network_.size(); } inline int PlanDef::network_size() const { return _internal_network_size(); } inline void PlanDef::clear_network() { network_.Clear(); } inline ::caffe2::NetDef* PlanDef::mutable_network(int index) { // @@protoc_insertion_point(field_mutable:caffe2.PlanDef.network) return network_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >* PlanDef::mutable_network() { // @@protoc_insertion_point(field_mutable_list:caffe2.PlanDef.network) return &network_; } inline const ::caffe2::NetDef& PlanDef::_internal_network(int index) const { return network_.Get(index); } inline const ::caffe2::NetDef& PlanDef::network(int index) const { // @@protoc_insertion_point(field_get:caffe2.PlanDef.network) return _internal_network(index); } inline ::caffe2::NetDef* PlanDef::_internal_add_network() { return network_.Add(); } inline ::caffe2::NetDef* PlanDef::add_network() { // @@protoc_insertion_point(field_add:caffe2.PlanDef.network) return _internal_add_network(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::NetDef >& PlanDef::network() const { // @@protoc_insertion_point(field_list:caffe2.PlanDef.network) return network_; } // repeated .caffe2.ExecutionStep execution_step = 3; inline int PlanDef::_internal_execution_step_size() const { return execution_step_.size(); } inline int PlanDef::execution_step_size() const { return _internal_execution_step_size(); } inline void PlanDef::clear_execution_step() { execution_step_.Clear(); } inline ::caffe2::ExecutionStep* PlanDef::mutable_execution_step(int index) { // @@protoc_insertion_point(field_mutable:caffe2.PlanDef.execution_step) return execution_step_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >* PlanDef::mutable_execution_step() { // @@protoc_insertion_point(field_mutable_list:caffe2.PlanDef.execution_step) return &execution_step_; } inline const ::caffe2::ExecutionStep& PlanDef::_internal_execution_step(int index) const { return execution_step_.Get(index); } inline const ::caffe2::ExecutionStep& PlanDef::execution_step(int index) const { // @@protoc_insertion_point(field_get:caffe2.PlanDef.execution_step) return _internal_execution_step(index); } inline ::caffe2::ExecutionStep* PlanDef::_internal_add_execution_step() { return execution_step_.Add(); } inline ::caffe2::ExecutionStep* PlanDef::add_execution_step() { // @@protoc_insertion_point(field_add:caffe2.PlanDef.execution_step) return _internal_add_execution_step(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::ExecutionStep >& PlanDef::execution_step() const { // @@protoc_insertion_point(field_list:caffe2.PlanDef.execution_step) return execution_step_; } // ------------------------------------------------------------------- // BlobProto // optional string name = 1; inline bool BlobProto::_internal_has_name() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool BlobProto::has_name() const { return _internal_has_name(); } inline void BlobProto::clear_name() { name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& BlobProto::name() const { // @@protoc_insertion_point(field_get:caffe2.BlobProto.name) return _internal_name(); } inline void BlobProto::set_name(const std::string& value) { _internal_set_name(value); // @@protoc_insertion_point(field_set:caffe2.BlobProto.name) } inline std::string* BlobProto::mutable_name() { // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.name) return _internal_mutable_name(); } inline const std::string& BlobProto::_internal_name() const { return name_.Get(); } inline void BlobProto::_internal_set_name(const std::string& value) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void BlobProto::set_name(std::string&& value) { _has_bits_[0] |= 0x00000001u; name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.BlobProto.name) } inline void BlobProto::set_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.BlobProto.name) } inline void BlobProto::set_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.BlobProto.name) } inline std::string* BlobProto::_internal_mutable_name() { _has_bits_[0] |= 0x00000001u; return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* BlobProto::release_name() { // @@protoc_insertion_point(field_release:caffe2.BlobProto.name) if (!_internal_has_name()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void BlobProto::set_allocated_name(std::string* name) { if (name != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } name_.SetAllocated(&GetEmptyStringAlreadyInited(), name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.name) } // optional string type = 2; inline bool BlobProto::_internal_has_type() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool BlobProto::has_type() const { return _internal_has_type(); } inline void BlobProto::clear_type() { type_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000002u; } inline const std::string& BlobProto::type() const { // @@protoc_insertion_point(field_get:caffe2.BlobProto.type) return _internal_type(); } inline void BlobProto::set_type(const std::string& value) { _internal_set_type(value); // @@protoc_insertion_point(field_set:caffe2.BlobProto.type) } inline std::string* BlobProto::mutable_type() { // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.type) return _internal_mutable_type(); } inline const std::string& BlobProto::_internal_type() const { return type_.Get(); } inline void BlobProto::_internal_set_type(const std::string& value) { _has_bits_[0] |= 0x00000002u; type_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void BlobProto::set_type(std::string&& value) { _has_bits_[0] |= 0x00000002u; type_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.BlobProto.type) } inline void BlobProto::set_type(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000002u; type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.BlobProto.type) } inline void BlobProto::set_type(const char* value, size_t size) { _has_bits_[0] |= 0x00000002u; type_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.BlobProto.type) } inline std::string* BlobProto::_internal_mutable_type() { _has_bits_[0] |= 0x00000002u; return type_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* BlobProto::release_type() { // @@protoc_insertion_point(field_release:caffe2.BlobProto.type) if (!_internal_has_type()) { return nullptr; } _has_bits_[0] &= ~0x00000002u; return type_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void BlobProto::set_allocated_type(std::string* type) { if (type != nullptr) { _has_bits_[0] |= 0x00000002u; } else { _has_bits_[0] &= ~0x00000002u; } type_.SetAllocated(&GetEmptyStringAlreadyInited(), type, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.type) } // optional .caffe2.TensorProto tensor = 3; inline bool BlobProto::_internal_has_tensor() const { bool value = (_has_bits_[0] & 0x00000008u) != 0; PROTOBUF_ASSUME(!value || tensor_ != nullptr); return value; } inline bool BlobProto::has_tensor() const { return _internal_has_tensor(); } inline void BlobProto::clear_tensor() { if (tensor_ != nullptr) tensor_->Clear(); _has_bits_[0] &= ~0x00000008u; } inline const ::caffe2::TensorProto& BlobProto::_internal_tensor() const { const ::caffe2::TensorProto* p = tensor_; return p != nullptr ? *p : *reinterpret_cast( &::caffe2::_TensorProto_default_instance_); } inline const ::caffe2::TensorProto& BlobProto::tensor() const { // @@protoc_insertion_point(field_get:caffe2.BlobProto.tensor) return _internal_tensor(); } inline void BlobProto::unsafe_arena_set_allocated_tensor( ::caffe2::TensorProto* tensor) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor_); } tensor_ = tensor; if (tensor) { _has_bits_[0] |= 0x00000008u; } else { _has_bits_[0] &= ~0x00000008u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.BlobProto.tensor) } inline ::caffe2::TensorProto* BlobProto::release_tensor() { _has_bits_[0] &= ~0x00000008u; ::caffe2::TensorProto* temp = tensor_; tensor_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } inline ::caffe2::TensorProto* BlobProto::unsafe_arena_release_tensor() { // @@protoc_insertion_point(field_release:caffe2.BlobProto.tensor) _has_bits_[0] &= ~0x00000008u; ::caffe2::TensorProto* temp = tensor_; tensor_ = nullptr; return temp; } inline ::caffe2::TensorProto* BlobProto::_internal_mutable_tensor() { _has_bits_[0] |= 0x00000008u; if (tensor_ == nullptr) { auto* p = CreateMaybeMessage<::caffe2::TensorProto>(GetArena()); tensor_ = p; } return tensor_; } inline ::caffe2::TensorProto* BlobProto::mutable_tensor() { // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.tensor) return _internal_mutable_tensor(); } inline void BlobProto::set_allocated_tensor(::caffe2::TensorProto* tensor) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete tensor_; } if (tensor) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tensor); if (message_arena != submessage_arena) { tensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, tensor, submessage_arena); } _has_bits_[0] |= 0x00000008u; } else { _has_bits_[0] &= ~0x00000008u; } tensor_ = tensor; // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.tensor) } // optional bytes content = 4; inline bool BlobProto::_internal_has_content() const { bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool BlobProto::has_content() const { return _internal_has_content(); } inline void BlobProto::clear_content() { content_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000004u; } inline const std::string& BlobProto::content() const { // @@protoc_insertion_point(field_get:caffe2.BlobProto.content) return _internal_content(); } inline void BlobProto::set_content(const std::string& value) { _internal_set_content(value); // @@protoc_insertion_point(field_set:caffe2.BlobProto.content) } inline std::string* BlobProto::mutable_content() { // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.content) return _internal_mutable_content(); } inline const std::string& BlobProto::_internal_content() const { return content_.Get(); } inline void BlobProto::_internal_set_content(const std::string& value) { _has_bits_[0] |= 0x00000004u; content_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void BlobProto::set_content(std::string&& value) { _has_bits_[0] |= 0x00000004u; content_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.BlobProto.content) } inline void BlobProto::set_content(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000004u; content_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.BlobProto.content) } inline void BlobProto::set_content(const void* value, size_t size) { _has_bits_[0] |= 0x00000004u; content_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.BlobProto.content) } inline std::string* BlobProto::_internal_mutable_content() { _has_bits_[0] |= 0x00000004u; return content_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* BlobProto::release_content() { // @@protoc_insertion_point(field_release:caffe2.BlobProto.content) if (!_internal_has_content()) { return nullptr; } _has_bits_[0] &= ~0x00000004u; return content_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void BlobProto::set_allocated_content(std::string* content) { if (content != nullptr) { _has_bits_[0] |= 0x00000004u; } else { _has_bits_[0] &= ~0x00000004u; } content_.SetAllocated(&GetEmptyStringAlreadyInited(), content, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.content) } // optional .caffe2.QTensorProto qtensor = 5; inline bool BlobProto::_internal_has_qtensor() const { bool value = (_has_bits_[0] & 0x00000010u) != 0; PROTOBUF_ASSUME(!value || qtensor_ != nullptr); return value; } inline bool BlobProto::has_qtensor() const { return _internal_has_qtensor(); } inline void BlobProto::clear_qtensor() { if (qtensor_ != nullptr) qtensor_->Clear(); _has_bits_[0] &= ~0x00000010u; } inline const ::caffe2::QTensorProto& BlobProto::_internal_qtensor() const { const ::caffe2::QTensorProto* p = qtensor_; return p != nullptr ? *p : *reinterpret_cast( &::caffe2::_QTensorProto_default_instance_); } inline const ::caffe2::QTensorProto& BlobProto::qtensor() const { // @@protoc_insertion_point(field_get:caffe2.BlobProto.qtensor) return _internal_qtensor(); } inline void BlobProto::unsafe_arena_set_allocated_qtensor( ::caffe2::QTensorProto* qtensor) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(qtensor_); } qtensor_ = qtensor; if (qtensor) { _has_bits_[0] |= 0x00000010u; } else { _has_bits_[0] &= ~0x00000010u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:caffe2.BlobProto.qtensor) } inline ::caffe2::QTensorProto* BlobProto::release_qtensor() { _has_bits_[0] &= ~0x00000010u; ::caffe2::QTensorProto* temp = qtensor_; qtensor_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } inline ::caffe2::QTensorProto* BlobProto::unsafe_arena_release_qtensor() { // @@protoc_insertion_point(field_release:caffe2.BlobProto.qtensor) _has_bits_[0] &= ~0x00000010u; ::caffe2::QTensorProto* temp = qtensor_; qtensor_ = nullptr; return temp; } inline ::caffe2::QTensorProto* BlobProto::_internal_mutable_qtensor() { _has_bits_[0] |= 0x00000010u; if (qtensor_ == nullptr) { auto* p = CreateMaybeMessage<::caffe2::QTensorProto>(GetArena()); qtensor_ = p; } return qtensor_; } inline ::caffe2::QTensorProto* BlobProto::mutable_qtensor() { // @@protoc_insertion_point(field_mutable:caffe2.BlobProto.qtensor) return _internal_mutable_qtensor(); } inline void BlobProto::set_allocated_qtensor(::caffe2::QTensorProto* qtensor) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete qtensor_; } if (qtensor) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(qtensor); if (message_arena != submessage_arena) { qtensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, qtensor, submessage_arena); } _has_bits_[0] |= 0x00000010u; } else { _has_bits_[0] &= ~0x00000010u; } qtensor_ = qtensor; // @@protoc_insertion_point(field_set_allocated:caffe2.BlobProto.qtensor) } // optional int32 content_num_chunks = 6; inline bool BlobProto::_internal_has_content_num_chunks() const { bool value = (_has_bits_[0] & 0x00000020u) != 0; return value; } inline bool BlobProto::has_content_num_chunks() const { return _internal_has_content_num_chunks(); } inline void BlobProto::clear_content_num_chunks() { content_num_chunks_ = 0; _has_bits_[0] &= ~0x00000020u; } inline ::PROTOBUF_NAMESPACE_ID::int32 BlobProto::_internal_content_num_chunks() const { return content_num_chunks_; } inline ::PROTOBUF_NAMESPACE_ID::int32 BlobProto::content_num_chunks() const { // @@protoc_insertion_point(field_get:caffe2.BlobProto.content_num_chunks) return _internal_content_num_chunks(); } inline void BlobProto::_internal_set_content_num_chunks(::PROTOBUF_NAMESPACE_ID::int32 value) { _has_bits_[0] |= 0x00000020u; content_num_chunks_ = value; } inline void BlobProto::set_content_num_chunks(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_content_num_chunks(value); // @@protoc_insertion_point(field_set:caffe2.BlobProto.content_num_chunks) } // optional int32 content_chunk_id = 7; inline bool BlobProto::_internal_has_content_chunk_id() const { bool value = (_has_bits_[0] & 0x00000040u) != 0; return value; } inline bool BlobProto::has_content_chunk_id() const { return _internal_has_content_chunk_id(); } inline void BlobProto::clear_content_chunk_id() { content_chunk_id_ = 0; _has_bits_[0] &= ~0x00000040u; } inline ::PROTOBUF_NAMESPACE_ID::int32 BlobProto::_internal_content_chunk_id() const { return content_chunk_id_; } inline ::PROTOBUF_NAMESPACE_ID::int32 BlobProto::content_chunk_id() const { // @@protoc_insertion_point(field_get:caffe2.BlobProto.content_chunk_id) return _internal_content_chunk_id(); } inline void BlobProto::_internal_set_content_chunk_id(::PROTOBUF_NAMESPACE_ID::int32 value) { _has_bits_[0] |= 0x00000040u; content_chunk_id_ = value; } inline void BlobProto::set_content_chunk_id(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_content_chunk_id(value); // @@protoc_insertion_point(field_set:caffe2.BlobProto.content_chunk_id) } // ------------------------------------------------------------------- // DBReaderProto // optional string name = 1; inline bool DBReaderProto::_internal_has_name() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool DBReaderProto::has_name() const { return _internal_has_name(); } inline void DBReaderProto::clear_name() { name_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& DBReaderProto::name() const { // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.name) return _internal_name(); } inline void DBReaderProto::set_name(const std::string& value) { _internal_set_name(value); // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.name) } inline std::string* DBReaderProto::mutable_name() { // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.name) return _internal_mutable_name(); } inline const std::string& DBReaderProto::_internal_name() const { return name_.Get(); } inline void DBReaderProto::_internal_set_name(const std::string& value) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void DBReaderProto::set_name(std::string&& value) { _has_bits_[0] |= 0x00000001u; name_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.DBReaderProto.name) } inline void DBReaderProto::set_name(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.name) } inline void DBReaderProto::set_name(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; name_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.name) } inline std::string* DBReaderProto::_internal_mutable_name() { _has_bits_[0] |= 0x00000001u; return name_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* DBReaderProto::release_name() { // @@protoc_insertion_point(field_release:caffe2.DBReaderProto.name) if (!_internal_has_name()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return name_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void DBReaderProto::set_allocated_name(std::string* name) { if (name != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } name_.SetAllocated(&GetEmptyStringAlreadyInited(), name, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.name) } // optional string source = 2; inline bool DBReaderProto::_internal_has_source() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool DBReaderProto::has_source() const { return _internal_has_source(); } inline void DBReaderProto::clear_source() { source_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000002u; } inline const std::string& DBReaderProto::source() const { // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.source) return _internal_source(); } inline void DBReaderProto::set_source(const std::string& value) { _internal_set_source(value); // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.source) } inline std::string* DBReaderProto::mutable_source() { // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.source) return _internal_mutable_source(); } inline const std::string& DBReaderProto::_internal_source() const { return source_.Get(); } inline void DBReaderProto::_internal_set_source(const std::string& value) { _has_bits_[0] |= 0x00000002u; source_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void DBReaderProto::set_source(std::string&& value) { _has_bits_[0] |= 0x00000002u; source_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.DBReaderProto.source) } inline void DBReaderProto::set_source(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000002u; source_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.source) } inline void DBReaderProto::set_source(const char* value, size_t size) { _has_bits_[0] |= 0x00000002u; source_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.source) } inline std::string* DBReaderProto::_internal_mutable_source() { _has_bits_[0] |= 0x00000002u; return source_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* DBReaderProto::release_source() { // @@protoc_insertion_point(field_release:caffe2.DBReaderProto.source) if (!_internal_has_source()) { return nullptr; } _has_bits_[0] &= ~0x00000002u; return source_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void DBReaderProto::set_allocated_source(std::string* source) { if (source != nullptr) { _has_bits_[0] |= 0x00000002u; } else { _has_bits_[0] &= ~0x00000002u; } source_.SetAllocated(&GetEmptyStringAlreadyInited(), source, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.source) } // optional string db_type = 3; inline bool DBReaderProto::_internal_has_db_type() const { bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool DBReaderProto::has_db_type() const { return _internal_has_db_type(); } inline void DBReaderProto::clear_db_type() { db_type_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000004u; } inline const std::string& DBReaderProto::db_type() const { // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.db_type) return _internal_db_type(); } inline void DBReaderProto::set_db_type(const std::string& value) { _internal_set_db_type(value); // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.db_type) } inline std::string* DBReaderProto::mutable_db_type() { // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.db_type) return _internal_mutable_db_type(); } inline const std::string& DBReaderProto::_internal_db_type() const { return db_type_.Get(); } inline void DBReaderProto::_internal_set_db_type(const std::string& value) { _has_bits_[0] |= 0x00000004u; db_type_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void DBReaderProto::set_db_type(std::string&& value) { _has_bits_[0] |= 0x00000004u; db_type_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.DBReaderProto.db_type) } inline void DBReaderProto::set_db_type(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000004u; db_type_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.db_type) } inline void DBReaderProto::set_db_type(const char* value, size_t size) { _has_bits_[0] |= 0x00000004u; db_type_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.db_type) } inline std::string* DBReaderProto::_internal_mutable_db_type() { _has_bits_[0] |= 0x00000004u; return db_type_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* DBReaderProto::release_db_type() { // @@protoc_insertion_point(field_release:caffe2.DBReaderProto.db_type) if (!_internal_has_db_type()) { return nullptr; } _has_bits_[0] &= ~0x00000004u; return db_type_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void DBReaderProto::set_allocated_db_type(std::string* db_type) { if (db_type != nullptr) { _has_bits_[0] |= 0x00000004u; } else { _has_bits_[0] &= ~0x00000004u; } db_type_.SetAllocated(&GetEmptyStringAlreadyInited(), db_type, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.db_type) } // optional string key = 4; inline bool DBReaderProto::_internal_has_key() const { bool value = (_has_bits_[0] & 0x00000008u) != 0; return value; } inline bool DBReaderProto::has_key() const { return _internal_has_key(); } inline void DBReaderProto::clear_key() { key_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000008u; } inline const std::string& DBReaderProto::key() const { // @@protoc_insertion_point(field_get:caffe2.DBReaderProto.key) return _internal_key(); } inline void DBReaderProto::set_key(const std::string& value) { _internal_set_key(value); // @@protoc_insertion_point(field_set:caffe2.DBReaderProto.key) } inline std::string* DBReaderProto::mutable_key() { // @@protoc_insertion_point(field_mutable:caffe2.DBReaderProto.key) return _internal_mutable_key(); } inline const std::string& DBReaderProto::_internal_key() const { return key_.Get(); } inline void DBReaderProto::_internal_set_key(const std::string& value) { _has_bits_[0] |= 0x00000008u; key_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void DBReaderProto::set_key(std::string&& value) { _has_bits_[0] |= 0x00000008u; key_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.DBReaderProto.key) } inline void DBReaderProto::set_key(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000008u; key_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.DBReaderProto.key) } inline void DBReaderProto::set_key(const char* value, size_t size) { _has_bits_[0] |= 0x00000008u; key_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.DBReaderProto.key) } inline std::string* DBReaderProto::_internal_mutable_key() { _has_bits_[0] |= 0x00000008u; return key_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* DBReaderProto::release_key() { // @@protoc_insertion_point(field_release:caffe2.DBReaderProto.key) if (!_internal_has_key()) { return nullptr; } _has_bits_[0] &= ~0x00000008u; return key_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void DBReaderProto::set_allocated_key(std::string* key) { if (key != nullptr) { _has_bits_[0] |= 0x00000008u; } else { _has_bits_[0] &= ~0x00000008u; } key_.SetAllocated(&GetEmptyStringAlreadyInited(), key, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.DBReaderProto.key) } // ------------------------------------------------------------------- // BlobSerializationOptions // optional string blob_name_regex = 1; inline bool BlobSerializationOptions::_internal_has_blob_name_regex() const { bool value = (_has_bits_[0] & 0x00000001u) != 0; return value; } inline bool BlobSerializationOptions::has_blob_name_regex() const { return _internal_has_blob_name_regex(); } inline void BlobSerializationOptions::clear_blob_name_regex() { blob_name_regex_.ClearToEmpty(&GetEmptyStringAlreadyInited(), GetArena()); _has_bits_[0] &= ~0x00000001u; } inline const std::string& BlobSerializationOptions::blob_name_regex() const { // @@protoc_insertion_point(field_get:caffe2.BlobSerializationOptions.blob_name_regex) return _internal_blob_name_regex(); } inline void BlobSerializationOptions::set_blob_name_regex(const std::string& value) { _internal_set_blob_name_regex(value); // @@protoc_insertion_point(field_set:caffe2.BlobSerializationOptions.blob_name_regex) } inline std::string* BlobSerializationOptions::mutable_blob_name_regex() { // @@protoc_insertion_point(field_mutable:caffe2.BlobSerializationOptions.blob_name_regex) return _internal_mutable_blob_name_regex(); } inline const std::string& BlobSerializationOptions::_internal_blob_name_regex() const { return blob_name_regex_.Get(); } inline void BlobSerializationOptions::_internal_set_blob_name_regex(const std::string& value) { _has_bits_[0] |= 0x00000001u; blob_name_regex_.Set(&GetEmptyStringAlreadyInited(), value, GetArena()); } inline void BlobSerializationOptions::set_blob_name_regex(std::string&& value) { _has_bits_[0] |= 0x00000001u; blob_name_regex_.Set( &GetEmptyStringAlreadyInited(), ::std::move(value), GetArena()); // @@protoc_insertion_point(field_set_rvalue:caffe2.BlobSerializationOptions.blob_name_regex) } inline void BlobSerializationOptions::set_blob_name_regex(const char* value) { GOOGLE_DCHECK(value != nullptr); _has_bits_[0] |= 0x00000001u; blob_name_regex_.Set(&GetEmptyStringAlreadyInited(), ::std::string(value), GetArena()); // @@protoc_insertion_point(field_set_char:caffe2.BlobSerializationOptions.blob_name_regex) } inline void BlobSerializationOptions::set_blob_name_regex(const char* value, size_t size) { _has_bits_[0] |= 0x00000001u; blob_name_regex_.Set(&GetEmptyStringAlreadyInited(), ::std::string( reinterpret_cast(value), size), GetArena()); // @@protoc_insertion_point(field_set_pointer:caffe2.BlobSerializationOptions.blob_name_regex) } inline std::string* BlobSerializationOptions::_internal_mutable_blob_name_regex() { _has_bits_[0] |= 0x00000001u; return blob_name_regex_.Mutable(&GetEmptyStringAlreadyInited(), GetArena()); } inline std::string* BlobSerializationOptions::release_blob_name_regex() { // @@protoc_insertion_point(field_release:caffe2.BlobSerializationOptions.blob_name_regex) if (!_internal_has_blob_name_regex()) { return nullptr; } _has_bits_[0] &= ~0x00000001u; return blob_name_regex_.ReleaseNonDefault(&GetEmptyStringAlreadyInited(), GetArena()); } inline void BlobSerializationOptions::set_allocated_blob_name_regex(std::string* blob_name_regex) { if (blob_name_regex != nullptr) { _has_bits_[0] |= 0x00000001u; } else { _has_bits_[0] &= ~0x00000001u; } blob_name_regex_.SetAllocated(&GetEmptyStringAlreadyInited(), blob_name_regex, GetArena()); // @@protoc_insertion_point(field_set_allocated:caffe2.BlobSerializationOptions.blob_name_regex) } // optional int64 chunk_size = 2; inline bool BlobSerializationOptions::_internal_has_chunk_size() const { bool value = (_has_bits_[0] & 0x00000002u) != 0; return value; } inline bool BlobSerializationOptions::has_chunk_size() const { return _internal_has_chunk_size(); } inline void BlobSerializationOptions::clear_chunk_size() { chunk_size_ = PROTOBUF_LONGLONG(0); _has_bits_[0] &= ~0x00000002u; } inline ::PROTOBUF_NAMESPACE_ID::int64 BlobSerializationOptions::_internal_chunk_size() const { return chunk_size_; } inline ::PROTOBUF_NAMESPACE_ID::int64 BlobSerializationOptions::chunk_size() const { // @@protoc_insertion_point(field_get:caffe2.BlobSerializationOptions.chunk_size) return _internal_chunk_size(); } inline void BlobSerializationOptions::_internal_set_chunk_size(::PROTOBUF_NAMESPACE_ID::int64 value) { _has_bits_[0] |= 0x00000002u; chunk_size_ = value; } inline void BlobSerializationOptions::set_chunk_size(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_chunk_size(value); // @@protoc_insertion_point(field_set:caffe2.BlobSerializationOptions.chunk_size) } // optional .caffe2.BlobSerializationOptions.FloatFormat float_format = 3; inline bool BlobSerializationOptions::_internal_has_float_format() const { bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool BlobSerializationOptions::has_float_format() const { return _internal_has_float_format(); } inline void BlobSerializationOptions::clear_float_format() { float_format_ = 0; _has_bits_[0] &= ~0x00000004u; } inline ::caffe2::BlobSerializationOptions_FloatFormat BlobSerializationOptions::_internal_float_format() const { return static_cast< ::caffe2::BlobSerializationOptions_FloatFormat >(float_format_); } inline ::caffe2::BlobSerializationOptions_FloatFormat BlobSerializationOptions::float_format() const { // @@protoc_insertion_point(field_get:caffe2.BlobSerializationOptions.float_format) return _internal_float_format(); } inline void BlobSerializationOptions::_internal_set_float_format(::caffe2::BlobSerializationOptions_FloatFormat value) { assert(::caffe2::BlobSerializationOptions_FloatFormat_IsValid(value)); _has_bits_[0] |= 0x00000004u; float_format_ = value; } inline void BlobSerializationOptions::set_float_format(::caffe2::BlobSerializationOptions_FloatFormat value) { _internal_set_float_format(value); // @@protoc_insertion_point(field_set:caffe2.BlobSerializationOptions.float_format) } // ------------------------------------------------------------------- // SerializationOptions // repeated .caffe2.BlobSerializationOptions options = 1; inline int SerializationOptions::_internal_options_size() const { return options_.size(); } inline int SerializationOptions::options_size() const { return _internal_options_size(); } inline void SerializationOptions::clear_options() { options_.Clear(); } inline ::caffe2::BlobSerializationOptions* SerializationOptions::mutable_options(int index) { // @@protoc_insertion_point(field_mutable:caffe2.SerializationOptions.options) return options_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions >* SerializationOptions::mutable_options() { // @@protoc_insertion_point(field_mutable_list:caffe2.SerializationOptions.options) return &options_; } inline const ::caffe2::BlobSerializationOptions& SerializationOptions::_internal_options(int index) const { return options_.Get(index); } inline const ::caffe2::BlobSerializationOptions& SerializationOptions::options(int index) const { // @@protoc_insertion_point(field_get:caffe2.SerializationOptions.options) return _internal_options(index); } inline ::caffe2::BlobSerializationOptions* SerializationOptions::_internal_add_options() { return options_.Add(); } inline ::caffe2::BlobSerializationOptions* SerializationOptions::add_options() { // @@protoc_insertion_point(field_add:caffe2.SerializationOptions.options) return _internal_add_options(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::caffe2::BlobSerializationOptions >& SerializationOptions::options() const { // @@protoc_insertion_point(field_list:caffe2.SerializationOptions.options) return options_; } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // @@protoc_insertion_point(namespace_scope) } // namespace caffe2 PROTOBUF_NAMESPACE_OPEN template <> struct is_proto_enum< ::caffe2::TensorProto_DataType> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::TensorProto_DataType>() { return ::caffe2::TensorProto_DataType_descriptor(); } template <> struct is_proto_enum< ::caffe2::TensorProto_SerializationFormat> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::TensorProto_SerializationFormat>() { return ::caffe2::TensorProto_SerializationFormat_descriptor(); } template <> struct is_proto_enum< ::caffe2::TensorBoundShape_DimType> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::TensorBoundShape_DimType>() { return ::caffe2::TensorBoundShape_DimType_descriptor(); } template <> struct is_proto_enum< ::caffe2::BlobSerializationOptions_FloatFormat> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::BlobSerializationOptions_FloatFormat>() { return ::caffe2::BlobSerializationOptions_FloatFormat_descriptor(); } template <> struct is_proto_enum< ::caffe2::DeviceTypeProto> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::caffe2::DeviceTypeProto>() { return ::caffe2::DeviceTypeProto_descriptor(); } PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) #include #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_caffe2_2fproto_2fcaffe2_2eproto