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

#ifndef GOOGLE_PROTOBUF_INCLUDED_caffe2_2fproto_2fmetanet_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_caffe2_2fproto_2fmetanet_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/unknown_field_set.h>
#include "caffe2/proto/caffe2.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_caffe2_2fproto_2fmetanet_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_2fmetanet_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[6]
    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_2fmetanet_2eproto;
namespace caffe2 { const ::std::string& GetEmptyStringAlreadyInited(); 
class BlobsMap;
class BlobsMapDefaultTypeInternal;
TORCH_API extern BlobsMapDefaultTypeInternal _BlobsMap_default_instance_;
class MetaNetDef;
class MetaNetDefDefaultTypeInternal;
TORCH_API extern MetaNetDefDefaultTypeInternal _MetaNetDef_default_instance_;
class ModelInfo;
class ModelInfoDefaultTypeInternal;
TORCH_API extern ModelInfoDefaultTypeInternal _ModelInfo_default_instance_;
class NetsMap;
class NetsMapDefaultTypeInternal;
TORCH_API extern NetsMapDefaultTypeInternal _NetsMap_default_instance_;
class PlansMap;
class PlansMapDefaultTypeInternal;
TORCH_API extern PlansMapDefaultTypeInternal _PlansMap_default_instance_;
class StringMap;
class StringMapDefaultTypeInternal;
TORCH_API extern StringMapDefaultTypeInternal _StringMap_default_instance_;
}  // namespace caffe2
PROTOBUF_NAMESPACE_OPEN
template<> TORCH_API ::caffe2::BlobsMap* Arena::CreateMaybeMessage<::caffe2::BlobsMap>(Arena*);
template<> TORCH_API ::caffe2::MetaNetDef* Arena::CreateMaybeMessage<::caffe2::MetaNetDef>(Arena*);
template<> TORCH_API ::caffe2::ModelInfo* Arena::CreateMaybeMessage<::caffe2::ModelInfo>(Arena*);
template<> TORCH_API ::caffe2::NetsMap* Arena::CreateMaybeMessage<::caffe2::NetsMap>(Arena*);
template<> TORCH_API ::caffe2::PlansMap* Arena::CreateMaybeMessage<::caffe2::PlansMap>(Arena*);
template<> TORCH_API ::caffe2::StringMap* Arena::CreateMaybeMessage<::caffe2::StringMap>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace caffe2 {

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

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

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

  inline ModelInfo& operator=(const ModelInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline ModelInfo& operator=(ModelInfo&& 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 ModelInfo& default_instance();

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

  friend void swap(ModelInfo& a, ModelInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(ModelInfo* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  ModelInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ModelInfo>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ModelInfo& from);
  void MergeFrom(const ModelInfo& 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(ModelInfo* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "caffe2.ModelInfo";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kProjectFieldNumber = 1,
    kModelClassFieldNumber = 2,
    kVersionFieldNumber = 3,
    kPredictorTypeFieldNumber = 4,
    kModelIdFieldNumber = 5,
  };
  // optional string project = 1;
  bool has_project() const;
  private:
  bool _internal_has_project() const;
  public:
  void clear_project();
  const std::string& project() const;
  void set_project(const std::string& value);
  void set_project(std::string&& value);
  void set_project(const char* value);
  void set_project(const char* value, size_t size);
  std::string* mutable_project();
  std::string* release_project();
  void set_allocated_project(std::string* project);
  private:
  const std::string& _internal_project() const;
  void _internal_set_project(const std::string& value);
  std::string* _internal_mutable_project();
  public:

  // optional string modelClass = 2;
  bool has_modelclass() const;
  private:
  bool _internal_has_modelclass() const;
  public:
  void clear_modelclass();
  const std::string& modelclass() const;
  void set_modelclass(const std::string& value);
  void set_modelclass(std::string&& value);
  void set_modelclass(const char* value);
  void set_modelclass(const char* value, size_t size);
  std::string* mutable_modelclass();
  std::string* release_modelclass();
  void set_allocated_modelclass(std::string* modelclass);
  private:
  const std::string& _internal_modelclass() const;
  void _internal_set_modelclass(const std::string& value);
  std::string* _internal_mutable_modelclass();
  public:

  // optional string version = 3;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  const std::string& version() const;
  void set_version(const std::string& value);
  void set_version(std::string&& value);
  void set_version(const char* value);
  void set_version(const char* value, size_t size);
  std::string* mutable_version();
  std::string* release_version();
  void set_allocated_version(std::string* version);
  private:
  const std::string& _internal_version() const;
  void _internal_set_version(const std::string& value);
  std::string* _internal_mutable_version();
  public:

  // optional string predictorType = 4 [default = "SINGLE_PREDICTOR"];
  bool has_predictortype() const;
  private:
  bool _internal_has_predictortype() const;
  public:
  void clear_predictortype();
  const std::string& predictortype() const;
  void set_predictortype(const std::string& value);
  void set_predictortype(std::string&& value);
  void set_predictortype(const char* value);
  void set_predictortype(const char* value, size_t size);
  std::string* mutable_predictortype();
  std::string* release_predictortype();
  void set_allocated_predictortype(std::string* predictortype);
  private:
  const std::string& _internal_predictortype() const;
  void _internal_set_predictortype(const std::string& value);
  std::string* _internal_mutable_predictortype();
  public:

  // optional string modelId = 5;
  bool has_modelid() const;
  private:
  bool _internal_has_modelid() const;
  public:
  void clear_modelid();
  const std::string& modelid() const;
  void set_modelid(const std::string& value);
  void set_modelid(std::string&& value);
  void set_modelid(const char* value);
  void set_modelid(const char* value, size_t size);
  std::string* mutable_modelid();
  std::string* release_modelid();
  void set_allocated_modelid(std::string* modelid);
  private:
  const std::string& _internal_modelid() const;
  void _internal_set_modelid(const std::string& value);
  std::string* _internal_mutable_modelid();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr project_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr modelclass_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
  public:
  static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> _i_give_permission_to_break_this_code_default_predictortype_;
  private:
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr predictortype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr modelid_;
  friend struct ::TableStruct_caffe2_2fproto_2fmetanet_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline BlobsMap& operator=(const BlobsMap& from) {
    CopyFrom(from);
    return *this;
  }
  inline BlobsMap& operator=(BlobsMap&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {