github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/c-deps/libroach/protos/roachpb/metadata.pb.h

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

#ifndef PROTOBUF_INCLUDED_roachpb_2fmetadata_2eproto
#define PROTOBUF_INCLUDED_roachpb_2fmetadata_2eproto

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3006000
#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 3006000 < GOOGLE_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/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/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
#include "util/unresolved_addr.pb.h"
#include "util/hlc/timestamp.pb.h"
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_roachpb_2fmetadata_2eproto 

namespace protobuf_roachpb_2fmetadata_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[14];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
}  // namespace protobuf_roachpb_2fmetadata_2eproto
namespace cockroach {
namespace roachpb {
class Attributes;
class AttributesDefaultTypeInternal;
extern AttributesDefaultTypeInternal _Attributes_default_instance_;
class Locality;
class LocalityDefaultTypeInternal;
extern LocalityDefaultTypeInternal _Locality_default_instance_;
class LocalityAddress;
class LocalityAddressDefaultTypeInternal;
extern LocalityAddressDefaultTypeInternal _LocalityAddress_default_instance_;
class NodeDescriptor;
class NodeDescriptorDefaultTypeInternal;
extern NodeDescriptorDefaultTypeInternal _NodeDescriptor_default_instance_;
class Percentiles;
class PercentilesDefaultTypeInternal;
extern PercentilesDefaultTypeInternal _Percentiles_default_instance_;
class RangeDescriptor;
class RangeDescriptorDefaultTypeInternal;
extern RangeDescriptorDefaultTypeInternal _RangeDescriptor_default_instance_;
class ReplicaDescriptor;
class ReplicaDescriptorDefaultTypeInternal;
extern ReplicaDescriptorDefaultTypeInternal _ReplicaDescriptor_default_instance_;
class ReplicaIdent;
class ReplicaIdentDefaultTypeInternal;
extern ReplicaIdentDefaultTypeInternal _ReplicaIdent_default_instance_;
class ReplicationTarget;
class ReplicationTargetDefaultTypeInternal;
extern ReplicationTargetDefaultTypeInternal _ReplicationTarget_default_instance_;
class StoreCapacity;
class StoreCapacityDefaultTypeInternal;
extern StoreCapacityDefaultTypeInternal _StoreCapacity_default_instance_;
class StoreDeadReplicas;
class StoreDeadReplicasDefaultTypeInternal;
extern StoreDeadReplicasDefaultTypeInternal _StoreDeadReplicas_default_instance_;
class StoreDescriptor;
class StoreDescriptorDefaultTypeInternal;
extern StoreDescriptorDefaultTypeInternal _StoreDescriptor_default_instance_;
class Tier;
class TierDefaultTypeInternal;
extern TierDefaultTypeInternal _Tier_default_instance_;
class Version;
class VersionDefaultTypeInternal;
extern VersionDefaultTypeInternal _Version_default_instance_;
}  // namespace roachpb
}  // namespace cockroach
namespace google {
namespace protobuf {
template<> ::cockroach::roachpb::Attributes* Arena::CreateMaybeMessage<::cockroach::roachpb::Attributes>(Arena*);
template<> ::cockroach::roachpb::Locality* Arena::CreateMaybeMessage<::cockroach::roachpb::Locality>(Arena*);
template<> ::cockroach::roachpb::LocalityAddress* Arena::CreateMaybeMessage<::cockroach::roachpb::LocalityAddress>(Arena*);
template<> ::cockroach::roachpb::NodeDescriptor* Arena::CreateMaybeMessage<::cockroach::roachpb::NodeDescriptor>(Arena*);
template<> ::cockroach::roachpb::Percentiles* Arena::CreateMaybeMessage<::cockroach::roachpb::Percentiles>(Arena*);
template<> ::cockroach::roachpb::RangeDescriptor* Arena::CreateMaybeMessage<::cockroach::roachpb::RangeDescriptor>(Arena*);
template<> ::cockroach::roachpb::ReplicaDescriptor* Arena::CreateMaybeMessage<::cockroach::roachpb::ReplicaDescriptor>(Arena*);
template<> ::cockroach::roachpb::ReplicaIdent* Arena::CreateMaybeMessage<::cockroach::roachpb::ReplicaIdent>(Arena*);
template<> ::cockroach::roachpb::ReplicationTarget* Arena::CreateMaybeMessage<::cockroach::roachpb::ReplicationTarget>(Arena*);
template<> ::cockroach::roachpb::StoreCapacity* Arena::CreateMaybeMessage<::cockroach::roachpb::StoreCapacity>(Arena*);
template<> ::cockroach::roachpb::StoreDeadReplicas* Arena::CreateMaybeMessage<::cockroach::roachpb::StoreDeadReplicas>(Arena*);
template<> ::cockroach::roachpb::StoreDescriptor* Arena::CreateMaybeMessage<::cockroach::roachpb::StoreDescriptor>(Arena*);
template<> ::cockroach::roachpb::Tier* Arena::CreateMaybeMessage<::cockroach::roachpb::Tier>(Arena*);
template<> ::cockroach::roachpb::Version* Arena::CreateMaybeMessage<::cockroach::roachpb::Version>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace cockroach {
namespace roachpb {

enum ReplicaType {
  VOTER_FULL = 0,
  VOTER_INCOMING = 2,
  VOTER_OUTGOING = 3,
  VOTER_DEMOTING = 4,
  LEARNER = 1
};
bool ReplicaType_IsValid(int value);
const ReplicaType ReplicaType_MIN = VOTER_FULL;
const ReplicaType ReplicaType_MAX = VOTER_DEMOTING;
const int ReplicaType_ARRAYSIZE = ReplicaType_MAX + 1;

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

class Attributes : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.Attributes) */ {
 public:
  Attributes();
  virtual ~Attributes();

  Attributes(const Attributes& from);

  inline Attributes& operator=(const Attributes& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Attributes(Attributes&& from) noexcept
    : Attributes() {
    *this = ::std::move(from);
  }

  inline Attributes& operator=(Attributes&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const Attributes& default_instance();

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

  void Swap(Attributes* other);
  friend void swap(Attributes& a, Attributes& b) {
    a.Swap(&b);
  }

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

  inline Attributes* New() const final {
    return CreateMaybeMessage<Attributes>(NULL);
  }

  Attributes* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Attributes>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const Attributes& from);
  void MergeFrom(const Attributes& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Attributes* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  int attrs_size() const;
  void clear_attrs();
  static const int kAttrsFieldNumber = 1;
  const ::std::string& attrs(int index) const;
  ::std::string* mutable_attrs(int index);
  void set_attrs(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_attrs(int index, ::std::string&& value);
  #endif
  void set_attrs(int index, const char* value);
  void set_attrs(int index, const char* value, size_t size);
  ::std::string* add_attrs();
  void add_attrs(const ::std::string& value);
  #if LANG_CXX11
  void add_attrs(::std::string&& value);
  #endif
  void add_attrs(const char* value);
  void add_attrs(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& attrs() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_attrs();

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.Attributes)
 private:

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::std::string> attrs_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ReplicationTarget : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.ReplicationTarget) */ {
 public:
  ReplicationTarget();
  virtual ~ReplicationTarget();

  ReplicationTarget(const ReplicationTarget& from);

  inline ReplicationTarget& operator=(const ReplicationTarget& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReplicationTarget(ReplicationTarget&& from) noexcept
    : ReplicationTarget() {
    *this = ::std::move(from);
  }

  inline ReplicationTarget& operator=(ReplicationTarget&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ReplicationTarget& default_instance();

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

  void Swap(ReplicationTarget* other);
  friend void swap(ReplicationTarget& a, ReplicationTarget& b) {
    a.Swap(&b);
  }

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

  inline ReplicationTarget* New() const final {
    return CreateMaybeMessage<ReplicationTarget>(NULL);
  }

  ReplicationTarget* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReplicationTarget>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const ReplicationTarget& from);
  void MergeFrom(const ReplicationTarget& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ReplicationTarget* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_node_id() const;
  void clear_node_id();
  static const int kNodeIdFieldNumber = 1;
  ::google::protobuf::int32 node_id() const;
  void set_node_id(::google::protobuf::int32 value);

  bool has_store_id() const;
  void clear_store_id();
  static const int kStoreIdFieldNumber = 2;
  ::google::protobuf::int32 store_id() const;
  void set_store_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.ReplicationTarget)
 private:
  void set_has_node_id();
  void clear_has_node_id();
  void set_has_store_id();
  void clear_has_store_id();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 node_id_;
  ::google::protobuf::int32 store_id_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ReplicaDescriptor : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.ReplicaDescriptor) */ {
 public:
  ReplicaDescriptor();
  virtual ~ReplicaDescriptor();

  ReplicaDescriptor(const ReplicaDescriptor& from);

  inline ReplicaDescriptor& operator=(const ReplicaDescriptor& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReplicaDescriptor(ReplicaDescriptor&& from) noexcept
    : ReplicaDescriptor() {
    *this = ::std::move(from);
  }

  inline ReplicaDescriptor& operator=(ReplicaDescriptor&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ReplicaDescriptor& default_instance();

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

  void Swap(ReplicaDescriptor* other);
  friend void swap(ReplicaDescriptor& a, ReplicaDescriptor& b) {
    a.Swap(&b);
  }

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

  inline ReplicaDescriptor* New() const final {
    return CreateMaybeMessage<ReplicaDescriptor>(NULL);
  }

  ReplicaDescriptor* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReplicaDescriptor>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const ReplicaDescriptor& from);
  void MergeFrom(const ReplicaDescriptor& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ReplicaDescriptor* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_node_id() const;
  void clear_node_id();
  static const int kNodeIdFieldNumber = 1;
  ::google::protobuf::int32 node_id() const;
  void set_node_id(::google::protobuf::int32 value);

  bool has_store_id() const;
  void clear_store_id();
  static const int kStoreIdFieldNumber = 2;
  ::google::protobuf::int32 store_id() const;
  void set_store_id(::google::protobuf::int32 value);

  bool has_replica_id() const;
  void clear_replica_id();
  static const int kReplicaIdFieldNumber = 3;
  ::google::protobuf::int32 replica_id() const;
  void set_replica_id(::google::protobuf::int32 value);

  // optional .cockroach.roachpb.ReplicaType type = 4;
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 4;
  ::cockroach::roachpb::ReplicaType type() const;
  void set_type(::cockroach::roachpb::ReplicaType value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.ReplicaDescriptor)
 private:
  void set_has_node_id();
  void clear_has_node_id();
  void set_has_store_id();
  void clear_has_store_id();
  void set_has_replica_id();
  void clear_has_replica_id();
  void set_has_type();
  void clear_has_type();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 node_id_;
  ::google::protobuf::int32 store_id_;
  ::google::protobuf::int32 replica_id_;
  int type_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ReplicaIdent : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.ReplicaIdent) */ {
 public:
  ReplicaIdent();
  virtual ~ReplicaIdent();

  ReplicaIdent(const ReplicaIdent& from);

  inline ReplicaIdent& operator=(const ReplicaIdent& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReplicaIdent(ReplicaIdent&& from) noexcept
    : ReplicaIdent() {
    *this = ::std::move(from);
  }

  inline ReplicaIdent& operator=(ReplicaIdent&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ReplicaIdent& default_instance();

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

  void Swap(ReplicaIdent* other);
  friend void swap(ReplicaIdent& a, ReplicaIdent& b) {
    a.Swap(&b);
  }

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

  inline ReplicaIdent* New() const final {
    return CreateMaybeMessage<ReplicaIdent>(NULL);
  }

  ReplicaIdent* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReplicaIdent>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const ReplicaIdent& from);
  void MergeFrom(const ReplicaIdent& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ReplicaIdent* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_replica() const;
  void clear_replica();
  static const int kReplicaFieldNumber = 2;
  private:
  const ::cockroach::roachpb::ReplicaDescriptor& _internal_replica() const;
  public:
  const ::cockroach::roachpb::ReplicaDescriptor& replica() const;
  ::cockroach::roachpb::ReplicaDescriptor* release_replica();
  ::cockroach::roachpb::ReplicaDescriptor* mutable_replica();
  void set_allocated_replica(::cockroach::roachpb::ReplicaDescriptor* replica);

  bool has_range_id() const;
  void clear_range_id();
  static const int kRangeIdFieldNumber = 1;
  ::google::protobuf::int64 range_id() const;
  void set_range_id(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.ReplicaIdent)
 private:
  void set_has_range_id();
  void clear_has_range_id();
  void set_has_replica();
  void clear_has_replica();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::cockroach::roachpb::ReplicaDescriptor* replica_;
  ::google::protobuf::int64 range_id_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RangeDescriptor : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.RangeDescriptor) */ {
 public:
  RangeDescriptor();
  virtual ~RangeDescriptor();

  RangeDescriptor(const RangeDescriptor& from);

  inline RangeDescriptor& operator=(const RangeDescriptor& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RangeDescriptor(RangeDescriptor&& from) noexcept
    : RangeDescriptor() {
    *this = ::std::move(from);
  }

  inline RangeDescriptor& operator=(RangeDescriptor&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const RangeDescriptor& default_instance();

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

  void Swap(RangeDescriptor* other);
  friend void swap(RangeDescriptor& a, RangeDescriptor& b) {
    a.Swap(&b);
  }

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

  inline RangeDescriptor* New() const final {
    return CreateMaybeMessage<RangeDescriptor>(NULL);
  }

  RangeDescriptor* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RangeDescriptor>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const RangeDescriptor& from);
  void MergeFrom(const RangeDescriptor& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RangeDescriptor* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  int internal_replicas_size() const;
  void clear_internal_replicas();
  static const int kInternalReplicasFieldNumber = 4;
  ::cockroach::roachpb::ReplicaDescriptor* mutable_internal_replicas(int index);
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaDescriptor >*
      mutable_internal_replicas();
  const ::cockroach::roachpb::ReplicaDescriptor& internal_replicas(int index) const;
  ::cockroach::roachpb::ReplicaDescriptor* add_internal_replicas();
  const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaDescriptor >&
      internal_replicas() const;

  bool has_start_key() const;
  void clear_start_key();
  static const int kStartKeyFieldNumber = 2;
  const ::std::string& start_key() const;
  void set_start_key(const ::std::string& value);
  #if LANG_CXX11
  void set_start_key(::std::string&& value);
  #endif
  void set_start_key(const char* value);
  void set_start_key(const void* value, size_t size);
  ::std::string* mutable_start_key();
  ::std::string* release_start_key();
  void set_allocated_start_key(::std::string* start_key);

  bool has_end_key() const;
  void clear_end_key();
  static const int kEndKeyFieldNumber = 3;
  const ::std::string& end_key() const;
  void set_end_key(const ::std::string& value);
  #if LANG_CXX11
  void set_end_key(::std::string&& value);
  #endif
  void set_end_key(const char* value);
  void set_end_key(const void* value, size_t size);
  ::std::string* mutable_end_key();
  ::std::string* release_end_key();
  void set_allocated_end_key(::std::string* end_key);

  // optional .cockroach.util.hlc.Timestamp sticky_bit = 7;
  bool has_sticky_bit() const;
  void clear_sticky_bit();
  static const int kStickyBitFieldNumber = 7;
  private:
  const ::cockroach::util::hlc::Timestamp& _internal_sticky_bit() const;
  public:
  const ::cockroach::util::hlc::Timestamp& sticky_bit() const;
  ::cockroach::util::hlc::Timestamp* release_sticky_bit();
  ::cockroach::util::hlc::Timestamp* mutable_sticky_bit();
  void set_allocated_sticky_bit(::cockroach::util::hlc::Timestamp* sticky_bit);

  bool has_range_id() const;
  void clear_range_id();
  static const int kRangeIdFieldNumber = 1;
  ::google::protobuf::int64 range_id() const;
  void set_range_id(::google::protobuf::int64 value);

  bool has_generation() const;
  void clear_generation();
  static const int kGenerationFieldNumber = 6;
  ::google::protobuf::int64 generation() const;
  void set_generation(::google::protobuf::int64 value);

  bool has_next_replica_id() const;
  void clear_next_replica_id();
  static const int kNextReplicaIdFieldNumber = 5;
  ::google::protobuf::int32 next_replica_id() const;
  void set_next_replica_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.RangeDescriptor)
 private:
  void set_has_range_id();
  void clear_has_range_id();
  void set_has_start_key();
  void clear_has_start_key();
  void set_has_end_key();
  void clear_has_end_key();
  void set_has_next_replica_id();
  void clear_has_next_replica_id();
  void set_has_generation();
  void clear_has_generation();
  void set_has_sticky_bit();
  void clear_has_sticky_bit();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaDescriptor > internal_replicas_;
  ::google::protobuf::internal::ArenaStringPtr start_key_;
  ::google::protobuf::internal::ArenaStringPtr end_key_;
  ::cockroach::util::hlc::Timestamp* sticky_bit_;
  ::google::protobuf::int64 range_id_;
  ::google::protobuf::int64 generation_;
  ::google::protobuf::int32 next_replica_id_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Percentiles : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.Percentiles) */ {
 public:
  Percentiles();
  virtual ~Percentiles();

  Percentiles(const Percentiles& from);

  inline Percentiles& operator=(const Percentiles& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Percentiles(Percentiles&& from) noexcept
    : Percentiles() {
    *this = ::std::move(from);
  }

  inline Percentiles& operator=(Percentiles&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const Percentiles& default_instance();

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

  void Swap(Percentiles* other);
  friend void swap(Percentiles& a, Percentiles& b) {
    a.Swap(&b);
  }

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

  inline Percentiles* New() const final {
    return CreateMaybeMessage<Percentiles>(NULL);
  }

  Percentiles* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Percentiles>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const Percentiles& from);
  void MergeFrom(const Percentiles& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Percentiles* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_p10() const;
  void clear_p10();
  static const int kP10FieldNumber = 1;
  double p10() const;
  void set_p10(double value);

  bool has_p25() const;
  void clear_p25();
  static const int kP25FieldNumber = 2;
  double p25() const;
  void set_p25(double value);

  bool has_p50() const;
  void clear_p50();
  static const int kP50FieldNumber = 3;
  double p50() const;
  void set_p50(double value);

  bool has_p75() const;
  void clear_p75();
  static const int kP75FieldNumber = 4;
  double p75() const;
  void set_p75(double value);

  bool has_p90() const;
  void clear_p90();
  static const int kP90FieldNumber = 5;
  double p90() const;
  void set_p90(double value);

  bool has_pmax() const;
  void clear_pmax();
  static const int kPMaxFieldNumber = 6;
  double pmax() const;
  void set_pmax(double value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.Percentiles)
 private:
  void set_has_p10();
  void clear_has_p10();
  void set_has_p25();
  void clear_has_p25();
  void set_has_p50();
  void clear_has_p50();
  void set_has_p75();
  void clear_has_p75();
  void set_has_p90();
  void clear_has_p90();
  void set_has_pmax();
  void clear_has_pmax();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  double p10_;
  double p25_;
  double p50_;
  double p75_;
  double p90_;
  double pmax_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class StoreCapacity : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.StoreCapacity) */ {
 public:
  StoreCapacity();
  virtual ~StoreCapacity();

  StoreCapacity(const StoreCapacity& from);

  inline StoreCapacity& operator=(const StoreCapacity& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StoreCapacity(StoreCapacity&& from) noexcept
    : StoreCapacity() {
    *this = ::std::move(from);
  }

  inline StoreCapacity& operator=(StoreCapacity&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const StoreCapacity& default_instance();

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

  void Swap(StoreCapacity* other);
  friend void swap(StoreCapacity& a, StoreCapacity& b) {
    a.Swap(&b);
  }

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

  inline StoreCapacity* New() const final {
    return CreateMaybeMessage<StoreCapacity>(NULL);
  }

  StoreCapacity* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StoreCapacity>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const StoreCapacity& from);
  void MergeFrom(const StoreCapacity& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(StoreCapacity* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_bytes_per_replica() const;
  void clear_bytes_per_replica();
  static const int kBytesPerReplicaFieldNumber = 6;
  private:
  const ::cockroach::roachpb::Percentiles& _internal_bytes_per_replica() const;
  public:
  const ::cockroach::roachpb::Percentiles& bytes_per_replica() const;
  ::cockroach::roachpb::Percentiles* release_bytes_per_replica();
  ::cockroach::roachpb::Percentiles* mutable_bytes_per_replica();
  void set_allocated_bytes_per_replica(::cockroach::roachpb::Percentiles* bytes_per_replica);

  bool has_writes_per_replica() const;
  void clear_writes_per_replica();
  static const int kWritesPerReplicaFieldNumber = 7;
  private:
  const ::cockroach::roachpb::Percentiles& _internal_writes_per_replica() const;
  public:
  const ::cockroach::roachpb::Percentiles& writes_per_replica() const;
  ::cockroach::roachpb::Percentiles* release_writes_per_replica();
  ::cockroach::roachpb::Percentiles* mutable_writes_per_replica();
  void set_allocated_writes_per_replica(::cockroach::roachpb::Percentiles* writes_per_replica);

  bool has_capacity() const;
  void clear_capacity();
  static const int kCapacityFieldNumber = 1;
  ::google::protobuf::int64 capacity() const;
  void set_capacity(::google::protobuf::int64 value);

  bool has_available() const;
  void clear_available();
  static const int kAvailableFieldNumber = 2;
  ::google::protobuf::int64 available() const;
  void set_available(::google::protobuf::int64 value);

  bool has_range_count() const;
  void clear_range_count();
  static const int kRangeCountFieldNumber = 3;
  ::google::protobuf::int32 range_count() const;
  void set_range_count(::google::protobuf::int32 value);

  bool has_lease_count() const;
  void clear_lease_count();
  static const int kLeaseCountFieldNumber = 4;
  ::google::protobuf::int32 lease_count() const;
  void set_lease_count(::google::protobuf::int32 value);

  bool has_writes_per_second() const;
  void clear_writes_per_second();
  static const int kWritesPerSecondFieldNumber = 5;
  double writes_per_second() const;
  void set_writes_per_second(double value);

  bool has_used() const;
  void clear_used();
  static const int kUsedFieldNumber = 8;
  ::google::protobuf::int64 used() const;
  void set_used(::google::protobuf::int64 value);

  bool has_logical_bytes() const;
  void clear_logical_bytes();
  static const int kLogicalBytesFieldNumber = 9;
  ::google::protobuf::int64 logical_bytes() const;
  void set_logical_bytes(::google::protobuf::int64 value);

  bool has_queries_per_second() const;
  void clear_queries_per_second();
  static const int kQueriesPerSecondFieldNumber = 10;
  double queries_per_second() const;
  void set_queries_per_second(double value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.StoreCapacity)
 private:
  void set_has_capacity();
  void clear_has_capacity();
  void set_has_available();
  void clear_has_available();
  void set_has_used();
  void clear_has_used();
  void set_has_logical_bytes();
  void clear_has_logical_bytes();
  void set_has_range_count();
  void clear_has_range_count();
  void set_has_lease_count();
  void clear_has_lease_count();
  void set_has_queries_per_second();
  void clear_has_queries_per_second();
  void set_has_writes_per_second();
  void clear_has_writes_per_second();
  void set_has_bytes_per_replica();
  void clear_has_bytes_per_replica();
  void set_has_writes_per_replica();
  void clear_has_writes_per_replica();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::cockroach::roachpb::Percentiles* bytes_per_replica_;
  ::cockroach::roachpb::Percentiles* writes_per_replica_;
  ::google::protobuf::int64 capacity_;
  ::google::protobuf::int64 available_;
  ::google::protobuf::int32 range_count_;
  ::google::protobuf::int32 lease_count_;
  double writes_per_second_;
  ::google::protobuf::int64 used_;
  ::google::protobuf::int64 logical_bytes_;
  double queries_per_second_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class NodeDescriptor : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.NodeDescriptor) */ {
 public:
  NodeDescriptor();
  virtual ~NodeDescriptor();

  NodeDescriptor(const NodeDescriptor& from);

  inline NodeDescriptor& operator=(const NodeDescriptor& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  NodeDescriptor(NodeDescriptor&& from) noexcept
    : NodeDescriptor() {
    *this = ::std::move(from);
  }

  inline NodeDescriptor& operator=(NodeDescriptor&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const NodeDescriptor& default_instance();

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

  void Swap(NodeDescriptor* other);
  friend void swap(NodeDescriptor& a, NodeDescriptor& b) {
    a.Swap(&b);
  }

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

  inline NodeDescriptor* New() const final {
    return CreateMaybeMessage<NodeDescriptor>(NULL);
  }

  NodeDescriptor* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<NodeDescriptor>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const NodeDescriptor& from);
  void MergeFrom(const NodeDescriptor& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(NodeDescriptor* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  int locality_address_size() const;
  void clear_locality_address();
  static const int kLocalityAddressFieldNumber = 8;
  ::cockroach::roachpb::LocalityAddress* mutable_locality_address(int index);
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::LocalityAddress >*
      mutable_locality_address();
  const ::cockroach::roachpb::LocalityAddress& locality_address(int index) const;
  ::cockroach::roachpb::LocalityAddress* add_locality_address();
  const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::LocalityAddress >&
      locality_address() const;

  bool has_build_tag() const;
  void clear_build_tag();
  static const int kBuildTagFieldNumber = 6;
  const ::std::string& build_tag() const;
  void set_build_tag(const ::std::string& value);
  #if LANG_CXX11
  void set_build_tag(::std::string&& value);
  #endif
  void set_build_tag(const char* value);
  void set_build_tag(const char* value, size_t size);
  ::std::string* mutable_build_tag();
  ::std::string* release_build_tag();
  void set_allocated_build_tag(::std::string* build_tag);

  bool has_cluster_name() const;
  void clear_cluster_name();
  static const int kClusterNameFieldNumber = 9;
  const ::std::string& cluster_name() const;
  void set_cluster_name(const ::std::string& value);
  #if LANG_CXX11
  void set_cluster_name(::std::string&& value);
  #endif
  void set_cluster_name(const char* value);
  void set_cluster_name(const char* value, size_t size);
  ::std::string* mutable_cluster_name();
  ::std::string* release_cluster_name();
  void set_allocated_cluster_name(::std::string* cluster_name);

  bool has_address() const;
  void clear_address();
  static const int kAddressFieldNumber = 2;
  private:
  const ::cockroach::util::UnresolvedAddr& _internal_address() const;
  public:
  const ::cockroach::util::UnresolvedAddr& address() const;
  ::cockroach::util::UnresolvedAddr* release_address();
  ::cockroach::util::UnresolvedAddr* mutable_address();
  void set_allocated_address(::cockroach::util::UnresolvedAddr* address);

  bool has_attrs() const;
  void clear_attrs();
  static const int kAttrsFieldNumber = 3;
  private:
  const ::cockroach::roachpb::Attributes& _internal_attrs() const;
  public:
  const ::cockroach::roachpb::Attributes& attrs() const;
  ::cockroach::roachpb::Attributes* release_attrs();
  ::cockroach::roachpb::Attributes* mutable_attrs();
  void set_allocated_attrs(::cockroach::roachpb::Attributes* attrs);

  bool has_locality() const;
  void clear_locality();
  static const int kLocalityFieldNumber = 4;
  private:
  const ::cockroach::roachpb::Locality& _internal_locality() const;
  public:
  const ::cockroach::roachpb::Locality& locality() const;
  ::cockroach::roachpb::Locality* release_locality();
  ::cockroach::roachpb::Locality* mutable_locality();
  void set_allocated_locality(::cockroach::roachpb::Locality* locality);

  bool has_serverversion() const;
  void clear_serverversion();
  static const int kServerVersionFieldNumber = 5;
  private:
  const ::cockroach::roachpb::Version& _internal_serverversion() const;
  public:
  const ::cockroach::roachpb::Version& serverversion() const;
  ::cockroach::roachpb::Version* release_serverversion();
  ::cockroach::roachpb::Version* mutable_serverversion();
  void set_allocated_serverversion(::cockroach::roachpb::Version* serverversion);

  bool has_sql_address() const;
  void clear_sql_address();
  static const int kSqlAddressFieldNumber = 10;
  private:
  const ::cockroach::util::UnresolvedAddr& _internal_sql_address() const;
  public:
  const ::cockroach::util::UnresolvedAddr& sql_address() const;
  ::cockroach::util::UnresolvedAddr* release_sql_address();
  ::cockroach::util::UnresolvedAddr* mutable_sql_address();
  void set_allocated_sql_address(::cockroach::util::UnresolvedAddr* sql_address);

  bool has_started_at() const;
  void clear_started_at();
  static const int kStartedAtFieldNumber = 7;
  ::google::protobuf::int64 started_at() const;
  void set_started_at(::google::protobuf::int64 value);

  bool has_node_id() const;
  void clear_node_id();
  static const int kNodeIdFieldNumber = 1;
  ::google::protobuf::int32 node_id() const;
  void set_node_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.NodeDescriptor)
 private:
  void set_has_node_id();
  void clear_has_node_id();
  void set_has_address();
  void clear_has_address();
  void set_has_attrs();
  void clear_has_attrs();
  void set_has_locality();
  void clear_has_locality();
  void set_has_serverversion();
  void clear_has_serverversion();
  void set_has_build_tag();
  void clear_has_build_tag();
  void set_has_started_at();
  void clear_has_started_at();
  void set_has_cluster_name();
  void clear_has_cluster_name();
  void set_has_sql_address();
  void clear_has_sql_address();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::LocalityAddress > locality_address_;
  ::google::protobuf::internal::ArenaStringPtr build_tag_;
  ::google::protobuf::internal::ArenaStringPtr cluster_name_;
  ::cockroach::util::UnresolvedAddr* address_;
  ::cockroach::roachpb::Attributes* attrs_;
  ::cockroach::roachpb::Locality* locality_;
  ::cockroach::roachpb::Version* serverversion_;
  ::cockroach::util::UnresolvedAddr* sql_address_;
  ::google::protobuf::int64 started_at_;
  ::google::protobuf::int32 node_id_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class LocalityAddress : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.LocalityAddress) */ {
 public:
  LocalityAddress();
  virtual ~LocalityAddress();

  LocalityAddress(const LocalityAddress& from);

  inline LocalityAddress& operator=(const LocalityAddress& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  LocalityAddress(LocalityAddress&& from) noexcept
    : LocalityAddress() {
    *this = ::std::move(from);
  }

  inline LocalityAddress& operator=(LocalityAddress&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const LocalityAddress& default_instance();

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

  void Swap(LocalityAddress* other);
  friend void swap(LocalityAddress& a, LocalityAddress& b) {
    a.Swap(&b);
  }

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

  inline LocalityAddress* New() const final {
    return CreateMaybeMessage<LocalityAddress>(NULL);
  }

  LocalityAddress* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<LocalityAddress>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const LocalityAddress& from);
  void MergeFrom(const LocalityAddress& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LocalityAddress* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_address() const;
  void clear_address();
  static const int kAddressFieldNumber = 1;
  private:
  const ::cockroach::util::UnresolvedAddr& _internal_address() const;
  public:
  const ::cockroach::util::UnresolvedAddr& address() const;
  ::cockroach::util::UnresolvedAddr* release_address();
  ::cockroach::util::UnresolvedAddr* mutable_address();
  void set_allocated_address(::cockroach::util::UnresolvedAddr* address);

  bool has_locality_tier() const;
  void clear_locality_tier();
  static const int kLocalityTierFieldNumber = 2;
  private:
  const ::cockroach::roachpb::Tier& _internal_locality_tier() const;
  public:
  const ::cockroach::roachpb::Tier& locality_tier() const;
  ::cockroach::roachpb::Tier* release_locality_tier();
  ::cockroach::roachpb::Tier* mutable_locality_tier();
  void set_allocated_locality_tier(::cockroach::roachpb::Tier* locality_tier);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.LocalityAddress)
 private:
  void set_has_address();
  void clear_has_address();
  void set_has_locality_tier();
  void clear_has_locality_tier();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::cockroach::util::UnresolvedAddr* address_;
  ::cockroach::roachpb::Tier* locality_tier_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class StoreDescriptor : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.StoreDescriptor) */ {
 public:
  StoreDescriptor();
  virtual ~StoreDescriptor();

  StoreDescriptor(const StoreDescriptor& from);

  inline StoreDescriptor& operator=(const StoreDescriptor& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StoreDescriptor(StoreDescriptor&& from) noexcept
    : StoreDescriptor() {
    *this = ::std::move(from);
  }

  inline StoreDescriptor& operator=(StoreDescriptor&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const StoreDescriptor& default_instance();

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

  void Swap(StoreDescriptor* other);
  friend void swap(StoreDescriptor& a, StoreDescriptor& b) {
    a.Swap(&b);
  }

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

  inline StoreDescriptor* New() const final {
    return CreateMaybeMessage<StoreDescriptor>(NULL);
  }

  StoreDescriptor* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StoreDescriptor>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const StoreDescriptor& from);
  void MergeFrom(const StoreDescriptor& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(StoreDescriptor* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_attrs() const;
  void clear_attrs();
  static const int kAttrsFieldNumber = 2;
  private:
  const ::cockroach::roachpb::Attributes& _internal_attrs() const;
  public:
  const ::cockroach::roachpb::Attributes& attrs() const;
  ::cockroach::roachpb::Attributes* release_attrs();
  ::cockroach::roachpb::Attributes* mutable_attrs();
  void set_allocated_attrs(::cockroach::roachpb::Attributes* attrs);

  bool has_node() const;
  void clear_node();
  static const int kNodeFieldNumber = 3;
  private:
  const ::cockroach::roachpb::NodeDescriptor& _internal_node() const;
  public:
  const ::cockroach::roachpb::NodeDescriptor& node() const;
  ::cockroach::roachpb::NodeDescriptor* release_node();
  ::cockroach::roachpb::NodeDescriptor* mutable_node();
  void set_allocated_node(::cockroach::roachpb::NodeDescriptor* node);

  bool has_capacity() const;
  void clear_capacity();
  static const int kCapacityFieldNumber = 4;
  private:
  const ::cockroach::roachpb::StoreCapacity& _internal_capacity() const;
  public:
  const ::cockroach::roachpb::StoreCapacity& capacity() const;
  ::cockroach::roachpb::StoreCapacity* release_capacity();
  ::cockroach::roachpb::StoreCapacity* mutable_capacity();
  void set_allocated_capacity(::cockroach::roachpb::StoreCapacity* capacity);

  bool has_store_id() const;
  void clear_store_id();
  static const int kStoreIdFieldNumber = 1;
  ::google::protobuf::int32 store_id() const;
  void set_store_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.StoreDescriptor)
 private:
  void set_has_store_id();
  void clear_has_store_id();
  void set_has_attrs();
  void clear_has_attrs();
  void set_has_node();
  void clear_has_node();
  void set_has_capacity();
  void clear_has_capacity();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::cockroach::roachpb::Attributes* attrs_;
  ::cockroach::roachpb::NodeDescriptor* node_;
  ::cockroach::roachpb::StoreCapacity* capacity_;
  ::google::protobuf::int32 store_id_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class StoreDeadReplicas : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.StoreDeadReplicas) */ {
 public:
  StoreDeadReplicas();
  virtual ~StoreDeadReplicas();

  StoreDeadReplicas(const StoreDeadReplicas& from);

  inline StoreDeadReplicas& operator=(const StoreDeadReplicas& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StoreDeadReplicas(StoreDeadReplicas&& from) noexcept
    : StoreDeadReplicas() {
    *this = ::std::move(from);
  }

  inline StoreDeadReplicas& operator=(StoreDeadReplicas&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const StoreDeadReplicas& default_instance();

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

  void Swap(StoreDeadReplicas* other);
  friend void swap(StoreDeadReplicas& a, StoreDeadReplicas& b) {
    a.Swap(&b);
  }

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

  inline StoreDeadReplicas* New() const final {
    return CreateMaybeMessage<StoreDeadReplicas>(NULL);
  }

  StoreDeadReplicas* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StoreDeadReplicas>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const StoreDeadReplicas& from);
  void MergeFrom(const StoreDeadReplicas& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(StoreDeadReplicas* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  int replicas_size() const;
  void clear_replicas();
  static const int kReplicasFieldNumber = 2;
  ::cockroach::roachpb::ReplicaIdent* mutable_replicas(int index);
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaIdent >*
      mutable_replicas();
  const ::cockroach::roachpb::ReplicaIdent& replicas(int index) const;
  ::cockroach::roachpb::ReplicaIdent* add_replicas();
  const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaIdent >&
      replicas() const;

  bool has_store_id() const;
  void clear_store_id();
  static const int kStoreIdFieldNumber = 1;
  ::google::protobuf::int32 store_id() const;
  void set_store_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.StoreDeadReplicas)
 private:
  void set_has_store_id();
  void clear_has_store_id();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaIdent > replicas_;
  ::google::protobuf::int32 store_id_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Locality : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.Locality) */ {
 public:
  Locality();
  virtual ~Locality();

  Locality(const Locality& from);

  inline Locality& operator=(const Locality& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Locality(Locality&& from) noexcept
    : Locality() {
    *this = ::std::move(from);
  }

  inline Locality& operator=(Locality&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const Locality& default_instance();

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

  void Swap(Locality* other);
  friend void swap(Locality& a, Locality& b) {
    a.Swap(&b);
  }

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

  inline Locality* New() const final {
    return CreateMaybeMessage<Locality>(NULL);
  }

  Locality* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Locality>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const Locality& from);
  void MergeFrom(const Locality& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Locality* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  int tiers_size() const;
  void clear_tiers();
  static const int kTiersFieldNumber = 1;
  ::cockroach::roachpb::Tier* mutable_tiers(int index);
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::Tier >*
      mutable_tiers();
  const ::cockroach::roachpb::Tier& tiers(int index) const;
  ::cockroach::roachpb::Tier* add_tiers();
  const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::Tier >&
      tiers() const;

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.Locality)
 private:

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::Tier > tiers_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Tier : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.Tier) */ {
 public:
  Tier();
  virtual ~Tier();

  Tier(const Tier& from);

  inline Tier& operator=(const Tier& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Tier(Tier&& from) noexcept
    : Tier() {
    *this = ::std::move(from);
  }

  inline Tier& operator=(Tier&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const Tier& default_instance();

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

  void Swap(Tier* other);
  friend void swap(Tier& a, Tier& b) {
    a.Swap(&b);
  }

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

  inline Tier* New() const final {
    return CreateMaybeMessage<Tier>(NULL);
  }

  Tier* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Tier>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const Tier& from);
  void MergeFrom(const Tier& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Tier* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_key() const;
  void clear_key();
  static const int kKeyFieldNumber = 1;
  const ::std::string& key() const;
  void set_key(const ::std::string& value);
  #if LANG_CXX11
  void set_key(::std::string&& value);
  #endif
  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);

  bool has_value() const;
  void clear_value();
  static const int kValueFieldNumber = 2;
  const ::std::string& value() const;
  void set_value(const ::std::string& value);
  #if LANG_CXX11
  void set_value(::std::string&& value);
  #endif
  void set_value(const char* value);
  void set_value(const char* value, size_t size);
  ::std::string* mutable_value();
  ::std::string* release_value();
  void set_allocated_value(::std::string* value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.Tier)
 private:
  void set_has_key();
  void clear_has_key();
  void set_has_value();
  void clear_has_value();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr key_;
  ::google::protobuf::internal::ArenaStringPtr value_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Version : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.Version) */ {
 public:
  Version();
  virtual ~Version();

  Version(const Version& from);

  inline Version& operator=(const Version& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Version(Version&& from) noexcept
    : Version() {
    *this = ::std::move(from);
  }

  inline Version& operator=(Version&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const Version& default_instance();

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

  void Swap(Version* other);
  friend void swap(Version& a, Version& b) {
    a.Swap(&b);
  }

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

  inline Version* New() const final {
    return CreateMaybeMessage<Version>(NULL);
  }

  Version* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Version>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const Version& from);
  void MergeFrom(const Version& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Version* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_major_val() const;
  void clear_major_val();
  static const int kMajorValFieldNumber = 1;
  ::google::protobuf::int32 major_val() const;
  void set_major_val(::google::protobuf::int32 value);

  bool has_minor_val() const;
  void clear_minor_val();
  static const int kMinorValFieldNumber = 2;
  ::google::protobuf::int32 minor_val() const;
  void set_minor_val(::google::protobuf::int32 value);

  bool has_patch() const;
  void clear_patch();
  static const int kPatchFieldNumber = 3;
  ::google::protobuf::int32 patch() const;
  void set_patch(::google::protobuf::int32 value);

  bool has_unstable() const;
  void clear_unstable();
  static const int kUnstableFieldNumber = 4;
  ::google::protobuf::int32 unstable() const;
  void set_unstable(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.Version)
 private:
  void set_has_major_val();
  void clear_has_major_val();
  void set_has_minor_val();
  void clear_has_minor_val();
  void set_has_patch();
  void clear_has_patch();
  void set_has_unstable();
  void clear_has_unstable();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 major_val_;
  ::google::protobuf::int32 minor_val_;
  ::google::protobuf::int32 patch_;
  ::google::protobuf::int32 unstable_;
  friend struct ::protobuf_roachpb_2fmetadata_2eproto::TableStruct;
};
// ===================================================================


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

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

inline int Attributes::attrs_size() const {
  return attrs_.size();
}
inline void Attributes::clear_attrs() {
  attrs_.Clear();
}
inline const ::std::string& Attributes::attrs(int index) const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Attributes.attrs)
  return attrs_.Get(index);
}
inline ::std::string* Attributes::mutable_attrs(int index) {
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.Attributes.attrs)
  return attrs_.Mutable(index);
}
inline void Attributes::set_attrs(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Attributes.attrs)
  attrs_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void Attributes::set_attrs(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Attributes.attrs)
  attrs_.Mutable(index)->assign(std::move(value));
}
#endif
inline void Attributes::set_attrs(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  attrs_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.Attributes.attrs)
}
inline void Attributes::set_attrs(int index, const char* value, size_t size) {
  attrs_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.Attributes.attrs)
}
inline ::std::string* Attributes::add_attrs() {
  // @@protoc_insertion_point(field_add_mutable:cockroach.roachpb.Attributes.attrs)
  return attrs_.Add();
}
inline void Attributes::add_attrs(const ::std::string& value) {
  attrs_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:cockroach.roachpb.Attributes.attrs)
}
#if LANG_CXX11
inline void Attributes::add_attrs(::std::string&& value) {
  attrs_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:cockroach.roachpb.Attributes.attrs)
}
#endif
inline void Attributes::add_attrs(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  attrs_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:cockroach.roachpb.Attributes.attrs)
}
inline void Attributes::add_attrs(const char* value, size_t size) {
  attrs_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:cockroach.roachpb.Attributes.attrs)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
Attributes::attrs() const {
  // @@protoc_insertion_point(field_list:cockroach.roachpb.Attributes.attrs)
  return attrs_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
Attributes::mutable_attrs() {
  // @@protoc_insertion_point(field_mutable_list:cockroach.roachpb.Attributes.attrs)
  return &attrs_;
}

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

// ReplicationTarget

inline bool ReplicationTarget::has_node_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReplicationTarget::set_has_node_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReplicationTarget::clear_has_node_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReplicationTarget::clear_node_id() {
  node_id_ = 0;
  clear_has_node_id();
}
inline ::google::protobuf::int32 ReplicationTarget::node_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReplicationTarget.node_id)
  return node_id_;
}
inline void ReplicationTarget::set_node_id(::google::protobuf::int32 value) {
  set_has_node_id();
  node_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.ReplicationTarget.node_id)
}

inline bool ReplicationTarget::has_store_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReplicationTarget::set_has_store_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ReplicationTarget::clear_has_store_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ReplicationTarget::clear_store_id() {
  store_id_ = 0;
  clear_has_store_id();
}
inline ::google::protobuf::int32 ReplicationTarget::store_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReplicationTarget.store_id)
  return store_id_;
}
inline void ReplicationTarget::set_store_id(::google::protobuf::int32 value) {
  set_has_store_id();
  store_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.ReplicationTarget.store_id)
}

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

// ReplicaDescriptor

inline bool ReplicaDescriptor::has_node_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReplicaDescriptor::set_has_node_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReplicaDescriptor::clear_has_node_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReplicaDescriptor::clear_node_id() {
  node_id_ = 0;
  clear_has_node_id();
}
inline ::google::protobuf::int32 ReplicaDescriptor::node_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReplicaDescriptor.node_id)
  return node_id_;
}
inline void ReplicaDescriptor::set_node_id(::google::protobuf::int32 value) {
  set_has_node_id();
  node_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.ReplicaDescriptor.node_id)
}

inline bool ReplicaDescriptor::has_store_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReplicaDescriptor::set_has_store_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ReplicaDescriptor::clear_has_store_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ReplicaDescriptor::clear_store_id() {
  store_id_ = 0;
  clear_has_store_id();
}
inline ::google::protobuf::int32 ReplicaDescriptor::store_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReplicaDescriptor.store_id)
  return store_id_;
}
inline void ReplicaDescriptor::set_store_id(::google::protobuf::int32 value) {
  set_has_store_id();
  store_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.ReplicaDescriptor.store_id)
}

inline bool ReplicaDescriptor::has_replica_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ReplicaDescriptor::set_has_replica_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ReplicaDescriptor::clear_has_replica_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ReplicaDescriptor::clear_replica_id() {
  replica_id_ = 0;
  clear_has_replica_id();
}
inline ::google::protobuf::int32 ReplicaDescriptor::replica_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReplicaDescriptor.replica_id)
  return replica_id_;
}
inline void ReplicaDescriptor::set_replica_id(::google::protobuf::int32 value) {
  set_has_replica_id();
  replica_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.ReplicaDescriptor.replica_id)
}

// optional .cockroach.roachpb.ReplicaType type = 4;
inline bool ReplicaDescriptor::has_type() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ReplicaDescriptor::set_has_type() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ReplicaDescriptor::clear_has_type() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ReplicaDescriptor::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::cockroach::roachpb::ReplicaType ReplicaDescriptor::type() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReplicaDescriptor.type)
  return static_cast< ::cockroach::roachpb::ReplicaType >(type_);
}
inline void ReplicaDescriptor::set_type(::cockroach::roachpb::ReplicaType value) {
  assert(::cockroach::roachpb::ReplicaType_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.ReplicaDescriptor.type)
}

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

// ReplicaIdent

inline bool ReplicaIdent::has_range_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReplicaIdent::set_has_range_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ReplicaIdent::clear_has_range_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ReplicaIdent::clear_range_id() {
  range_id_ = GOOGLE_LONGLONG(0);
  clear_has_range_id();
}
inline ::google::protobuf::int64 ReplicaIdent::range_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReplicaIdent.range_id)
  return range_id_;
}
inline void ReplicaIdent::set_range_id(::google::protobuf::int64 value) {
  set_has_range_id();
  range_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.ReplicaIdent.range_id)
}

inline bool ReplicaIdent::has_replica() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReplicaIdent::set_has_replica() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReplicaIdent::clear_has_replica() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReplicaIdent::clear_replica() {
  if (replica_ != NULL) replica_->Clear();
  clear_has_replica();
}
inline const ::cockroach::roachpb::ReplicaDescriptor& ReplicaIdent::_internal_replica() const {
  return *replica_;
}
inline const ::cockroach::roachpb::ReplicaDescriptor& ReplicaIdent::replica() const {
  const ::cockroach::roachpb::ReplicaDescriptor* p = replica_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReplicaIdent.replica)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::ReplicaDescriptor*>(
      &::cockroach::roachpb::_ReplicaDescriptor_default_instance_);
}
inline ::cockroach::roachpb::ReplicaDescriptor* ReplicaIdent::release_replica() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ReplicaIdent.replica)
  clear_has_replica();
  ::cockroach::roachpb::ReplicaDescriptor* temp = replica_;
  replica_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::ReplicaDescriptor* ReplicaIdent::mutable_replica() {
  set_has_replica();
  if (replica_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::ReplicaDescriptor>(GetArenaNoVirtual());
    replica_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ReplicaIdent.replica)
  return replica_;
}
inline void ReplicaIdent::set_allocated_replica(::cockroach::roachpb::ReplicaDescriptor* replica) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete replica_;
  }
  if (replica) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      replica = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, replica, submessage_arena);
    }
    set_has_replica();
  } else {
    clear_has_replica();
  }
  replica_ = replica;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.ReplicaIdent.replica)
}

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

// RangeDescriptor

inline bool RangeDescriptor::has_range_id() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void RangeDescriptor::set_has_range_id() {
  _has_bits_[0] |= 0x00000008u;
}
inline void RangeDescriptor::clear_has_range_id() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void RangeDescriptor::clear_range_id() {
  range_id_ = GOOGLE_LONGLONG(0);
  clear_has_range_id();
}
inline ::google::protobuf::int64 RangeDescriptor::range_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeDescriptor.range_id)
  return range_id_;
}
inline void RangeDescriptor::set_range_id(::google::protobuf::int64 value) {
  set_has_range_id();
  range_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeDescriptor.range_id)
}

inline bool RangeDescriptor::has_start_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RangeDescriptor::set_has_start_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RangeDescriptor::clear_has_start_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RangeDescriptor::clear_start_key() {
  start_key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_start_key();
}
inline const ::std::string& RangeDescriptor::start_key() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeDescriptor.start_key)
  return start_key_.GetNoArena();
}
inline void RangeDescriptor::set_start_key(const ::std::string& value) {
  set_has_start_key();
  start_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeDescriptor.start_key)
}
#if LANG_CXX11
inline void RangeDescriptor::set_start_key(::std::string&& value) {
  set_has_start_key();
  start_key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.RangeDescriptor.start_key)
}
#endif
inline void RangeDescriptor::set_start_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_start_key();
  start_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.RangeDescriptor.start_key)
}
inline void RangeDescriptor::set_start_key(const void* value, size_t size) {
  set_has_start_key();
  start_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.RangeDescriptor.start_key)
}
inline ::std::string* RangeDescriptor::mutable_start_key() {
  set_has_start_key();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.RangeDescriptor.start_key)
  return start_key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RangeDescriptor::release_start_key() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.RangeDescriptor.start_key)
  if (!has_start_key()) {
    return NULL;
  }
  clear_has_start_key();
  return start_key_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RangeDescriptor::set_allocated_start_key(::std::string* start_key) {
  if (start_key != NULL) {
    set_has_start_key();
  } else {
    clear_has_start_key();
  }
  start_key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), start_key);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.RangeDescriptor.start_key)
}

inline bool RangeDescriptor::has_end_key() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RangeDescriptor::set_has_end_key() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RangeDescriptor::clear_has_end_key() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RangeDescriptor::clear_end_key() {
  end_key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_end_key();
}
inline const ::std::string& RangeDescriptor::end_key() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeDescriptor.end_key)
  return end_key_.GetNoArena();
}
inline void RangeDescriptor::set_end_key(const ::std::string& value) {
  set_has_end_key();
  end_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeDescriptor.end_key)
}
#if LANG_CXX11
inline void RangeDescriptor::set_end_key(::std::string&& value) {
  set_has_end_key();
  end_key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.RangeDescriptor.end_key)
}
#endif
inline void RangeDescriptor::set_end_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_end_key();
  end_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.RangeDescriptor.end_key)
}
inline void RangeDescriptor::set_end_key(const void* value, size_t size) {
  set_has_end_key();
  end_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.RangeDescriptor.end_key)
}
inline ::std::string* RangeDescriptor::mutable_end_key() {
  set_has_end_key();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.RangeDescriptor.end_key)
  return end_key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RangeDescriptor::release_end_key() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.RangeDescriptor.end_key)
  if (!has_end_key()) {
    return NULL;
  }
  clear_has_end_key();
  return end_key_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RangeDescriptor::set_allocated_end_key(::std::string* end_key) {
  if (end_key != NULL) {
    set_has_end_key();
  } else {
    clear_has_end_key();
  }
  end_key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), end_key);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.RangeDescriptor.end_key)
}

inline int RangeDescriptor::internal_replicas_size() const {
  return internal_replicas_.size();
}
inline void RangeDescriptor::clear_internal_replicas() {
  internal_replicas_.Clear();
}
inline ::cockroach::roachpb::ReplicaDescriptor* RangeDescriptor::mutable_internal_replicas(int index) {
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.RangeDescriptor.internal_replicas)
  return internal_replicas_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaDescriptor >*
RangeDescriptor::mutable_internal_replicas() {
  // @@protoc_insertion_point(field_mutable_list:cockroach.roachpb.RangeDescriptor.internal_replicas)
  return &internal_replicas_;
}
inline const ::cockroach::roachpb::ReplicaDescriptor& RangeDescriptor::internal_replicas(int index) const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeDescriptor.internal_replicas)
  return internal_replicas_.Get(index);
}
inline ::cockroach::roachpb::ReplicaDescriptor* RangeDescriptor::add_internal_replicas() {
  // @@protoc_insertion_point(field_add:cockroach.roachpb.RangeDescriptor.internal_replicas)
  return internal_replicas_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaDescriptor >&
RangeDescriptor::internal_replicas() const {
  // @@protoc_insertion_point(field_list:cockroach.roachpb.RangeDescriptor.internal_replicas)
  return internal_replicas_;
}

inline bool RangeDescriptor::has_next_replica_id() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void RangeDescriptor::set_has_next_replica_id() {
  _has_bits_[0] |= 0x00000020u;
}
inline void RangeDescriptor::clear_has_next_replica_id() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void RangeDescriptor::clear_next_replica_id() {
  next_replica_id_ = 0;
  clear_has_next_replica_id();
}
inline ::google::protobuf::int32 RangeDescriptor::next_replica_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeDescriptor.next_replica_id)
  return next_replica_id_;
}
inline void RangeDescriptor::set_next_replica_id(::google::protobuf::int32 value) {
  set_has_next_replica_id();
  next_replica_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeDescriptor.next_replica_id)
}

inline bool RangeDescriptor::has_generation() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void RangeDescriptor::set_has_generation() {
  _has_bits_[0] |= 0x00000010u;
}
inline void RangeDescriptor::clear_has_generation() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void RangeDescriptor::clear_generation() {
  generation_ = GOOGLE_LONGLONG(0);
  clear_has_generation();
}
inline ::google::protobuf::int64 RangeDescriptor::generation() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeDescriptor.generation)
  return generation_;
}
inline void RangeDescriptor::set_generation(::google::protobuf::int64 value) {
  set_has_generation();
  generation_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeDescriptor.generation)
}

// optional .cockroach.util.hlc.Timestamp sticky_bit = 7;
inline bool RangeDescriptor::has_sticky_bit() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RangeDescriptor::set_has_sticky_bit() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RangeDescriptor::clear_has_sticky_bit() {
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::cockroach::util::hlc::Timestamp& RangeDescriptor::_internal_sticky_bit() const {
  return *sticky_bit_;
}
inline const ::cockroach::util::hlc::Timestamp& RangeDescriptor::sticky_bit() const {
  const ::cockroach::util::hlc::Timestamp* p = sticky_bit_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeDescriptor.sticky_bit)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::util::hlc::Timestamp*>(
      &::cockroach::util::hlc::_Timestamp_default_instance_);
}
inline ::cockroach::util::hlc::Timestamp* RangeDescriptor::release_sticky_bit() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.RangeDescriptor.sticky_bit)
  clear_has_sticky_bit();
  ::cockroach::util::hlc::Timestamp* temp = sticky_bit_;
  sticky_bit_ = NULL;
  return temp;
}
inline ::cockroach::util::hlc::Timestamp* RangeDescriptor::mutable_sticky_bit() {
  set_has_sticky_bit();
  if (sticky_bit_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::util::hlc::Timestamp>(GetArenaNoVirtual());
    sticky_bit_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.RangeDescriptor.sticky_bit)
  return sticky_bit_;
}
inline void RangeDescriptor::set_allocated_sticky_bit(::cockroach::util::hlc::Timestamp* sticky_bit) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(sticky_bit_);
  }
  if (sticky_bit) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      sticky_bit = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, sticky_bit, submessage_arena);
    }
    set_has_sticky_bit();
  } else {
    clear_has_sticky_bit();
  }
  sticky_bit_ = sticky_bit;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.RangeDescriptor.sticky_bit)
}

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

// Percentiles

inline bool Percentiles::has_p10() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Percentiles::set_has_p10() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Percentiles::clear_has_p10() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Percentiles::clear_p10() {
  p10_ = 0;
  clear_has_p10();
}
inline double Percentiles::p10() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Percentiles.p10)
  return p10_;
}
inline void Percentiles::set_p10(double value) {
  set_has_p10();
  p10_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Percentiles.p10)
}

inline bool Percentiles::has_p25() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Percentiles::set_has_p25() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Percentiles::clear_has_p25() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Percentiles::clear_p25() {
  p25_ = 0;
  clear_has_p25();
}
inline double Percentiles::p25() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Percentiles.p25)
  return p25_;
}
inline void Percentiles::set_p25(double value) {
  set_has_p25();
  p25_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Percentiles.p25)
}

inline bool Percentiles::has_p50() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Percentiles::set_has_p50() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Percentiles::clear_has_p50() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Percentiles::clear_p50() {
  p50_ = 0;
  clear_has_p50();
}
inline double Percentiles::p50() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Percentiles.p50)
  return p50_;
}
inline void Percentiles::set_p50(double value) {
  set_has_p50();
  p50_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Percentiles.p50)
}

inline bool Percentiles::has_p75() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Percentiles::set_has_p75() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Percentiles::clear_has_p75() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Percentiles::clear_p75() {
  p75_ = 0;
  clear_has_p75();
}
inline double Percentiles::p75() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Percentiles.p75)
  return p75_;
}
inline void Percentiles::set_p75(double value) {
  set_has_p75();
  p75_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Percentiles.p75)
}

inline bool Percentiles::has_p90() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Percentiles::set_has_p90() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Percentiles::clear_has_p90() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Percentiles::clear_p90() {
  p90_ = 0;
  clear_has_p90();
}
inline double Percentiles::p90() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Percentiles.p90)
  return p90_;
}
inline void Percentiles::set_p90(double value) {
  set_has_p90();
  p90_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Percentiles.p90)
}

inline bool Percentiles::has_pmax() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Percentiles::set_has_pmax() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Percentiles::clear_has_pmax() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Percentiles::clear_pmax() {
  pmax_ = 0;
  clear_has_pmax();
}
inline double Percentiles::pmax() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Percentiles.pMax)
  return pmax_;
}
inline void Percentiles::set_pmax(double value) {
  set_has_pmax();
  pmax_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Percentiles.pMax)
}

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

// StoreCapacity

inline bool StoreCapacity::has_capacity() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void StoreCapacity::set_has_capacity() {
  _has_bits_[0] |= 0x00000004u;
}
inline void StoreCapacity::clear_has_capacity() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void StoreCapacity::clear_capacity() {
  capacity_ = GOOGLE_LONGLONG(0);
  clear_has_capacity();
}
inline ::google::protobuf::int64 StoreCapacity::capacity() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreCapacity.capacity)
  return capacity_;
}
inline void StoreCapacity::set_capacity(::google::protobuf::int64 value) {
  set_has_capacity();
  capacity_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.StoreCapacity.capacity)
}

inline bool StoreCapacity::has_available() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void StoreCapacity::set_has_available() {
  _has_bits_[0] |= 0x00000008u;
}
inline void StoreCapacity::clear_has_available() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void StoreCapacity::clear_available() {
  available_ = GOOGLE_LONGLONG(0);
  clear_has_available();
}
inline ::google::protobuf::int64 StoreCapacity::available() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreCapacity.available)
  return available_;
}
inline void StoreCapacity::set_available(::google::protobuf::int64 value) {
  set_has_available();
  available_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.StoreCapacity.available)
}

inline bool StoreCapacity::has_used() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void StoreCapacity::set_has_used() {
  _has_bits_[0] |= 0x00000080u;
}
inline void StoreCapacity::clear_has_used() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void StoreCapacity::clear_used() {
  used_ = GOOGLE_LONGLONG(0);
  clear_has_used();
}
inline ::google::protobuf::int64 StoreCapacity::used() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreCapacity.used)
  return used_;
}
inline void StoreCapacity::set_used(::google::protobuf::int64 value) {
  set_has_used();
  used_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.StoreCapacity.used)
}

inline bool StoreCapacity::has_logical_bytes() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void StoreCapacity::set_has_logical_bytes() {
  _has_bits_[0] |= 0x00000100u;
}
inline void StoreCapacity::clear_has_logical_bytes() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void StoreCapacity::clear_logical_bytes() {
  logical_bytes_ = GOOGLE_LONGLONG(0);
  clear_has_logical_bytes();
}
inline ::google::protobuf::int64 StoreCapacity::logical_bytes() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreCapacity.logical_bytes)
  return logical_bytes_;
}
inline void StoreCapacity::set_logical_bytes(::google::protobuf::int64 value) {
  set_has_logical_bytes();
  logical_bytes_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.StoreCapacity.logical_bytes)
}

inline bool StoreCapacity::has_range_count() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void StoreCapacity::set_has_range_count() {
  _has_bits_[0] |= 0x00000010u;
}
inline void StoreCapacity::clear_has_range_count() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void StoreCapacity::clear_range_count() {
  range_count_ = 0;
  clear_has_range_count();
}
inline ::google::protobuf::int32 StoreCapacity::range_count() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreCapacity.range_count)
  return range_count_;
}
inline void StoreCapacity::set_range_count(::google::protobuf::int32 value) {
  set_has_range_count();
  range_count_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.StoreCapacity.range_count)
}

inline bool StoreCapacity::has_lease_count() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void StoreCapacity::set_has_lease_count() {
  _has_bits_[0] |= 0x00000020u;
}
inline void StoreCapacity::clear_has_lease_count() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void StoreCapacity::clear_lease_count() {
  lease_count_ = 0;
  clear_has_lease_count();
}
inline ::google::protobuf::int32 StoreCapacity::lease_count() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreCapacity.lease_count)
  return lease_count_;
}
inline void StoreCapacity::set_lease_count(::google::protobuf::int32 value) {
  set_has_lease_count();
  lease_count_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.StoreCapacity.lease_count)
}

inline bool StoreCapacity::has_queries_per_second() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void StoreCapacity::set_has_queries_per_second() {
  _has_bits_[0] |= 0x00000200u;
}
inline void StoreCapacity::clear_has_queries_per_second() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void StoreCapacity::clear_queries_per_second() {
  queries_per_second_ = 0;
  clear_has_queries_per_second();
}
inline double StoreCapacity::queries_per_second() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreCapacity.queries_per_second)
  return queries_per_second_;
}
inline void StoreCapacity::set_queries_per_second(double value) {
  set_has_queries_per_second();
  queries_per_second_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.StoreCapacity.queries_per_second)
}

inline bool StoreCapacity::has_writes_per_second() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void StoreCapacity::set_has_writes_per_second() {
  _has_bits_[0] |= 0x00000040u;
}
inline void StoreCapacity::clear_has_writes_per_second() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void StoreCapacity::clear_writes_per_second() {
  writes_per_second_ = 0;
  clear_has_writes_per_second();
}
inline double StoreCapacity::writes_per_second() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreCapacity.writes_per_second)
  return writes_per_second_;
}
inline void StoreCapacity::set_writes_per_second(double value) {
  set_has_writes_per_second();
  writes_per_second_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.StoreCapacity.writes_per_second)
}

inline bool StoreCapacity::has_bytes_per_replica() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StoreCapacity::set_has_bytes_per_replica() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StoreCapacity::clear_has_bytes_per_replica() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StoreCapacity::clear_bytes_per_replica() {
  if (bytes_per_replica_ != NULL) bytes_per_replica_->Clear();
  clear_has_bytes_per_replica();
}
inline const ::cockroach::roachpb::Percentiles& StoreCapacity::_internal_bytes_per_replica() const {
  return *bytes_per_replica_;
}
inline const ::cockroach::roachpb::Percentiles& StoreCapacity::bytes_per_replica() const {
  const ::cockroach::roachpb::Percentiles* p = bytes_per_replica_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreCapacity.bytes_per_replica)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Percentiles*>(
      &::cockroach::roachpb::_Percentiles_default_instance_);
}
inline ::cockroach::roachpb::Percentiles* StoreCapacity::release_bytes_per_replica() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.StoreCapacity.bytes_per_replica)
  clear_has_bytes_per_replica();
  ::cockroach::roachpb::Percentiles* temp = bytes_per_replica_;
  bytes_per_replica_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Percentiles* StoreCapacity::mutable_bytes_per_replica() {
  set_has_bytes_per_replica();
  if (bytes_per_replica_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Percentiles>(GetArenaNoVirtual());
    bytes_per_replica_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.StoreCapacity.bytes_per_replica)
  return bytes_per_replica_;
}
inline void StoreCapacity::set_allocated_bytes_per_replica(::cockroach::roachpb::Percentiles* bytes_per_replica) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete bytes_per_replica_;
  }
  if (bytes_per_replica) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      bytes_per_replica = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, bytes_per_replica, submessage_arena);
    }
    set_has_bytes_per_replica();
  } else {
    clear_has_bytes_per_replica();
  }
  bytes_per_replica_ = bytes_per_replica;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.StoreCapacity.bytes_per_replica)
}

inline bool StoreCapacity::has_writes_per_replica() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StoreCapacity::set_has_writes_per_replica() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StoreCapacity::clear_has_writes_per_replica() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StoreCapacity::clear_writes_per_replica() {
  if (writes_per_replica_ != NULL) writes_per_replica_->Clear();
  clear_has_writes_per_replica();
}
inline const ::cockroach::roachpb::Percentiles& StoreCapacity::_internal_writes_per_replica() const {
  return *writes_per_replica_;
}
inline const ::cockroach::roachpb::Percentiles& StoreCapacity::writes_per_replica() const {
  const ::cockroach::roachpb::Percentiles* p = writes_per_replica_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreCapacity.writes_per_replica)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Percentiles*>(
      &::cockroach::roachpb::_Percentiles_default_instance_);
}
inline ::cockroach::roachpb::Percentiles* StoreCapacity::release_writes_per_replica() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.StoreCapacity.writes_per_replica)
  clear_has_writes_per_replica();
  ::cockroach::roachpb::Percentiles* temp = writes_per_replica_;
  writes_per_replica_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Percentiles* StoreCapacity::mutable_writes_per_replica() {
  set_has_writes_per_replica();
  if (writes_per_replica_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Percentiles>(GetArenaNoVirtual());
    writes_per_replica_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.StoreCapacity.writes_per_replica)
  return writes_per_replica_;
}
inline void StoreCapacity::set_allocated_writes_per_replica(::cockroach::roachpb::Percentiles* writes_per_replica) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete writes_per_replica_;
  }
  if (writes_per_replica) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      writes_per_replica = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, writes_per_replica, submessage_arena);
    }
    set_has_writes_per_replica();
  } else {
    clear_has_writes_per_replica();
  }
  writes_per_replica_ = writes_per_replica;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.StoreCapacity.writes_per_replica)
}

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

// NodeDescriptor

inline bool NodeDescriptor::has_node_id() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void NodeDescriptor::set_has_node_id() {
  _has_bits_[0] |= 0x00000100u;
}
inline void NodeDescriptor::clear_has_node_id() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void NodeDescriptor::clear_node_id() {
  node_id_ = 0;
  clear_has_node_id();
}
inline ::google::protobuf::int32 NodeDescriptor::node_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NodeDescriptor.node_id)
  return node_id_;
}
inline void NodeDescriptor::set_node_id(::google::protobuf::int32 value) {
  set_has_node_id();
  node_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.NodeDescriptor.node_id)
}

inline bool NodeDescriptor::has_address() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NodeDescriptor::set_has_address() {
  _has_bits_[0] |= 0x00000004u;
}
inline void NodeDescriptor::clear_has_address() {
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::cockroach::util::UnresolvedAddr& NodeDescriptor::_internal_address() const {
  return *address_;
}
inline const ::cockroach::util::UnresolvedAddr& NodeDescriptor::address() const {
  const ::cockroach::util::UnresolvedAddr* p = address_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NodeDescriptor.address)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::util::UnresolvedAddr*>(
      &::cockroach::util::_UnresolvedAddr_default_instance_);
}
inline ::cockroach::util::UnresolvedAddr* NodeDescriptor::release_address() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.NodeDescriptor.address)
  clear_has_address();
  ::cockroach::util::UnresolvedAddr* temp = address_;
  address_ = NULL;
  return temp;
}
inline ::cockroach::util::UnresolvedAddr* NodeDescriptor::mutable_address() {
  set_has_address();
  if (address_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::util::UnresolvedAddr>(GetArenaNoVirtual());
    address_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NodeDescriptor.address)
  return address_;
}
inline void NodeDescriptor::set_allocated_address(::cockroach::util::UnresolvedAddr* address) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(address_);
  }
  if (address) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      address = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, address, submessage_arena);
    }
    set_has_address();
  } else {
    clear_has_address();
  }
  address_ = address;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NodeDescriptor.address)
}

inline bool NodeDescriptor::has_attrs() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void NodeDescriptor::set_has_attrs() {
  _has_bits_[0] |= 0x00000008u;
}
inline void NodeDescriptor::clear_has_attrs() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void NodeDescriptor::clear_attrs() {
  if (attrs_ != NULL) attrs_->Clear();
  clear_has_attrs();
}
inline const ::cockroach::roachpb::Attributes& NodeDescriptor::_internal_attrs() const {
  return *attrs_;
}
inline const ::cockroach::roachpb::Attributes& NodeDescriptor::attrs() const {
  const ::cockroach::roachpb::Attributes* p = attrs_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NodeDescriptor.attrs)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Attributes*>(
      &::cockroach::roachpb::_Attributes_default_instance_);
}
inline ::cockroach::roachpb::Attributes* NodeDescriptor::release_attrs() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.NodeDescriptor.attrs)
  clear_has_attrs();
  ::cockroach::roachpb::Attributes* temp = attrs_;
  attrs_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Attributes* NodeDescriptor::mutable_attrs() {
  set_has_attrs();
  if (attrs_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Attributes>(GetArenaNoVirtual());
    attrs_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NodeDescriptor.attrs)
  return attrs_;
}
inline void NodeDescriptor::set_allocated_attrs(::cockroach::roachpb::Attributes* attrs) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete attrs_;
  }
  if (attrs) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      attrs = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, attrs, submessage_arena);
    }
    set_has_attrs();
  } else {
    clear_has_attrs();
  }
  attrs_ = attrs;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NodeDescriptor.attrs)
}

inline bool NodeDescriptor::has_locality() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void NodeDescriptor::set_has_locality() {
  _has_bits_[0] |= 0x00000010u;
}
inline void NodeDescriptor::clear_has_locality() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void NodeDescriptor::clear_locality() {
  if (locality_ != NULL) locality_->Clear();
  clear_has_locality();
}
inline const ::cockroach::roachpb::Locality& NodeDescriptor::_internal_locality() const {
  return *locality_;
}
inline const ::cockroach::roachpb::Locality& NodeDescriptor::locality() const {
  const ::cockroach::roachpb::Locality* p = locality_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NodeDescriptor.locality)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Locality*>(
      &::cockroach::roachpb::_Locality_default_instance_);
}
inline ::cockroach::roachpb::Locality* NodeDescriptor::release_locality() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.NodeDescriptor.locality)
  clear_has_locality();
  ::cockroach::roachpb::Locality* temp = locality_;
  locality_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Locality* NodeDescriptor::mutable_locality() {
  set_has_locality();
  if (locality_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Locality>(GetArenaNoVirtual());
    locality_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NodeDescriptor.locality)
  return locality_;
}
inline void NodeDescriptor::set_allocated_locality(::cockroach::roachpb::Locality* locality) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete locality_;
  }
  if (locality) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      locality = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, locality, submessage_arena);
    }
    set_has_locality();
  } else {
    clear_has_locality();
  }
  locality_ = locality;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NodeDescriptor.locality)
}

inline bool NodeDescriptor::has_serverversion() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void NodeDescriptor::set_has_serverversion() {
  _has_bits_[0] |= 0x00000020u;
}
inline void NodeDescriptor::clear_has_serverversion() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void NodeDescriptor::clear_serverversion() {
  if (serverversion_ != NULL) serverversion_->Clear();
  clear_has_serverversion();
}
inline const ::cockroach::roachpb::Version& NodeDescriptor::_internal_serverversion() const {
  return *serverversion_;
}
inline const ::cockroach::roachpb::Version& NodeDescriptor::serverversion() const {
  const ::cockroach::roachpb::Version* p = serverversion_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NodeDescriptor.ServerVersion)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Version*>(
      &::cockroach::roachpb::_Version_default_instance_);
}
inline ::cockroach::roachpb::Version* NodeDescriptor::release_serverversion() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.NodeDescriptor.ServerVersion)
  clear_has_serverversion();
  ::cockroach::roachpb::Version* temp = serverversion_;
  serverversion_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Version* NodeDescriptor::mutable_serverversion() {
  set_has_serverversion();
  if (serverversion_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Version>(GetArenaNoVirtual());
    serverversion_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NodeDescriptor.ServerVersion)
  return serverversion_;
}
inline void NodeDescriptor::set_allocated_serverversion(::cockroach::roachpb::Version* serverversion) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete serverversion_;
  }
  if (serverversion) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      serverversion = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, serverversion, submessage_arena);
    }
    set_has_serverversion();
  } else {
    clear_has_serverversion();
  }
  serverversion_ = serverversion;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NodeDescriptor.ServerVersion)
}

inline bool NodeDescriptor::has_build_tag() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NodeDescriptor::set_has_build_tag() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NodeDescriptor::clear_has_build_tag() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NodeDescriptor::clear_build_tag() {
  build_tag_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_build_tag();
}
inline const ::std::string& NodeDescriptor::build_tag() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NodeDescriptor.build_tag)
  return build_tag_.GetNoArena();
}
inline void NodeDescriptor::set_build_tag(const ::std::string& value) {
  set_has_build_tag();
  build_tag_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.NodeDescriptor.build_tag)
}
#if LANG_CXX11
inline void NodeDescriptor::set_build_tag(::std::string&& value) {
  set_has_build_tag();
  build_tag_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.NodeDescriptor.build_tag)
}
#endif
inline void NodeDescriptor::set_build_tag(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_build_tag();
  build_tag_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.NodeDescriptor.build_tag)
}
inline void NodeDescriptor::set_build_tag(const char* value, size_t size) {
  set_has_build_tag();
  build_tag_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.NodeDescriptor.build_tag)
}
inline ::std::string* NodeDescriptor::mutable_build_tag() {
  set_has_build_tag();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NodeDescriptor.build_tag)
  return build_tag_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* NodeDescriptor::release_build_tag() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.NodeDescriptor.build_tag)
  if (!has_build_tag()) {
    return NULL;
  }
  clear_has_build_tag();
  return build_tag_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NodeDescriptor::set_allocated_build_tag(::std::string* build_tag) {
  if (build_tag != NULL) {
    set_has_build_tag();
  } else {
    clear_has_build_tag();
  }
  build_tag_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), build_tag);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NodeDescriptor.build_tag)
}

inline bool NodeDescriptor::has_started_at() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void NodeDescriptor::set_has_started_at() {
  _has_bits_[0] |= 0x00000080u;
}
inline void NodeDescriptor::clear_has_started_at() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void NodeDescriptor::clear_started_at() {
  started_at_ = GOOGLE_LONGLONG(0);
  clear_has_started_at();
}
inline ::google::protobuf::int64 NodeDescriptor::started_at() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NodeDescriptor.started_at)
  return started_at_;
}
inline void NodeDescriptor::set_started_at(::google::protobuf::int64 value) {
  set_has_started_at();
  started_at_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.NodeDescriptor.started_at)
}

inline int NodeDescriptor::locality_address_size() const {
  return locality_address_.size();
}
inline void NodeDescriptor::clear_locality_address() {
  locality_address_.Clear();
}
inline ::cockroach::roachpb::LocalityAddress* NodeDescriptor::mutable_locality_address(int index) {
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NodeDescriptor.locality_address)
  return locality_address_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::LocalityAddress >*
NodeDescriptor::mutable_locality_address() {
  // @@protoc_insertion_point(field_mutable_list:cockroach.roachpb.NodeDescriptor.locality_address)
  return &locality_address_;
}
inline const ::cockroach::roachpb::LocalityAddress& NodeDescriptor::locality_address(int index) const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NodeDescriptor.locality_address)
  return locality_address_.Get(index);
}
inline ::cockroach::roachpb::LocalityAddress* NodeDescriptor::add_locality_address() {
  // @@protoc_insertion_point(field_add:cockroach.roachpb.NodeDescriptor.locality_address)
  return locality_address_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::LocalityAddress >&
NodeDescriptor::locality_address() const {
  // @@protoc_insertion_point(field_list:cockroach.roachpb.NodeDescriptor.locality_address)
  return locality_address_;
}

inline bool NodeDescriptor::has_cluster_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NodeDescriptor::set_has_cluster_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NodeDescriptor::clear_has_cluster_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NodeDescriptor::clear_cluster_name() {
  cluster_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_cluster_name();
}
inline const ::std::string& NodeDescriptor::cluster_name() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NodeDescriptor.cluster_name)
  return cluster_name_.GetNoArena();
}
inline void NodeDescriptor::set_cluster_name(const ::std::string& value) {
  set_has_cluster_name();
  cluster_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.NodeDescriptor.cluster_name)
}
#if LANG_CXX11
inline void NodeDescriptor::set_cluster_name(::std::string&& value) {
  set_has_cluster_name();
  cluster_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.NodeDescriptor.cluster_name)
}
#endif
inline void NodeDescriptor::set_cluster_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_cluster_name();
  cluster_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.NodeDescriptor.cluster_name)
}
inline void NodeDescriptor::set_cluster_name(const char* value, size_t size) {
  set_has_cluster_name();
  cluster_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.NodeDescriptor.cluster_name)
}
inline ::std::string* NodeDescriptor::mutable_cluster_name() {
  set_has_cluster_name();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NodeDescriptor.cluster_name)
  return cluster_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* NodeDescriptor::release_cluster_name() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.NodeDescriptor.cluster_name)
  if (!has_cluster_name()) {
    return NULL;
  }
  clear_has_cluster_name();
  return cluster_name_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NodeDescriptor::set_allocated_cluster_name(::std::string* cluster_name) {
  if (cluster_name != NULL) {
    set_has_cluster_name();
  } else {
    clear_has_cluster_name();
  }
  cluster_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), cluster_name);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NodeDescriptor.cluster_name)
}

inline bool NodeDescriptor::has_sql_address() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void NodeDescriptor::set_has_sql_address() {
  _has_bits_[0] |= 0x00000040u;
}
inline void NodeDescriptor::clear_has_sql_address() {
  _has_bits_[0] &= ~0x00000040u;
}
inline const ::cockroach::util::UnresolvedAddr& NodeDescriptor::_internal_sql_address() const {
  return *sql_address_;
}
inline const ::cockroach::util::UnresolvedAddr& NodeDescriptor::sql_address() const {
  const ::cockroach::util::UnresolvedAddr* p = sql_address_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NodeDescriptor.sql_address)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::util::UnresolvedAddr*>(
      &::cockroach::util::_UnresolvedAddr_default_instance_);
}
inline ::cockroach::util::UnresolvedAddr* NodeDescriptor::release_sql_address() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.NodeDescriptor.sql_address)
  clear_has_sql_address();
  ::cockroach::util::UnresolvedAddr* temp = sql_address_;
  sql_address_ = NULL;
  return temp;
}
inline ::cockroach::util::UnresolvedAddr* NodeDescriptor::mutable_sql_address() {
  set_has_sql_address();
  if (sql_address_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::util::UnresolvedAddr>(GetArenaNoVirtual());
    sql_address_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NodeDescriptor.sql_address)
  return sql_address_;
}
inline void NodeDescriptor::set_allocated_sql_address(::cockroach::util::UnresolvedAddr* sql_address) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(sql_address_);
  }
  if (sql_address) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      sql_address = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, sql_address, submessage_arena);
    }
    set_has_sql_address();
  } else {
    clear_has_sql_address();
  }
  sql_address_ = sql_address;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NodeDescriptor.sql_address)
}

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

// LocalityAddress

inline bool LocalityAddress::has_address() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LocalityAddress::set_has_address() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LocalityAddress::clear_has_address() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::cockroach::util::UnresolvedAddr& LocalityAddress::_internal_address() const {
  return *address_;
}
inline const ::cockroach::util::UnresolvedAddr& LocalityAddress::address() const {
  const ::cockroach::util::UnresolvedAddr* p = address_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.LocalityAddress.address)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::util::UnresolvedAddr*>(
      &::cockroach::util::_UnresolvedAddr_default_instance_);
}
inline ::cockroach::util::UnresolvedAddr* LocalityAddress::release_address() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.LocalityAddress.address)
  clear_has_address();
  ::cockroach::util::UnresolvedAddr* temp = address_;
  address_ = NULL;
  return temp;
}
inline ::cockroach::util::UnresolvedAddr* LocalityAddress::mutable_address() {
  set_has_address();
  if (address_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::util::UnresolvedAddr>(GetArenaNoVirtual());
    address_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.LocalityAddress.address)
  return address_;
}
inline void LocalityAddress::set_allocated_address(::cockroach::util::UnresolvedAddr* address) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(address_);
  }
  if (address) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      address = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, address, submessage_arena);
    }
    set_has_address();
  } else {
    clear_has_address();
  }
  address_ = address;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.LocalityAddress.address)
}

inline bool LocalityAddress::has_locality_tier() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LocalityAddress::set_has_locality_tier() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LocalityAddress::clear_has_locality_tier() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LocalityAddress::clear_locality_tier() {
  if (locality_tier_ != NULL) locality_tier_->Clear();
  clear_has_locality_tier();
}
inline const ::cockroach::roachpb::Tier& LocalityAddress::_internal_locality_tier() const {
  return *locality_tier_;
}
inline const ::cockroach::roachpb::Tier& LocalityAddress::locality_tier() const {
  const ::cockroach::roachpb::Tier* p = locality_tier_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.LocalityAddress.locality_tier)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Tier*>(
      &::cockroach::roachpb::_Tier_default_instance_);
}
inline ::cockroach::roachpb::Tier* LocalityAddress::release_locality_tier() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.LocalityAddress.locality_tier)
  clear_has_locality_tier();
  ::cockroach::roachpb::Tier* temp = locality_tier_;
  locality_tier_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Tier* LocalityAddress::mutable_locality_tier() {
  set_has_locality_tier();
  if (locality_tier_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Tier>(GetArenaNoVirtual());
    locality_tier_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.LocalityAddress.locality_tier)
  return locality_tier_;
}
inline void LocalityAddress::set_allocated_locality_tier(::cockroach::roachpb::Tier* locality_tier) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete locality_tier_;
  }
  if (locality_tier) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      locality_tier = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, locality_tier, submessage_arena);
    }
    set_has_locality_tier();
  } else {
    clear_has_locality_tier();
  }
  locality_tier_ = locality_tier;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.LocalityAddress.locality_tier)
}

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

// StoreDescriptor

inline bool StoreDescriptor::has_store_id() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void StoreDescriptor::set_has_store_id() {
  _has_bits_[0] |= 0x00000008u;
}
inline void StoreDescriptor::clear_has_store_id() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void StoreDescriptor::clear_store_id() {
  store_id_ = 0;
  clear_has_store_id();
}
inline ::google::protobuf::int32 StoreDescriptor::store_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreDescriptor.store_id)
  return store_id_;
}
inline void StoreDescriptor::set_store_id(::google::protobuf::int32 value) {
  set_has_store_id();
  store_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.StoreDescriptor.store_id)
}

inline bool StoreDescriptor::has_attrs() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StoreDescriptor::set_has_attrs() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StoreDescriptor::clear_has_attrs() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StoreDescriptor::clear_attrs() {
  if (attrs_ != NULL) attrs_->Clear();
  clear_has_attrs();
}
inline const ::cockroach::roachpb::Attributes& StoreDescriptor::_internal_attrs() const {
  return *attrs_;
}
inline const ::cockroach::roachpb::Attributes& StoreDescriptor::attrs() const {
  const ::cockroach::roachpb::Attributes* p = attrs_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreDescriptor.attrs)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Attributes*>(
      &::cockroach::roachpb::_Attributes_default_instance_);
}
inline ::cockroach::roachpb::Attributes* StoreDescriptor::release_attrs() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.StoreDescriptor.attrs)
  clear_has_attrs();
  ::cockroach::roachpb::Attributes* temp = attrs_;
  attrs_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Attributes* StoreDescriptor::mutable_attrs() {
  set_has_attrs();
  if (attrs_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Attributes>(GetArenaNoVirtual());
    attrs_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.StoreDescriptor.attrs)
  return attrs_;
}
inline void StoreDescriptor::set_allocated_attrs(::cockroach::roachpb::Attributes* attrs) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete attrs_;
  }
  if (attrs) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      attrs = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, attrs, submessage_arena);
    }
    set_has_attrs();
  } else {
    clear_has_attrs();
  }
  attrs_ = attrs;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.StoreDescriptor.attrs)
}

inline bool StoreDescriptor::has_node() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void StoreDescriptor::set_has_node() {
  _has_bits_[0] |= 0x00000002u;
}
inline void StoreDescriptor::clear_has_node() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void StoreDescriptor::clear_node() {
  if (node_ != NULL) node_->Clear();
  clear_has_node();
}
inline const ::cockroach::roachpb::NodeDescriptor& StoreDescriptor::_internal_node() const {
  return *node_;
}
inline const ::cockroach::roachpb::NodeDescriptor& StoreDescriptor::node() const {
  const ::cockroach::roachpb::NodeDescriptor* p = node_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreDescriptor.node)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::NodeDescriptor*>(
      &::cockroach::roachpb::_NodeDescriptor_default_instance_);
}
inline ::cockroach::roachpb::NodeDescriptor* StoreDescriptor::release_node() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.StoreDescriptor.node)
  clear_has_node();
  ::cockroach::roachpb::NodeDescriptor* temp = node_;
  node_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::NodeDescriptor* StoreDescriptor::mutable_node() {
  set_has_node();
  if (node_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::NodeDescriptor>(GetArenaNoVirtual());
    node_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.StoreDescriptor.node)
  return node_;
}
inline void StoreDescriptor::set_allocated_node(::cockroach::roachpb::NodeDescriptor* node) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete node_;
  }
  if (node) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      node = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, node, submessage_arena);
    }
    set_has_node();
  } else {
    clear_has_node();
  }
  node_ = node;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.StoreDescriptor.node)
}

inline bool StoreDescriptor::has_capacity() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void StoreDescriptor::set_has_capacity() {
  _has_bits_[0] |= 0x00000004u;
}
inline void StoreDescriptor::clear_has_capacity() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void StoreDescriptor::clear_capacity() {
  if (capacity_ != NULL) capacity_->Clear();
  clear_has_capacity();
}
inline const ::cockroach::roachpb::StoreCapacity& StoreDescriptor::_internal_capacity() const {
  return *capacity_;
}
inline const ::cockroach::roachpb::StoreCapacity& StoreDescriptor::capacity() const {
  const ::cockroach::roachpb::StoreCapacity* p = capacity_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreDescriptor.capacity)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::StoreCapacity*>(
      &::cockroach::roachpb::_StoreCapacity_default_instance_);
}
inline ::cockroach::roachpb::StoreCapacity* StoreDescriptor::release_capacity() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.StoreDescriptor.capacity)
  clear_has_capacity();
  ::cockroach::roachpb::StoreCapacity* temp = capacity_;
  capacity_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::StoreCapacity* StoreDescriptor::mutable_capacity() {
  set_has_capacity();
  if (capacity_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::StoreCapacity>(GetArenaNoVirtual());
    capacity_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.StoreDescriptor.capacity)
  return capacity_;
}
inline void StoreDescriptor::set_allocated_capacity(::cockroach::roachpb::StoreCapacity* capacity) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete capacity_;
  }
  if (capacity) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      capacity = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, capacity, submessage_arena);
    }
    set_has_capacity();
  } else {
    clear_has_capacity();
  }
  capacity_ = capacity;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.StoreDescriptor.capacity)
}

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

// StoreDeadReplicas

inline bool StoreDeadReplicas::has_store_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StoreDeadReplicas::set_has_store_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StoreDeadReplicas::clear_has_store_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StoreDeadReplicas::clear_store_id() {
  store_id_ = 0;
  clear_has_store_id();
}
inline ::google::protobuf::int32 StoreDeadReplicas::store_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreDeadReplicas.store_id)
  return store_id_;
}
inline void StoreDeadReplicas::set_store_id(::google::protobuf::int32 value) {
  set_has_store_id();
  store_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.StoreDeadReplicas.store_id)
}

inline int StoreDeadReplicas::replicas_size() const {
  return replicas_.size();
}
inline void StoreDeadReplicas::clear_replicas() {
  replicas_.Clear();
}
inline ::cockroach::roachpb::ReplicaIdent* StoreDeadReplicas::mutable_replicas(int index) {
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.StoreDeadReplicas.replicas)
  return replicas_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaIdent >*
StoreDeadReplicas::mutable_replicas() {
  // @@protoc_insertion_point(field_mutable_list:cockroach.roachpb.StoreDeadReplicas.replicas)
  return &replicas_;
}
inline const ::cockroach::roachpb::ReplicaIdent& StoreDeadReplicas::replicas(int index) const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreDeadReplicas.replicas)
  return replicas_.Get(index);
}
inline ::cockroach::roachpb::ReplicaIdent* StoreDeadReplicas::add_replicas() {
  // @@protoc_insertion_point(field_add:cockroach.roachpb.StoreDeadReplicas.replicas)
  return replicas_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaIdent >&
StoreDeadReplicas::replicas() const {
  // @@protoc_insertion_point(field_list:cockroach.roachpb.StoreDeadReplicas.replicas)
  return replicas_;
}

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

// Locality

inline int Locality::tiers_size() const {
  return tiers_.size();
}
inline void Locality::clear_tiers() {
  tiers_.Clear();
}
inline ::cockroach::roachpb::Tier* Locality::mutable_tiers(int index) {
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.Locality.tiers)
  return tiers_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::Tier >*
Locality::mutable_tiers() {
  // @@protoc_insertion_point(field_mutable_list:cockroach.roachpb.Locality.tiers)
  return &tiers_;
}
inline const ::cockroach::roachpb::Tier& Locality::tiers(int index) const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Locality.tiers)
  return tiers_.Get(index);
}
inline ::cockroach::roachpb::Tier* Locality::add_tiers() {
  // @@protoc_insertion_point(field_add:cockroach.roachpb.Locality.tiers)
  return tiers_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::Tier >&
Locality::tiers() const {
  // @@protoc_insertion_point(field_list:cockroach.roachpb.Locality.tiers)
  return tiers_;
}

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

// Tier

inline bool Tier::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Tier::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Tier::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Tier::clear_key() {
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_key();
}
inline const ::std::string& Tier::key() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Tier.key)
  return key_.GetNoArena();
}
inline void Tier::set_key(const ::std::string& value) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Tier.key)
}
#if LANG_CXX11
inline void Tier::set_key(::std::string&& value) {
  set_has_key();
  key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.Tier.key)
}
#endif
inline void Tier::set_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.Tier.key)
}
inline void Tier::set_key(const char* value, size_t size) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.Tier.key)
}
inline ::std::string* Tier::mutable_key() {
  set_has_key();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.Tier.key)
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Tier::release_key() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.Tier.key)
  if (!has_key()) {
    return NULL;
  }
  clear_has_key();
  return key_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Tier::set_allocated_key(::std::string* key) {
  if (key != NULL) {
    set_has_key();
  } else {
    clear_has_key();
  }
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.Tier.key)
}

inline bool Tier::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Tier::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Tier::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Tier::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_value();
}
inline const ::std::string& Tier::value() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Tier.value)
  return value_.GetNoArena();
}
inline void Tier::set_value(const ::std::string& value) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Tier.value)
}
#if LANG_CXX11
inline void Tier::set_value(::std::string&& value) {
  set_has_value();
  value_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.Tier.value)
}
#endif
inline void Tier::set_value(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.Tier.value)
}
inline void Tier::set_value(const char* value, size_t size) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.Tier.value)
}
inline ::std::string* Tier::mutable_value() {
  set_has_value();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.Tier.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Tier::release_value() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.Tier.value)
  if (!has_value()) {
    return NULL;
  }
  clear_has_value();
  return value_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Tier::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    set_has_value();
  } else {
    clear_has_value();
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.Tier.value)
}

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

// Version

inline bool Version::has_major_val() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Version::set_has_major_val() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Version::clear_has_major_val() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Version::clear_major_val() {
  major_val_ = 0;
  clear_has_major_val();
}
inline ::google::protobuf::int32 Version::major_val() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Version.major_val)
  return major_val_;
}
inline void Version::set_major_val(::google::protobuf::int32 value) {
  set_has_major_val();
  major_val_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Version.major_val)
}

inline bool Version::has_minor_val() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Version::set_has_minor_val() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Version::clear_has_minor_val() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Version::clear_minor_val() {
  minor_val_ = 0;
  clear_has_minor_val();
}
inline ::google::protobuf::int32 Version::minor_val() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Version.minor_val)
  return minor_val_;
}
inline void Version::set_minor_val(::google::protobuf::int32 value) {
  set_has_minor_val();
  minor_val_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Version.minor_val)
}

inline bool Version::has_patch() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Version::set_has_patch() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Version::clear_has_patch() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Version::clear_patch() {
  patch_ = 0;
  clear_has_patch();
}
inline ::google::protobuf::int32 Version::patch() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Version.patch)
  return patch_;
}
inline void Version::set_patch(::google::protobuf::int32 value) {
  set_has_patch();
  patch_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Version.patch)
}

inline bool Version::has_unstable() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Version::set_has_unstable() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Version::clear_has_unstable() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Version::clear_unstable() {
  unstable_ = 0;
  clear_has_unstable();
}
inline ::google::protobuf::int32 Version::unstable() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Version.unstable)
  return unstable_;
}
inline void Version::set_unstable(::google::protobuf::int32 value) {
  set_has_unstable();
  unstable_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Version.unstable)
}

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace roachpb
}  // namespace cockroach

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::cockroach::roachpb::ReplicaType> : ::std::true_type {};

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_roachpb_2fmetadata_2eproto