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

#ifndef PROTOBUF_cockroach_2fpkg_2froachpb_2fmetadata_2eproto__INCLUDED
#define PROTOBUF_cockroach_2fpkg_2froachpb_2fmetadata_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 3004000
#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 3004000 < 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/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 "cockroach/pkg/util/unresolved_addr.pb.h"
// @@protoc_insertion_point(includes)
namespace cockroach {
namespace roachpb {
class Attributes;
class AttributesDefaultTypeInternal;
extern AttributesDefaultTypeInternal _Attributes_default_instance_;
class Locality;
class LocalityDefaultTypeInternal;
extern LocalityDefaultTypeInternal _Locality_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 cockroach {
namespace roachpb {

namespace protobuf_cockroach_2fpkg_2froachpb_2fmetadata_2eproto {
// Internal implementation detail -- do not call these.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[];
  static const ::google::protobuf::uint32 offsets[];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static void InitDefaultsImpl();
};
void AddDescriptors();
void InitDefaults();
}  // namespace protobuf_cockroach_2fpkg_2froachpb_2fmetadata_2eproto

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

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 inline const Attributes* internal_default_instance() {
    return reinterpret_cast<const Attributes*>(
               &_Attributes_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    0;

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

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

  inline Attributes* New() const PROTOBUF_FINAL { return New(NULL); }

  Attributes* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const Attributes& from);
  void MergeFrom(const Attributes& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  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 PROTOBUF_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 int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::std::string> attrs_;
  friend struct protobuf_cockroach_2fpkg_2froachpb_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 inline const ReplicationTarget* internal_default_instance() {
    return reinterpret_cast<const ReplicationTarget*>(
               &_ReplicationTarget_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    1;

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

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

  inline ReplicationTarget* New() const PROTOBUF_FINAL { return New(NULL); }

  ReplicationTarget* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const ReplicationTarget& from);
  void MergeFrom(const ReplicationTarget& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  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 PROTOBUF_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 int _cached_size_;
  ::google::protobuf::int32 node_id_;
  ::google::protobuf::int32 store_id_;
  friend struct protobuf_cockroach_2fpkg_2froachpb_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 inline const ReplicaDescriptor* internal_default_instance() {
    return reinterpret_cast<const ReplicaDescriptor*>(
               &_ReplicaDescriptor_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    2;

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

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

  inline ReplicaDescriptor* New() const PROTOBUF_FINAL { return New(NULL); }

  ReplicaDescriptor* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const ReplicaDescriptor& from);
  void MergeFrom(const ReplicaDescriptor& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  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 PROTOBUF_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);

  // @@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();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::int32 node_id_;
  ::google::protobuf::int32 store_id_;
  ::google::protobuf::int32 replica_id_;
  friend struct protobuf_cockroach_2fpkg_2froachpb_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 inline const ReplicaIdent* internal_default_instance() {
    return reinterpret_cast<const ReplicaIdent*>(
               &_ReplicaIdent_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    3;

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

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

  inline ReplicaIdent* New() const PROTOBUF_FINAL { return New(NULL); }

  ReplicaIdent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const ReplicaIdent& from);
  void MergeFrom(const ReplicaIdent& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  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 PROTOBUF_FINAL;

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

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

  bool has_replica() const;
  void clear_replica();
  static const int kReplicaFieldNumber = 2;
  const ::cockroach::roachpb::ReplicaDescriptor& replica() const;
  ::cockroach::roachpb::ReplicaDescriptor* mutable_replica();
  ::cockroach::roachpb::ReplicaDescriptor* release_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 int _cached_size_;
  ::cockroach::roachpb::ReplicaDescriptor* replica_;
  ::google::protobuf::int64 range_id_;
  friend struct protobuf_cockroach_2fpkg_2froachpb_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 inline const RangeDescriptor* internal_default_instance() {
    return reinterpret_cast<const RangeDescriptor*>(
               &_RangeDescriptor_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    4;

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

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

  inline RangeDescriptor* New() const PROTOBUF_FINAL { return New(NULL); }

  RangeDescriptor* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const RangeDescriptor& from);
  void MergeFrom(const RangeDescriptor& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  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 PROTOBUF_FINAL;

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

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

  int replicas_size() const;
  void clear_replicas();
  static const int kReplicasFieldNumber = 4;
  const ::cockroach::roachpb::ReplicaDescriptor& replicas(int index) const;
  ::cockroach::roachpb::ReplicaDescriptor* mutable_replicas(int index);
  ::cockroach::roachpb::ReplicaDescriptor* add_replicas();
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaDescriptor >*
      mutable_replicas();
  const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaDescriptor >&
      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);

  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_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();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaDescriptor > replicas_;
  ::google::protobuf::internal::ArenaStringPtr start_key_;
  ::google::protobuf::internal::ArenaStringPtr end_key_;
  ::google::protobuf::int64 range_id_;
  ::google::protobuf::int32 next_replica_id_;
  friend struct protobuf_cockroach_2fpkg_2froachpb_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 inline const Percentiles* internal_default_instance() {
    return reinterpret_cast<const Percentiles*>(
               &_Percentiles_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    5;

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

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

  inline Percentiles* New() const PROTOBUF_FINAL { return New(NULL); }

  Percentiles* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const Percentiles& from);
  void MergeFrom(const Percentiles& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  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 PROTOBUF_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);

  // @@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();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  double p10_;
  double p25_;
  double p50_;
  double p75_;
  double p90_;
  friend struct protobuf_cockroach_2fpkg_2froachpb_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 inline const StoreCapacity* internal_default_instance() {
    return reinterpret_cast<const StoreCapacity*>(
               &_StoreCapacity_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    6;

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

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

  inline StoreCapacity* New() const PROTOBUF_FINAL { return New(NULL); }

  StoreCapacity* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const StoreCapacity& from);
  void MergeFrom(const StoreCapacity& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  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 PROTOBUF_FINAL;

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

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

  bool has_bytes_per_replica() const;
  void clear_bytes_per_replica();
  static const int kBytesPerReplicaFieldNumber = 6;
  const ::cockroach::roachpb::Percentiles& bytes_per_replica() const;
  ::cockroach::roachpb::Percentiles* mutable_bytes_per_replica();
  ::cockroach::roachpb::Percentiles* release_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;
  const ::cockroach::roachpb::Percentiles& writes_per_replica() const;
  ::cockroach::roachpb::Percentiles* mutable_writes_per_replica();
  ::cockroach::roachpb::Percentiles* release_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);

  // @@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_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 int _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_;
  friend struct protobuf_cockroach_2fpkg_2froachpb_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 inline const NodeDescriptor* internal_default_instance() {
    return reinterpret_cast<const NodeDescriptor*>(
               &_NodeDescriptor_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    7;

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

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

  inline NodeDescriptor* New() const PROTOBUF_FINAL { return New(NULL); }

  NodeDescriptor* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const NodeDescriptor& from);
  void MergeFrom(const NodeDescriptor& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  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 PROTOBUF_FINAL;

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

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

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

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

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

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

  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();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::cockroach::util::UnresolvedAddr* address_;
  ::cockroach::roachpb::Attributes* attrs_;
  ::cockroach::roachpb::Locality* locality_;
  ::cockroach::roachpb::Version* serverversion_;
  ::google::protobuf::int32 node_id_;
  friend struct protobuf_cockroach_2fpkg_2froachpb_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 inline const StoreDescriptor* internal_default_instance() {
    return reinterpret_cast<const StoreDescriptor*>(
               &_StoreDescriptor_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    8;

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

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

  inline StoreDescriptor* New() const PROTOBUF_FINAL { return New(NULL); }

  StoreDescriptor* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const StoreDescriptor& from);
  void MergeFrom(const StoreDescriptor& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  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 PROTOBUF_FINAL;

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

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

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

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

  bool has_capacity() const;
  void clear_capacity();
  static const int kCapacityFieldNumber = 4;
  const ::cockroach::roachpb::StoreCapacity& capacity() const;
  ::cockroach::roachpb::StoreCapacity* mutable_capacity();
  ::cockroach::roachpb::StoreCapacity* release_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 int _cached_size_;
  ::cockroach::roachpb::Attributes* attrs_;
  ::cockroach::roachpb::NodeDescriptor* node_;
  ::cockroach::roachpb::StoreCapacity* capacity_;
  ::google::protobuf::int32 store_id_;
  friend struct protobuf_cockroach_2fpkg_2froachpb_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 inline const StoreDeadReplicas* internal_default_instance() {
    return reinterpret_cast<const StoreDeadReplicas*>(
               &_StoreDeadReplicas_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    9;

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

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

  inline StoreDeadReplicas* New() const PROTOBUF_FINAL { return New(NULL); }

  StoreDeadReplicas* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const StoreDeadReplicas& from);
  void MergeFrom(const StoreDeadReplicas& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  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 PROTOBUF_FINAL;

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

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

  int replicas_size() const;
  void clear_replicas();
  static const int kReplicasFieldNumber = 2;
  const ::cockroach::roachpb::ReplicaIdent& replicas(int index) const;
  ::cockroach::roachpb::ReplicaIdent* mutable_replicas(int index);
  ::cockroach::roachpb::ReplicaIdent* add_replicas();
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaIdent >*
      mutable_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 int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaIdent > replicas_;
  ::google::protobuf::int32 store_id_;
  friend struct protobuf_cockroach_2fpkg_2froachpb_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 inline const Locality* internal_default_instance() {
    return reinterpret_cast<const Locality*>(
               &_Locality_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    10;

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

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

  inline Locality* New() const PROTOBUF_FINAL { return New(NULL); }

  Locality* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const Locality& from);
  void MergeFrom(const Locality& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  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 PROTOBUF_FINAL;

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

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

  int tiers_size() const;
  void clear_tiers();
  static const int kTiersFieldNumber = 1;
  const ::cockroach::roachpb::Tier& tiers(int index) const;
  ::cockroach::roachpb::Tier* mutable_tiers(int index);
  ::cockroach::roachpb::Tier* add_tiers();
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::Tier >*
      mutable_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 int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::Tier > tiers_;
  friend struct protobuf_cockroach_2fpkg_2froachpb_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 inline const Tier* internal_default_instance() {
    return reinterpret_cast<const Tier*>(
               &_Tier_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    11;

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

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

  inline Tier* New() const PROTOBUF_FINAL { return New(NULL); }

  Tier* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const Tier& from);
  void MergeFrom(const Tier& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  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 PROTOBUF_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 int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr key_;
  ::google::protobuf::internal::ArenaStringPtr value_;
  friend struct protobuf_cockroach_2fpkg_2froachpb_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 inline const Version* internal_default_instance() {
    return reinterpret_cast<const Version*>(
               &_Version_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    12;

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

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

  inline Version* New() const PROTOBUF_FINAL { return New(NULL); }

  Version* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const Version& from);
  void MergeFrom(const Version& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  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 PROTOBUF_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 int _cached_size_;
  ::google::protobuf::int32 major_val_;
  ::google::protobuf::int32 minor_val_;
  ::google::protobuf::int32 patch_;
  ::google::protobuf::int32 unstable_;
  friend struct protobuf_cockroach_2fpkg_2froachpb_2fmetadata_2eproto::TableStruct;
};
// ===================================================================


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

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
#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)
}

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

// 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_->::cockroach::roachpb::ReplicaDescriptor::Clear();
  clear_has_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::mutable_replica() {
  set_has_replica();
  if (replica_ == NULL) {
    replica_ = new ::cockroach::roachpb::ReplicaDescriptor;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ReplicaIdent.replica)
  return replica_;
}
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 void ReplicaIdent::set_allocated_replica(::cockroach::roachpb::ReplicaDescriptor* replica) {
  delete replica_;
  replica_ = replica;
  if (replica) {
    set_has_replica();
  } else {
    clear_has_replica();
  }
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.ReplicaIdent.replica)
}

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

// RangeDescriptor

inline bool RangeDescriptor::has_range_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RangeDescriptor::set_has_range_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RangeDescriptor::clear_has_range_id() {
  _has_bits_[0] &= ~0x00000004u;
}
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)
  clear_has_start_key();
  return start_key_.ReleaseNoArena(&::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)
  clear_has_end_key();
  return end_key_.ReleaseNoArena(&::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::replicas_size() const {
  return replicas_.size();
}
inline void RangeDescriptor::clear_replicas() {
  replicas_.Clear();
}
inline const ::cockroach::roachpb::ReplicaDescriptor& RangeDescriptor::replicas(int index) const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeDescriptor.replicas)
  return replicas_.Get(index);
}
inline ::cockroach::roachpb::ReplicaDescriptor* RangeDescriptor::mutable_replicas(int index) {
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.RangeDescriptor.replicas)
  return replicas_.Mutable(index);
}
inline ::cockroach::roachpb::ReplicaDescriptor* RangeDescriptor::add_replicas() {
  // @@protoc_insertion_point(field_add:cockroach.roachpb.RangeDescriptor.replicas)
  return replicas_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaDescriptor >*
RangeDescriptor::mutable_replicas() {
  // @@protoc_insertion_point(field_mutable_list:cockroach.roachpb.RangeDescriptor.replicas)
  return &replicas_;
}
inline const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaDescriptor >&
RangeDescriptor::replicas() const {
  // @@protoc_insertion_point(field_list:cockroach.roachpb.RangeDescriptor.replicas)
  return replicas_;
}

inline bool RangeDescriptor::has_next_replica_id() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void RangeDescriptor::set_has_next_replica_id() {
  _has_bits_[0] |= 0x00000008u;
}
inline void RangeDescriptor::clear_has_next_replica_id() {
  _has_bits_[0] &= ~0x00000008u;
}
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)
}

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

// 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)
}

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

// 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_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_->::cockroach::roachpb::Percentiles::Clear();
  clear_has_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::mutable_bytes_per_replica() {
  set_has_bytes_per_replica();
  if (bytes_per_replica_ == NULL) {
    bytes_per_replica_ = new ::cockroach::roachpb::Percentiles;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.StoreCapacity.bytes_per_replica)
  return bytes_per_replica_;
}
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 void StoreCapacity::set_allocated_bytes_per_replica(::cockroach::roachpb::Percentiles* bytes_per_replica) {
  delete bytes_per_replica_;
  bytes_per_replica_ = bytes_per_replica;
  if (bytes_per_replica) {
    set_has_bytes_per_replica();
  } else {
    clear_has_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_->::cockroach::roachpb::Percentiles::Clear();
  clear_has_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::mutable_writes_per_replica() {
  set_has_writes_per_replica();
  if (writes_per_replica_ == NULL) {
    writes_per_replica_ = new ::cockroach::roachpb::Percentiles;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.StoreCapacity.writes_per_replica)
  return writes_per_replica_;
}
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 void StoreCapacity::set_allocated_writes_per_replica(::cockroach::roachpb::Percentiles* writes_per_replica) {
  delete writes_per_replica_;
  writes_per_replica_ = writes_per_replica;
  if (writes_per_replica) {
    set_has_writes_per_replica();
  } else {
    clear_has_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] & 0x00000010u) != 0;
}
inline void NodeDescriptor::set_has_node_id() {
  _has_bits_[0] |= 0x00000010u;
}
inline void NodeDescriptor::clear_has_node_id() {
  _has_bits_[0] &= ~0x00000010u;
}
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] & 0x00000001u) != 0;
}
inline void NodeDescriptor::set_has_address() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NodeDescriptor::clear_has_address() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NodeDescriptor::clear_address() {
  if (address_ != NULL) address_->::cockroach::util::UnresolvedAddr::Clear();
  clear_has_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::mutable_address() {
  set_has_address();
  if (address_ == NULL) {
    address_ = new ::cockroach::util::UnresolvedAddr;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NodeDescriptor.address)
  return address_;
}
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 void NodeDescriptor::set_allocated_address(::cockroach::util::UnresolvedAddr* address) {
  delete address_;
  address_ = address;
  if (address) {
    set_has_address();
  } else {
    clear_has_address();
  }
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NodeDescriptor.address)
}

inline bool NodeDescriptor::has_attrs() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NodeDescriptor::set_has_attrs() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NodeDescriptor::clear_has_attrs() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NodeDescriptor::clear_attrs() {
  if (attrs_ != NULL) attrs_->::cockroach::roachpb::Attributes::Clear();
  clear_has_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::mutable_attrs() {
  set_has_attrs();
  if (attrs_ == NULL) {
    attrs_ = new ::cockroach::roachpb::Attributes;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NodeDescriptor.attrs)
  return attrs_;
}
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 void NodeDescriptor::set_allocated_attrs(::cockroach::roachpb::Attributes* attrs) {
  delete attrs_;
  attrs_ = attrs;
  if (attrs) {
    set_has_attrs();
  } else {
    clear_has_attrs();
  }
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NodeDescriptor.attrs)
}

inline bool NodeDescriptor::has_locality() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NodeDescriptor::set_has_locality() {
  _has_bits_[0] |= 0x00000004u;
}
inline void NodeDescriptor::clear_has_locality() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void NodeDescriptor::clear_locality() {
  if (locality_ != NULL) locality_->::cockroach::roachpb::Locality::Clear();
  clear_has_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::mutable_locality() {
  set_has_locality();
  if (locality_ == NULL) {
    locality_ = new ::cockroach::roachpb::Locality;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NodeDescriptor.locality)
  return locality_;
}
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 void NodeDescriptor::set_allocated_locality(::cockroach::roachpb::Locality* locality) {
  delete locality_;
  locality_ = locality;
  if (locality) {
    set_has_locality();
  } else {
    clear_has_locality();
  }
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NodeDescriptor.locality)
}

inline bool NodeDescriptor::has_serverversion() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void NodeDescriptor::set_has_serverversion() {
  _has_bits_[0] |= 0x00000008u;
}
inline void NodeDescriptor::clear_has_serverversion() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void NodeDescriptor::clear_serverversion() {
  if (serverversion_ != NULL) serverversion_->::cockroach::roachpb::Version::Clear();
  clear_has_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::mutable_serverversion() {
  set_has_serverversion();
  if (serverversion_ == NULL) {
    serverversion_ = new ::cockroach::roachpb::Version;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NodeDescriptor.ServerVersion)
  return serverversion_;
}
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 void NodeDescriptor::set_allocated_serverversion(::cockroach::roachpb::Version* serverversion) {
  delete serverversion_;
  serverversion_ = serverversion;
  if (serverversion) {
    set_has_serverversion();
  } else {
    clear_has_serverversion();
  }
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NodeDescriptor.ServerVersion)
}

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

// 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_->::cockroach::roachpb::Attributes::Clear();
  clear_has_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::mutable_attrs() {
  set_has_attrs();
  if (attrs_ == NULL) {
    attrs_ = new ::cockroach::roachpb::Attributes;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.StoreDescriptor.attrs)
  return attrs_;
}
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 void StoreDescriptor::set_allocated_attrs(::cockroach::roachpb::Attributes* attrs) {
  delete attrs_;
  attrs_ = attrs;
  if (attrs) {
    set_has_attrs();
  } else {
    clear_has_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_->::cockroach::roachpb::NodeDescriptor::Clear();
  clear_has_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::mutable_node() {
  set_has_node();
  if (node_ == NULL) {
    node_ = new ::cockroach::roachpb::NodeDescriptor;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.StoreDescriptor.node)
  return node_;
}
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 void StoreDescriptor::set_allocated_node(::cockroach::roachpb::NodeDescriptor* node) {
  delete node_;
  node_ = node;
  if (node) {
    set_has_node();
  } else {
    clear_has_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_->::cockroach::roachpb::StoreCapacity::Clear();
  clear_has_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::mutable_capacity() {
  set_has_capacity();
  if (capacity_ == NULL) {
    capacity_ = new ::cockroach::roachpb::StoreCapacity;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.StoreDescriptor.capacity)
  return capacity_;
}
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 void StoreDescriptor::set_allocated_capacity(::cockroach::roachpb::StoreCapacity* capacity) {
  delete capacity_;
  capacity_ = capacity;
  if (capacity) {
    set_has_capacity();
  } else {
    clear_has_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 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::mutable_replicas(int index) {
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.StoreDeadReplicas.replicas)
  return replicas_.Mutable(index);
}
inline ::cockroach::roachpb::ReplicaIdent* StoreDeadReplicas::add_replicas() {
  // @@protoc_insertion_point(field_add:cockroach.roachpb.StoreDeadReplicas.replicas)
  return replicas_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ReplicaIdent >*
StoreDeadReplicas::mutable_replicas() {
  // @@protoc_insertion_point(field_mutable_list:cockroach.roachpb.StoreDeadReplicas.replicas)
  return &replicas_;
}
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 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::mutable_tiers(int index) {
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.Locality.tiers)
  return tiers_.Mutable(index);
}
inline ::cockroach::roachpb::Tier* Locality::add_tiers() {
  // @@protoc_insertion_point(field_add:cockroach.roachpb.Locality.tiers)
  return tiers_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::Tier >*
Locality::mutable_tiers() {
  // @@protoc_insertion_point(field_mutable_list:cockroach.roachpb.Locality.tiers)
  return &tiers_;
}
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)
  clear_has_key();
  return key_.ReleaseNoArena(&::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)
  clear_has_value();
  return value_.ReleaseNoArena(&::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__
#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


}  // namespace roachpb
}  // namespace cockroach

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_cockroach_2fpkg_2froachpb_2fmetadata_2eproto__INCLUDED
