// 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 < 3011000
#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 3011004 < 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.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::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[21]
    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 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 ExternalDataProto;
class ExternalDataProtoDefaultTypeInternal;
TORCH_API extern ExternalDataProtoDefaultTypeInternal _ExternalDataProto_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 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::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::ExternalDataProto* Arena::CreateMaybeMessage<::caffe2::ExternalDataProto>(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::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 ExternalDataProto_SourceType : int {
  ExternalDataProto_SourceType_INLINE_CONTAINER = 0,
  ExternalDataProto_SourceType_SIMPLE_FILE = 1
};
TORCH_API bool ExternalDataProto_SourceType_IsValid(int value);
constexpr ExternalDataProto_SourceType ExternalDataProto_SourceType_SourceType_MIN = ExternalDataProto_SourceType_INLINE_CONTAINER;
constexpr ExternalDataProto_SourceType ExternalDataProto_SourceType_SourceType_MAX = ExternalDataProto_SourceType_SIMPLE_FILE;
constexpr int ExternalDataProto_SourceType_SourceType_ARRAYSIZE = static_cast<int>(ExternalDataProto_SourceType_SourceType_MAX) + 1;

TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ExternalDataProto_SourceType_descriptor();
template<typename T>
inline const std::string& ExternalDataProto_SourceType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ExternalDataProto_SourceType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ExternalDataProto_SourceType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ExternalDataProto_SourceType_descriptor(), enum_t_value);
}
inline bool ExternalDataProto_SourceType_Parse(
    const std::string& name, ExternalDataProto_SourceType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ExternalDataProto_SourceType>(
    ExternalDataProto_SourceType_descriptor(), name, value);
}
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
};
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_ZERO_COLLISION_HASH;
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(
    const std::string& name, TensorProto_DataType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TensorProto_DataType>(
    TensorProto_DataType_descriptor(), name, value);
}
enum TensorProto_StorageType : int {
  TensorProto_StorageType_TYPED = 1,
  TensorProto_StorageType_RAW = 2,
  TensorProto_StorageType_EXTERNAL = 3,
  TensorProto_StorageType_NO_CONTENT = 4
};
TORCH_API bool TensorProto_StorageType_IsValid(int value);
constexpr TensorProto_StorageType TensorProto_StorageType_StorageType_MIN = TensorProto_StorageType_TYPED;
constexpr TensorProto_StorageType TensorProto_StorageType_StorageType_MAX = TensorProto_StorageType_NO_CONTENT;
constexpr int TensorProto_StorageType_StorageType_ARRAYSIZE = static_cast<int>(TensorProto_StorageType_StorageType_MAX) + 1;

TORCH_API const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TensorProto_StorageType_descriptor();
template<typename T>
inline const std::string& TensorProto_StorageType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TensorProto_StorageType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TensorProto_StorageType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    TensorProto_StorageType_descriptor(), enum_t_value);
}
inline bool TensorProto_StorageType_Parse(
    const std::string& name, TensorProto_StorageType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TensorProto_StorageType>(
    TensorProto_StorageType_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(
    const std::string& name, TensorBoundShape_DimType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TensorBoundShape_DimType>(
    TensorBoundShape_DimType_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_MSNPU = 8,
  PROTO_XLA = 9,
  PROTO_COMPILE_TIME_MAX_DEVICE_TYPES = 10
};
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(
    const std::string& name, DeviceTypeProto* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceTypeProto>(
    DeviceTypeProto_descriptor(), name, value);
}
// ===================================================================

class TORCH_API ExternalDataProto :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:caffe2.ExternalDataProto) */ {
 public:
  ExternalDataProto();
  virtual ~ExternalDataProto();

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

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

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

  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 ExternalDataProto& default_instance();

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

  friend void swap(ExternalDataProto& a, ExternalDataProto& b) {
    a.Swap(&b);