// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: google/bigtable/v2/data.proto

#ifndef PROTOBUF_INCLUDED_google_2fbigtable_2fv2_2fdata_2eproto
#define PROTOBUF_INCLUDED_google_2fbigtable_2fv2_2fdata_2eproto

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 3006001
#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 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_google_2fbigtable_2fv2_2fdata_2eproto 

namespace protobuf_google_2fbigtable_2fv2_2fdata_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[19];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_google_2fbigtable_2fv2_2fdata_2eproto
namespace google {
namespace bigtable {
namespace v2 {
class Cell;
class CellDefaultTypeInternal;
extern CellDefaultTypeInternal _Cell_default_instance_;
class Column;
class ColumnDefaultTypeInternal;
extern ColumnDefaultTypeInternal _Column_default_instance_;
class ColumnRange;
class ColumnRangeDefaultTypeInternal;
extern ColumnRangeDefaultTypeInternal _ColumnRange_default_instance_;
class Family;
class FamilyDefaultTypeInternal;
extern FamilyDefaultTypeInternal _Family_default_instance_;
class Mutation;
class MutationDefaultTypeInternal;
extern MutationDefaultTypeInternal _Mutation_default_instance_;
class Mutation_DeleteFromColumn;
class Mutation_DeleteFromColumnDefaultTypeInternal;
extern Mutation_DeleteFromColumnDefaultTypeInternal _Mutation_DeleteFromColumn_default_instance_;
class Mutation_DeleteFromFamily;
class Mutation_DeleteFromFamilyDefaultTypeInternal;
extern Mutation_DeleteFromFamilyDefaultTypeInternal _Mutation_DeleteFromFamily_default_instance_;
class Mutation_DeleteFromRow;
class Mutation_DeleteFromRowDefaultTypeInternal;
extern Mutation_DeleteFromRowDefaultTypeInternal _Mutation_DeleteFromRow_default_instance_;
class Mutation_SetCell;
class Mutation_SetCellDefaultTypeInternal;
extern Mutation_SetCellDefaultTypeInternal _Mutation_SetCell_default_instance_;
class ReadModifyWriteRule;
class ReadModifyWriteRuleDefaultTypeInternal;
extern ReadModifyWriteRuleDefaultTypeInternal _ReadModifyWriteRule_default_instance_;
class Row;
class RowDefaultTypeInternal;
extern RowDefaultTypeInternal _Row_default_instance_;
class RowFilter;
class RowFilterDefaultTypeInternal;
extern RowFilterDefaultTypeInternal _RowFilter_default_instance_;
class RowFilter_Chain;
class RowFilter_ChainDefaultTypeInternal;
extern RowFilter_ChainDefaultTypeInternal _RowFilter_Chain_default_instance_;
class RowFilter_Condition;
class RowFilter_ConditionDefaultTypeInternal;
extern RowFilter_ConditionDefaultTypeInternal _RowFilter_Condition_default_instance_;
class RowFilter_Interleave;
class RowFilter_InterleaveDefaultTypeInternal;
extern RowFilter_InterleaveDefaultTypeInternal _RowFilter_Interleave_default_instance_;
class RowRange;
class RowRangeDefaultTypeInternal;
extern RowRangeDefaultTypeInternal _RowRange_default_instance_;
class RowSet;
class RowSetDefaultTypeInternal;
extern RowSetDefaultTypeInternal _RowSet_default_instance_;
class TimestampRange;
class TimestampRangeDefaultTypeInternal;
extern TimestampRangeDefaultTypeInternal _TimestampRange_default_instance_;
class ValueRange;
class ValueRangeDefaultTypeInternal;
extern ValueRangeDefaultTypeInternal _ValueRange_default_instance_;
}  // namespace v2
}  // namespace bigtable
}  // namespace google
namespace google {
namespace protobuf {
template<> ::google::bigtable::v2::Cell* Arena::CreateMaybeMessage<::google::bigtable::v2::Cell>(Arena*);
template<> ::google::bigtable::v2::Column* Arena::CreateMaybeMessage<::google::bigtable::v2::Column>(Arena*);
template<> ::google::bigtable::v2::ColumnRange* Arena::CreateMaybeMessage<::google::bigtable::v2::ColumnRange>(Arena*);
template<> ::google::bigtable::v2::Family* Arena::CreateMaybeMessage<::google::bigtable::v2::Family>(Arena*);
template<> ::google::bigtable::v2::Mutation* Arena::CreateMaybeMessage<::google::bigtable::v2::Mutation>(Arena*);
template<> ::google::bigtable::v2::Mutation_DeleteFromColumn* Arena::CreateMaybeMessage<::google::bigtable::v2::Mutation_DeleteFromColumn>(Arena*);
template<> ::google::bigtable::v2::Mutation_DeleteFromFamily* Arena::CreateMaybeMessage<::google::bigtable::v2::Mutation_DeleteFromFamily>(Arena*);
template<> ::google::bigtable::v2::Mutation_DeleteFromRow* Arena::CreateMaybeMessage<::google::bigtable::v2::Mutation_DeleteFromRow>(Arena*);
template<> ::google::bigtable::v2::Mutation_SetCell* Arena::CreateMaybeMessage<::google::bigtable::v2::Mutation_SetCell>(Arena*);
template<> ::google::bigtable::v2::ReadModifyWriteRule* Arena::CreateMaybeMessage<::google::bigtable::v2::ReadModifyWriteRule>(Arena*);
template<> ::google::bigtable::v2::Row* Arena::CreateMaybeMessage<::google::bigtable::v2::Row>(Arena*);
template<> ::google::bigtable::v2::RowFilter* Arena::CreateMaybeMessage<::google::bigtable::v2::RowFilter>(Arena*);
template<> ::google::bigtable::v2::RowFilter_Chain* Arena::CreateMaybeMessage<::google::bigtable::v2::RowFilter_Chain>(Arena*);
template<> ::google::bigtable::v2::RowFilter_Condition* Arena::CreateMaybeMessage<::google::bigtable::v2::RowFilter_Condition>(Arena*);
template<> ::google::bigtable::v2::RowFilter_Interleave* Arena::CreateMaybeMessage<::google::bigtable::v2::RowFilter_Interleave>(Arena*);
template<> ::google::bigtable::v2::RowRange* Arena::CreateMaybeMessage<::google::bigtable::v2::RowRange>(Arena*);
template<> ::google::bigtable::v2::RowSet* Arena::CreateMaybeMessage<::google::bigtable::v2::RowSet>(Arena*);
template<> ::google::bigtable::v2::TimestampRange* Arena::CreateMaybeMessage<::google::bigtable::v2::TimestampRange>(Arena*);
template<> ::google::bigtable::v2::ValueRange* Arena::CreateMaybeMessage<::google::bigtable::v2::ValueRange>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace google {
namespace bigtable {
namespace v2 {

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

class Row : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.Row) */ {
 public:
  Row();
  virtual ~Row();

  Row(const Row& from);

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

  inline Row& operator=(Row&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Row& default_instance();

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated .google.bigtable.v2.Family families = 2;
  int families_size() const;
  void clear_families();
  static const int kFamiliesFieldNumber = 2;
  ::google::bigtable::v2::Family* mutable_families(int index);
  ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Family >*
      mutable_families();
  const ::google::bigtable::v2::Family& families(int index) const;
  ::google::bigtable::v2::Family* add_families();
  const ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Family >&
      families() const;

  // bytes key = 1;
  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 void* value, size_t size);
  ::std::string* mutable_key();
  ::std::string* release_key();
  void set_allocated_key(::std::string* key);

  // @@protoc_insertion_point(class_scope:google.bigtable.v2.Row)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Family > families_;
  ::google::protobuf::internal::ArenaStringPtr key_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Family : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.Family) */ {
 public:
  Family();
  virtual ~Family();

  Family(const Family& from);

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

  inline Family& operator=(Family&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Family& default_instance();

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated .google.bigtable.v2.Column columns = 2;
  int columns_size() const;
  void clear_columns();
  static const int kColumnsFieldNumber = 2;
  ::google::bigtable::v2::Column* mutable_columns(int index);
  ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Column >*
      mutable_columns();
  const ::google::bigtable::v2::Column& columns(int index) const;
  ::google::bigtable::v2::Column* add_columns();
  const ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Column >&
      columns() const;

  // string name = 1;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // @@protoc_insertion_point(class_scope:google.bigtable.v2.Family)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Column > columns_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Column : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.Column) */ {
 public:
  Column();
  virtual ~Column();

  Column(const Column& from);

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

  inline Column& operator=(Column&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Column& default_instance();

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated .google.bigtable.v2.Cell cells = 2;
  int cells_size() const;
  void clear_cells();
  static const int kCellsFieldNumber = 2;
  ::google::bigtable::v2::Cell* mutable_cells(int index);
  ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Cell >*
      mutable_cells();
  const ::google::bigtable::v2::Cell& cells(int index) const;
  ::google::bigtable::v2::Cell* add_cells();
  const ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Cell >&
      cells() const;

  // bytes qualifier = 1;
  void clear_qualifier();
  static const int kQualifierFieldNumber = 1;
  const ::std::string& qualifier() const;
  void set_qualifier(const ::std::string& value);
  #if LANG_CXX11
  void set_qualifier(::std::string&& value);
  #endif
  void set_qualifier(const char* value);
  void set_qualifier(const void* value, size_t size);
  ::std::string* mutable_qualifier();
  ::std::string* release_qualifier();
  void set_allocated_qualifier(::std::string* qualifier);

  // @@protoc_insertion_point(class_scope:google.bigtable.v2.Column)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Cell > cells_;
  ::google::protobuf::internal::ArenaStringPtr qualifier_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Cell : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.Cell) */ {
 public:
  Cell();
  virtual ~Cell();

  Cell(const Cell& from);

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

  inline Cell& operator=(Cell&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Cell& default_instance();

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated string labels = 3;
  int labels_size() const;
  void clear_labels();
  static const int kLabelsFieldNumber = 3;
  const ::std::string& labels(int index) const;
  ::std::string* mutable_labels(int index);
  void set_labels(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_labels(int index, ::std::string&& value);
  #endif
  void set_labels(int index, const char* value);
  void set_labels(int index, const char* value, size_t size);
  ::std::string* add_labels();
  void add_labels(const ::std::string& value);
  #if LANG_CXX11
  void add_labels(::std::string&& value);
  #endif
  void add_labels(const char* value);
  void add_labels(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& labels() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_labels();

  // bytes value = 2;
  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 void* value, size_t size);
  ::std::string* mutable_value();
  ::std::string* release_value();
  void set_allocated_value(::std::string* value);

  // int64 timestamp_micros = 1;
  void clear_timestamp_micros();
  static const int kTimestampMicrosFieldNumber = 1;
  ::google::protobuf::int64 timestamp_micros() const;
  void set_timestamp_micros(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:google.bigtable.v2.Cell)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::std::string> labels_;
  ::google::protobuf::internal::ArenaStringPtr value_;
  ::google::protobuf::int64 timestamp_micros_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RowRange : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.RowRange) */ {
 public:
  RowRange();
  virtual ~RowRange();

  RowRange(const RowRange& from);

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

  inline RowRange& operator=(RowRange&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RowRange& default_instance();

  enum StartKeyCase {
    kStartKeyClosed = 1,
    kStartKeyOpen = 2,
    START_KEY_NOT_SET = 0,
  };

  enum EndKeyCase {
    kEndKeyOpen = 3,
    kEndKeyClosed = 4,
    END_KEY_NOT_SET = 0,
  };

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // bytes start_key_closed = 1;
  private:
  bool has_start_key_closed() const;
  public:
  void clear_start_key_closed();
  static const int kStartKeyClosedFieldNumber = 1;
  const ::std::string& start_key_closed() const;
  void set_start_key_closed(const ::std::string& value);
  #if LANG_CXX11
  void set_start_key_closed(::std::string&& value);
  #endif
  void set_start_key_closed(const char* value);
  void set_start_key_closed(const void* value, size_t size);
  ::std::string* mutable_start_key_closed();
  ::std::string* release_start_key_closed();
  void set_allocated_start_key_closed(::std::string* start_key_closed);

  // bytes start_key_open = 2;
  private:
  bool has_start_key_open() const;
  public:
  void clear_start_key_open();
  static const int kStartKeyOpenFieldNumber = 2;
  const ::std::string& start_key_open() const;
  void set_start_key_open(const ::std::string& value);
  #if LANG_CXX11
  void set_start_key_open(::std::string&& value);
  #endif
  void set_start_key_open(const char* value);
  void set_start_key_open(const void* value, size_t size);
  ::std::string* mutable_start_key_open();
  ::std::string* release_start_key_open();
  void set_allocated_start_key_open(::std::string* start_key_open);

  // bytes end_key_open = 3;
  private:
  bool has_end_key_open() const;
  public:
  void clear_end_key_open();
  static const int kEndKeyOpenFieldNumber = 3;
  const ::std::string& end_key_open() const;
  void set_end_key_open(const ::std::string& value);
  #if LANG_CXX11
  void set_end_key_open(::std::string&& value);
  #endif
  void set_end_key_open(const char* value);
  void set_end_key_open(const void* value, size_t size);
  ::std::string* mutable_end_key_open();
  ::std::string* release_end_key_open();
  void set_allocated_end_key_open(::std::string* end_key_open);

  // bytes end_key_closed = 4;
  private:
  bool has_end_key_closed() const;
  public:
  void clear_end_key_closed();
  static const int kEndKeyClosedFieldNumber = 4;
  const ::std::string& end_key_closed() const;
  void set_end_key_closed(const ::std::string& value);
  #if LANG_CXX11
  void set_end_key_closed(::std::string&& value);
  #endif
  void set_end_key_closed(const char* value);
  void set_end_key_closed(const void* value, size_t size);
  ::std::string* mutable_end_key_closed();
  ::std::string* release_end_key_closed();
  void set_allocated_end_key_closed(::std::string* end_key_closed);

  void clear_start_key();
  StartKeyCase start_key_case() const;
  void clear_end_key();
  EndKeyCase end_key_case() const;
  // @@protoc_insertion_point(class_scope:google.bigtable.v2.RowRange)
 private:
  void set_has_start_key_closed();
  void set_has_start_key_open();
  void set_has_end_key_open();
  void set_has_end_key_closed();

  inline bool has_start_key() const;
  inline void clear_has_start_key();

  inline bool has_end_key() const;
  inline void clear_has_end_key();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  union StartKeyUnion {
    StartKeyUnion() {}
    ::google::protobuf::internal::ArenaStringPtr start_key_closed_;
    ::google::protobuf::internal::ArenaStringPtr start_key_open_;
  } start_key_;
  union EndKeyUnion {
    EndKeyUnion() {}
    ::google::protobuf::internal::ArenaStringPtr end_key_open_;
    ::google::protobuf::internal::ArenaStringPtr end_key_closed_;
  } end_key_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[2];

  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RowSet : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.RowSet) */ {
 public:
  RowSet();
  virtual ~RowSet();

  RowSet(const RowSet& from);

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

  inline RowSet& operator=(RowSet&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RowSet& default_instance();

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated bytes row_keys = 1;
  int row_keys_size() const;
  void clear_row_keys();
  static const int kRowKeysFieldNumber = 1;
  const ::std::string& row_keys(int index) const;
  ::std::string* mutable_row_keys(int index);
  void set_row_keys(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_row_keys(int index, ::std::string&& value);
  #endif
  void set_row_keys(int index, const char* value);
  void set_row_keys(int index, const void* value, size_t size);
  ::std::string* add_row_keys();
  void add_row_keys(const ::std::string& value);
  #if LANG_CXX11
  void add_row_keys(::std::string&& value);
  #endif
  void add_row_keys(const char* value);
  void add_row_keys(const void* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& row_keys() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_row_keys();

  // repeated .google.bigtable.v2.RowRange row_ranges = 2;
  int row_ranges_size() const;
  void clear_row_ranges();
  static const int kRowRangesFieldNumber = 2;
  ::google::bigtable::v2::RowRange* mutable_row_ranges(int index);
  ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowRange >*
      mutable_row_ranges();
  const ::google::bigtable::v2::RowRange& row_ranges(int index) const;
  ::google::bigtable::v2::RowRange* add_row_ranges();
  const ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowRange >&
      row_ranges() const;

  // @@protoc_insertion_point(class_scope:google.bigtable.v2.RowSet)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::std::string> row_keys_;
  ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowRange > row_ranges_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ColumnRange : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.ColumnRange) */ {
 public:
  ColumnRange();
  virtual ~ColumnRange();

  ColumnRange(const ColumnRange& from);

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

  inline ColumnRange& operator=(ColumnRange&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ColumnRange& default_instance();

  enum StartQualifierCase {
    kStartQualifierClosed = 2,
    kStartQualifierOpen = 3,
    START_QUALIFIER_NOT_SET = 0,
  };

  enum EndQualifierCase {
    kEndQualifierClosed = 4,
    kEndQualifierOpen = 5,
    END_QUALIFIER_NOT_SET = 0,
  };

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // string family_name = 1;
  void clear_family_name();
  static const int kFamilyNameFieldNumber = 1;
  const ::std::string& family_name() const;
  void set_family_name(const ::std::string& value);
  #if LANG_CXX11
  void set_family_name(::std::string&& value);
  #endif
  void set_family_name(const char* value);
  void set_family_name(const char* value, size_t size);
  ::std::string* mutable_family_name();
  ::std::string* release_family_name();
  void set_allocated_family_name(::std::string* family_name);

  // bytes start_qualifier_closed = 2;
  private:
  bool has_start_qualifier_closed() const;
  public:
  void clear_start_qualifier_closed();
  static const int kStartQualifierClosedFieldNumber = 2;
  const ::std::string& start_qualifier_closed() const;
  void set_start_qualifier_closed(const ::std::string& value);
  #if LANG_CXX11
  void set_start_qualifier_closed(::std::string&& value);
  #endif
  void set_start_qualifier_closed(const char* value);
  void set_start_qualifier_closed(const void* value, size_t size);
  ::std::string* mutable_start_qualifier_closed();
  ::std::string* release_start_qualifier_closed();
  void set_allocated_start_qualifier_closed(::std::string* start_qualifier_closed);

  // bytes start_qualifier_open = 3;
  private:
  bool has_start_qualifier_open() const;
  public:
  void clear_start_qualifier_open();
  static const int kStartQualifierOpenFieldNumber = 3;
  const ::std::string& start_qualifier_open() const;
  void set_start_qualifier_open(const ::std::string& value);
  #if LANG_CXX11
  void set_start_qualifier_open(::std::string&& value);
  #endif
  void set_start_qualifier_open(const char* value);
  void set_start_qualifier_open(const void* value, size_t size);
  ::std::string* mutable_start_qualifier_open();
  ::std::string* release_start_qualifier_open();
  void set_allocated_start_qualifier_open(::std::string* start_qualifier_open);

  // bytes end_qualifier_closed = 4;
  private:
  bool has_end_qualifier_closed() const;
  public:
  void clear_end_qualifier_closed();
  static const int kEndQualifierClosedFieldNumber = 4;
  const ::std::string& end_qualifier_closed() const;
  void set_end_qualifier_closed(const ::std::string& value);
  #if LANG_CXX11
  void set_end_qualifier_closed(::std::string&& value);
  #endif
  void set_end_qualifier_closed(const char* value);
  void set_end_qualifier_closed(const void* value, size_t size);
  ::std::string* mutable_end_qualifier_closed();
  ::std::string* release_end_qualifier_closed();
  void set_allocated_end_qualifier_closed(::std::string* end_qualifier_closed);

  // bytes end_qualifier_open = 5;
  private:
  bool has_end_qualifier_open() const;
  public:
  void clear_end_qualifier_open();
  static const int kEndQualifierOpenFieldNumber = 5;
  const ::std::string& end_qualifier_open() const;
  void set_end_qualifier_open(const ::std::string& value);
  #if LANG_CXX11
  void set_end_qualifier_open(::std::string&& value);
  #endif
  void set_end_qualifier_open(const char* value);
  void set_end_qualifier_open(const void* value, size_t size);
  ::std::string* mutable_end_qualifier_open();
  ::std::string* release_end_qualifier_open();
  void set_allocated_end_qualifier_open(::std::string* end_qualifier_open);

  void clear_start_qualifier();
  StartQualifierCase start_qualifier_case() const;
  void clear_end_qualifier();
  EndQualifierCase end_qualifier_case() const;
  // @@protoc_insertion_point(class_scope:google.bigtable.v2.ColumnRange)
 private:
  void set_has_start_qualifier_closed();
  void set_has_start_qualifier_open();
  void set_has_end_qualifier_closed();
  void set_has_end_qualifier_open();

  inline bool has_start_qualifier() const;
  inline void clear_has_start_qualifier();

  inline bool has_end_qualifier() const;
  inline void clear_has_end_qualifier();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr family_name_;
  union StartQualifierUnion {
    StartQualifierUnion() {}
    ::google::protobuf::internal::ArenaStringPtr start_qualifier_closed_;
    ::google::protobuf::internal::ArenaStringPtr start_qualifier_open_;
  } start_qualifier_;
  union EndQualifierUnion {
    EndQualifierUnion() {}
    ::google::protobuf::internal::ArenaStringPtr end_qualifier_closed_;
    ::google::protobuf::internal::ArenaStringPtr end_qualifier_open_;
  } end_qualifier_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[2];

  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TimestampRange : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.TimestampRange) */ {
 public:
  TimestampRange();
  virtual ~TimestampRange();

  TimestampRange(const TimestampRange& from);

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

  inline TimestampRange& operator=(TimestampRange&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const TimestampRange& default_instance();

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // int64 start_timestamp_micros = 1;
  void clear_start_timestamp_micros();
  static const int kStartTimestampMicrosFieldNumber = 1;
  ::google::protobuf::int64 start_timestamp_micros() const;
  void set_start_timestamp_micros(::google::protobuf::int64 value);

  // int64 end_timestamp_micros = 2;
  void clear_end_timestamp_micros();
  static const int kEndTimestampMicrosFieldNumber = 2;
  ::google::protobuf::int64 end_timestamp_micros() const;
  void set_end_timestamp_micros(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:google.bigtable.v2.TimestampRange)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 start_timestamp_micros_;
  ::google::protobuf::int64 end_timestamp_micros_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ValueRange : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.ValueRange) */ {
 public:
  ValueRange();
  virtual ~ValueRange();

  ValueRange(const ValueRange& from);

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

  inline ValueRange& operator=(ValueRange&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ValueRange& default_instance();

  enum StartValueCase {
    kStartValueClosed = 1,
    kStartValueOpen = 2,
    START_VALUE_NOT_SET = 0,
  };

  enum EndValueCase {
    kEndValueClosed = 3,
    kEndValueOpen = 4,
    END_VALUE_NOT_SET = 0,
  };

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // bytes start_value_closed = 1;
  private:
  bool has_start_value_closed() const;
  public:
  void clear_start_value_closed();
  static const int kStartValueClosedFieldNumber = 1;
  const ::std::string& start_value_closed() const;
  void set_start_value_closed(const ::std::string& value);
  #if LANG_CXX11
  void set_start_value_closed(::std::string&& value);
  #endif
  void set_start_value_closed(const char* value);
  void set_start_value_closed(const void* value, size_t size);
  ::std::string* mutable_start_value_closed();
  ::std::string* release_start_value_closed();
  void set_allocated_start_value_closed(::std::string* start_value_closed);

  // bytes start_value_open = 2;
  private:
  bool has_start_value_open() const;
  public:
  void clear_start_value_open();
  static const int kStartValueOpenFieldNumber = 2;
  const ::std::string& start_value_open() const;
  void set_start_value_open(const ::std::string& value);
  #if LANG_CXX11
  void set_start_value_open(::std::string&& value);
  #endif
  void set_start_value_open(const char* value);
  void set_start_value_open(const void* value, size_t size);
  ::std::string* mutable_start_value_open();
  ::std::string* release_start_value_open();
  void set_allocated_start_value_open(::std::string* start_value_open);

  // bytes end_value_closed = 3;
  private:
  bool has_end_value_closed() const;
  public:
  void clear_end_value_closed();
  static const int kEndValueClosedFieldNumber = 3;
  const ::std::string& end_value_closed() const;
  void set_end_value_closed(const ::std::string& value);
  #if LANG_CXX11
  void set_end_value_closed(::std::string&& value);
  #endif
  void set_end_value_closed(const char* value);
  void set_end_value_closed(const void* value, size_t size);
  ::std::string* mutable_end_value_closed();
  ::std::string* release_end_value_closed();
  void set_allocated_end_value_closed(::std::string* end_value_closed);

  // bytes end_value_open = 4;
  private:
  bool has_end_value_open() const;
  public:
  void clear_end_value_open();
  static const int kEndValueOpenFieldNumber = 4;
  const ::std::string& end_value_open() const;
  void set_end_value_open(const ::std::string& value);
  #if LANG_CXX11
  void set_end_value_open(::std::string&& value);
  #endif
  void set_end_value_open(const char* value);
  void set_end_value_open(const void* value, size_t size);
  ::std::string* mutable_end_value_open();
  ::std::string* release_end_value_open();
  void set_allocated_end_value_open(::std::string* end_value_open);

  void clear_start_value();
  StartValueCase start_value_case() const;
  void clear_end_value();
  EndValueCase end_value_case() const;
  // @@protoc_insertion_point(class_scope:google.bigtable.v2.ValueRange)
 private:
  void set_has_start_value_closed();
  void set_has_start_value_open();
  void set_has_end_value_closed();
  void set_has_end_value_open();

  inline bool has_start_value() const;
  inline void clear_has_start_value();

  inline bool has_end_value() const;
  inline void clear_has_end_value();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  union StartValueUnion {
    StartValueUnion() {}
    ::google::protobuf::internal::ArenaStringPtr start_value_closed_;
    ::google::protobuf::internal::ArenaStringPtr start_value_open_;
  } start_value_;
  union EndValueUnion {
    EndValueUnion() {}
    ::google::protobuf::internal::ArenaStringPtr end_value_closed_;
    ::google::protobuf::internal::ArenaStringPtr end_value_open_;
  } end_value_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[2];

  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RowFilter_Chain : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.RowFilter.Chain) */ {
 public:
  RowFilter_Chain();
  virtual ~RowFilter_Chain();

  RowFilter_Chain(const RowFilter_Chain& from);

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

  inline RowFilter_Chain& operator=(RowFilter_Chain&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RowFilter_Chain& default_instance();

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated .google.bigtable.v2.RowFilter filters = 1;
  int filters_size() const;
  void clear_filters();
  static const int kFiltersFieldNumber = 1;
  ::google::bigtable::v2::RowFilter* mutable_filters(int index);
  ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowFilter >*
      mutable_filters();
  const ::google::bigtable::v2::RowFilter& filters(int index) const;
  ::google::bigtable::v2::RowFilter* add_filters();
  const ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowFilter >&
      filters() const;

  // @@protoc_insertion_point(class_scope:google.bigtable.v2.RowFilter.Chain)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowFilter > filters_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RowFilter_Interleave : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.RowFilter.Interleave) */ {
 public:
  RowFilter_Interleave();
  virtual ~RowFilter_Interleave();

  RowFilter_Interleave(const RowFilter_Interleave& from);

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

  inline RowFilter_Interleave& operator=(RowFilter_Interleave&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RowFilter_Interleave& default_instance();

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated .google.bigtable.v2.RowFilter filters = 1;
  int filters_size() const;
  void clear_filters();
  static const int kFiltersFieldNumber = 1;
  ::google::bigtable::v2::RowFilter* mutable_filters(int index);
  ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowFilter >*
      mutable_filters();
  const ::google::bigtable::v2::RowFilter& filters(int index) const;
  ::google::bigtable::v2::RowFilter* add_filters();
  const ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowFilter >&
      filters() const;

  // @@protoc_insertion_point(class_scope:google.bigtable.v2.RowFilter.Interleave)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowFilter > filters_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RowFilter_Condition : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.RowFilter.Condition) */ {
 public:
  RowFilter_Condition();
  virtual ~RowFilter_Condition();

  RowFilter_Condition(const RowFilter_Condition& from);

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

  inline RowFilter_Condition& operator=(RowFilter_Condition&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RowFilter_Condition& default_instance();

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // .google.bigtable.v2.RowFilter predicate_filter = 1;
  bool has_predicate_filter() const;
  void clear_predicate_filter();
  static const int kPredicateFilterFieldNumber = 1;
  private:
  const ::google::bigtable::v2::RowFilter& _internal_predicate_filter() const;
  public:
  const ::google::bigtable::v2::RowFilter& predicate_filter() const;
  ::google::bigtable::v2::RowFilter* release_predicate_filter();
  ::google::bigtable::v2::RowFilter* mutable_predicate_filter();
  void set_allocated_predicate_filter(::google::bigtable::v2::RowFilter* predicate_filter);

  // .google.bigtable.v2.RowFilter true_filter = 2;
  bool has_true_filter() const;
  void clear_true_filter();
  static const int kTrueFilterFieldNumber = 2;
  private:
  const ::google::bigtable::v2::RowFilter& _internal_true_filter() const;
  public:
  const ::google::bigtable::v2::RowFilter& true_filter() const;
  ::google::bigtable::v2::RowFilter* release_true_filter();
  ::google::bigtable::v2::RowFilter* mutable_true_filter();
  void set_allocated_true_filter(::google::bigtable::v2::RowFilter* true_filter);

  // .google.bigtable.v2.RowFilter false_filter = 3;
  bool has_false_filter() const;
  void clear_false_filter();
  static const int kFalseFilterFieldNumber = 3;
  private:
  const ::google::bigtable::v2::RowFilter& _internal_false_filter() const;
  public:
  const ::google::bigtable::v2::RowFilter& false_filter() const;
  ::google::bigtable::v2::RowFilter* release_false_filter();
  ::google::bigtable::v2::RowFilter* mutable_false_filter();
  void set_allocated_false_filter(::google::bigtable::v2::RowFilter* false_filter);

  // @@protoc_insertion_point(class_scope:google.bigtable.v2.RowFilter.Condition)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::bigtable::v2::RowFilter* predicate_filter_;
  ::google::bigtable::v2::RowFilter* true_filter_;
  ::google::bigtable::v2::RowFilter* false_filter_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RowFilter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.RowFilter) */ {
 public:
  RowFilter();
  virtual ~RowFilter();

  RowFilter(const RowFilter& from);

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

  inline RowFilter& operator=(RowFilter&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RowFilter& default_instance();

  enum FilterCase {
    kChain = 1,
    kInterleave = 2,
    kCondition = 3,
    kSink = 16,
    kPassAllFilter = 17,
    kBlockAllFilter = 18,
    kRowKeyRegexFilter = 4,
    kRowSampleFilter = 14,
    kFamilyNameRegexFilter = 5,
    kColumnQualifierRegexFilter = 6,
    kColumnRangeFilter = 7,
    kTimestampRangeFilter = 8,
    kValueRegexFilter = 9,
    kValueRangeFilter = 15,
    kCellsPerRowOffsetFilter = 10,
    kCellsPerRowLimitFilter = 11,
    kCellsPerColumnLimitFilter = 12,
    kStripValueTransformer = 13,
    kApplyLabelTransformer = 19,
    FILTER_NOT_SET = 0,
  };

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

  typedef RowFilter_Chain Chain;
  typedef RowFilter_Interleave Interleave;
  typedef RowFilter_Condition Condition;

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

  // .google.bigtable.v2.RowFilter.Chain chain = 1;
  bool has_chain() const;
  void clear_chain();
  static const int kChainFieldNumber = 1;
  private:
  const ::google::bigtable::v2::RowFilter_Chain& _internal_chain() const;
  public:
  const ::google::bigtable::v2::RowFilter_Chain& chain() const;
  ::google::bigtable::v2::RowFilter_Chain* release_chain();
  ::google::bigtable::v2::RowFilter_Chain* mutable_chain();
  void set_allocated_chain(::google::bigtable::v2::RowFilter_Chain* chain);

  // .google.bigtable.v2.RowFilter.Interleave interleave = 2;
  bool has_interleave() const;
  void clear_interleave();
  static const int kInterleaveFieldNumber = 2;
  private:
  const ::google::bigtable::v2::RowFilter_Interleave& _internal_interleave() const;
  public:
  const ::google::bigtable::v2::RowFilter_Interleave& interleave() const;
  ::google::bigtable::v2::RowFilter_Interleave* release_interleave();
  ::google::bigtable::v2::RowFilter_Interleave* mutable_interleave();
  void set_allocated_interleave(::google::bigtable::v2::RowFilter_Interleave* interleave);

  // .google.bigtable.v2.RowFilter.Condition condition = 3;
  bool has_condition() const;
  void clear_condition();
  static const int kConditionFieldNumber = 3;
  private:
  const ::google::bigtable::v2::RowFilter_Condition& _internal_condition() const;
  public:
  const ::google::bigtable::v2::RowFilter_Condition& condition() const;
  ::google::bigtable::v2::RowFilter_Condition* release_condition();
  ::google::bigtable::v2::RowFilter_Condition* mutable_condition();
  void set_allocated_condition(::google::bigtable::v2::RowFilter_Condition* condition);

  // bool sink = 16;
  private:
  bool has_sink() const;
  public:
  void clear_sink();
  static const int kSinkFieldNumber = 16;
  bool sink() const;
  void set_sink(bool value);

  // bool pass_all_filter = 17;
  private:
  bool has_pass_all_filter() const;
  public:
  void clear_pass_all_filter();
  static const int kPassAllFilterFieldNumber = 17;
  bool pass_all_filter() const;
  void set_pass_all_filter(bool value);

  // bool block_all_filter = 18;
  private:
  bool has_block_all_filter() const;
  public:
  void clear_block_all_filter();
  static const int kBlockAllFilterFieldNumber = 18;
  bool block_all_filter() const;
  void set_block_all_filter(bool value);

  // bytes row_key_regex_filter = 4;
  private:
  bool has_row_key_regex_filter() const;
  public:
  void clear_row_key_regex_filter();
  static const int kRowKeyRegexFilterFieldNumber = 4;
  const ::std::string& row_key_regex_filter() const;
  void set_row_key_regex_filter(const ::std::string& value);
  #if LANG_CXX11
  void set_row_key_regex_filter(::std::string&& value);
  #endif
  void set_row_key_regex_filter(const char* value);
  void set_row_key_regex_filter(const void* value, size_t size);
  ::std::string* mutable_row_key_regex_filter();
  ::std::string* release_row_key_regex_filter();
  void set_allocated_row_key_regex_filter(::std::string* row_key_regex_filter);

  // double row_sample_filter = 14;
  private:
  bool has_row_sample_filter() const;
  public:
  void clear_row_sample_filter();
  static const int kRowSampleFilterFieldNumber = 14;
  double row_sample_filter() const;
  void set_row_sample_filter(double value);

  // string family_name_regex_filter = 5;
  private:
  bool has_family_name_regex_filter() const;
  public:
  void clear_family_name_regex_filter();
  static const int kFamilyNameRegexFilterFieldNumber = 5;
  const ::std::string& family_name_regex_filter() const;
  void set_family_name_regex_filter(const ::std::string& value);
  #if LANG_CXX11
  void set_family_name_regex_filter(::std::string&& value);
  #endif
  void set_family_name_regex_filter(const char* value);
  void set_family_name_regex_filter(const char* value, size_t size);
  ::std::string* mutable_family_name_regex_filter();
  ::std::string* release_family_name_regex_filter();
  void set_allocated_family_name_regex_filter(::std::string* family_name_regex_filter);

  // bytes column_qualifier_regex_filter = 6;
  private:
  bool has_column_qualifier_regex_filter() const;
  public:
  void clear_column_qualifier_regex_filter();
  static const int kColumnQualifierRegexFilterFieldNumber = 6;
  const ::std::string& column_qualifier_regex_filter() const;
  void set_column_qualifier_regex_filter(const ::std::string& value);
  #if LANG_CXX11
  void set_column_qualifier_regex_filter(::std::string&& value);
  #endif
  void set_column_qualifier_regex_filter(const char* value);
  void set_column_qualifier_regex_filter(const void* value, size_t size);
  ::std::string* mutable_column_qualifier_regex_filter();
  ::std::string* release_column_qualifier_regex_filter();
  void set_allocated_column_qualifier_regex_filter(::std::string* column_qualifier_regex_filter);

  // .google.bigtable.v2.ColumnRange column_range_filter = 7;
  bool has_column_range_filter() const;
  void clear_column_range_filter();
  static const int kColumnRangeFilterFieldNumber = 7;
  private:
  const ::google::bigtable::v2::ColumnRange& _internal_column_range_filter() const;
  public:
  const ::google::bigtable::v2::ColumnRange& column_range_filter() const;
  ::google::bigtable::v2::ColumnRange* release_column_range_filter();
  ::google::bigtable::v2::ColumnRange* mutable_column_range_filter();
  void set_allocated_column_range_filter(::google::bigtable::v2::ColumnRange* column_range_filter);

  // .google.bigtable.v2.TimestampRange timestamp_range_filter = 8;
  bool has_timestamp_range_filter() const;
  void clear_timestamp_range_filter();
  static const int kTimestampRangeFilterFieldNumber = 8;
  private:
  const ::google::bigtable::v2::TimestampRange& _internal_timestamp_range_filter() const;
  public:
  const ::google::bigtable::v2::TimestampRange& timestamp_range_filter() const;
  ::google::bigtable::v2::TimestampRange* release_timestamp_range_filter();
  ::google::bigtable::v2::TimestampRange* mutable_timestamp_range_filter();
  void set_allocated_timestamp_range_filter(::google::bigtable::v2::TimestampRange* timestamp_range_filter);

  // bytes value_regex_filter = 9;
  private:
  bool has_value_regex_filter() const;
  public:
  void clear_value_regex_filter();
  static const int kValueRegexFilterFieldNumber = 9;
  const ::std::string& value_regex_filter() const;
  void set_value_regex_filter(const ::std::string& value);
  #if LANG_CXX11
  void set_value_regex_filter(::std::string&& value);
  #endif
  void set_value_regex_filter(const char* value);
  void set_value_regex_filter(const void* value, size_t size);
  ::std::string* mutable_value_regex_filter();
  ::std::string* release_value_regex_filter();
  void set_allocated_value_regex_filter(::std::string* value_regex_filter);

  // .google.bigtable.v2.ValueRange value_range_filter = 15;
  bool has_value_range_filter() const;
  void clear_value_range_filter();
  static const int kValueRangeFilterFieldNumber = 15;
  private:
  const ::google::bigtable::v2::ValueRange& _internal_value_range_filter() const;
  public:
  const ::google::bigtable::v2::ValueRange& value_range_filter() const;
  ::google::bigtable::v2::ValueRange* release_value_range_filter();
  ::google::bigtable::v2::ValueRange* mutable_value_range_filter();
  void set_allocated_value_range_filter(::google::bigtable::v2::ValueRange* value_range_filter);

  // int32 cells_per_row_offset_filter = 10;
  private:
  bool has_cells_per_row_offset_filter() const;
  public:
  void clear_cells_per_row_offset_filter();
  static const int kCellsPerRowOffsetFilterFieldNumber = 10;
  ::google::protobuf::int32 cells_per_row_offset_filter() const;
  void set_cells_per_row_offset_filter(::google::protobuf::int32 value);

  // int32 cells_per_row_limit_filter = 11;
  private:
  bool has_cells_per_row_limit_filter() const;
  public:
  void clear_cells_per_row_limit_filter();
  static const int kCellsPerRowLimitFilterFieldNumber = 11;
  ::google::protobuf::int32 cells_per_row_limit_filter() const;
  void set_cells_per_row_limit_filter(::google::protobuf::int32 value);

  // int32 cells_per_column_limit_filter = 12;
  private:
  bool has_cells_per_column_limit_filter() const;
  public:
  void clear_cells_per_column_limit_filter();
  static const int kCellsPerColumnLimitFilterFieldNumber = 12;
  ::google::protobuf::int32 cells_per_column_limit_filter() const;
  void set_cells_per_column_limit_filter(::google::protobuf::int32 value);

  // bool strip_value_transformer = 13;
  private:
  bool has_strip_value_transformer() const;
  public:
  void clear_strip_value_transformer();
  static const int kStripValueTransformerFieldNumber = 13;
  bool strip_value_transformer() const;
  void set_strip_value_transformer(bool value);

  // string apply_label_transformer = 19;
  private:
  bool has_apply_label_transformer() const;
  public:
  void clear_apply_label_transformer();
  static const int kApplyLabelTransformerFieldNumber = 19;
  const ::std::string& apply_label_transformer() const;
  void set_apply_label_transformer(const ::std::string& value);
  #if LANG_CXX11
  void set_apply_label_transformer(::std::string&& value);
  #endif
  void set_apply_label_transformer(const char* value);
  void set_apply_label_transformer(const char* value, size_t size);
  ::std::string* mutable_apply_label_transformer();
  ::std::string* release_apply_label_transformer();
  void set_allocated_apply_label_transformer(::std::string* apply_label_transformer);

  void clear_filter();
  FilterCase filter_case() const;
  // @@protoc_insertion_point(class_scope:google.bigtable.v2.RowFilter)
 private:
  void set_has_chain();
  void set_has_interleave();
  void set_has_condition();
  void set_has_sink();
  void set_has_pass_all_filter();
  void set_has_block_all_filter();
  void set_has_row_key_regex_filter();
  void set_has_row_sample_filter();
  void set_has_family_name_regex_filter();
  void set_has_column_qualifier_regex_filter();
  void set_has_column_range_filter();
  void set_has_timestamp_range_filter();
  void set_has_value_regex_filter();
  void set_has_value_range_filter();
  void set_has_cells_per_row_offset_filter();
  void set_has_cells_per_row_limit_filter();
  void set_has_cells_per_column_limit_filter();
  void set_has_strip_value_transformer();
  void set_has_apply_label_transformer();

  inline bool has_filter() const;
  inline void clear_has_filter();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  union FilterUnion {
    FilterUnion() {}
    ::google::bigtable::v2::RowFilter_Chain* chain_;
    ::google::bigtable::v2::RowFilter_Interleave* interleave_;
    ::google::bigtable::v2::RowFilter_Condition* condition_;
    bool sink_;
    bool pass_all_filter_;
    bool block_all_filter_;
    ::google::protobuf::internal::ArenaStringPtr row_key_regex_filter_;
    double row_sample_filter_;
    ::google::protobuf::internal::ArenaStringPtr family_name_regex_filter_;
    ::google::protobuf::internal::ArenaStringPtr column_qualifier_regex_filter_;
    ::google::bigtable::v2::ColumnRange* column_range_filter_;
    ::google::bigtable::v2::TimestampRange* timestamp_range_filter_;
    ::google::protobuf::internal::ArenaStringPtr value_regex_filter_;
    ::google::bigtable::v2::ValueRange* value_range_filter_;
    ::google::protobuf::int32 cells_per_row_offset_filter_;
    ::google::protobuf::int32 cells_per_row_limit_filter_;
    ::google::protobuf::int32 cells_per_column_limit_filter_;
    bool strip_value_transformer_;
    ::google::protobuf::internal::ArenaStringPtr apply_label_transformer_;
  } filter_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Mutation_SetCell : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.Mutation.SetCell) */ {
 public:
  Mutation_SetCell();
  virtual ~Mutation_SetCell();

  Mutation_SetCell(const Mutation_SetCell& from);

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

  inline Mutation_SetCell& operator=(Mutation_SetCell&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Mutation_SetCell& default_instance();

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // string family_name = 1;
  void clear_family_name();
  static const int kFamilyNameFieldNumber = 1;
  const ::std::string& family_name() const;
  void set_family_name(const ::std::string& value);
  #if LANG_CXX11
  void set_family_name(::std::string&& value);
  #endif
  void set_family_name(const char* value);
  void set_family_name(const char* value, size_t size);
  ::std::string* mutable_family_name();
  ::std::string* release_family_name();
  void set_allocated_family_name(::std::string* family_name);

  // bytes column_qualifier = 2;
  void clear_column_qualifier();
  static const int kColumnQualifierFieldNumber = 2;
  const ::std::string& column_qualifier() const;
  void set_column_qualifier(const ::std::string& value);
  #if LANG_CXX11
  void set_column_qualifier(::std::string&& value);
  #endif
  void set_column_qualifier(const char* value);
  void set_column_qualifier(const void* value, size_t size);
  ::std::string* mutable_column_qualifier();
  ::std::string* release_column_qualifier();
  void set_allocated_column_qualifier(::std::string* column_qualifier);

  // bytes value = 4;
  void clear_value();
  static const int kValueFieldNumber = 4;
  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 void* value, size_t size);
  ::std::string* mutable_value();
  ::std::string* release_value();
  void set_allocated_value(::std::string* value);

  // int64 timestamp_micros = 3;
  void clear_timestamp_micros();
  static const int kTimestampMicrosFieldNumber = 3;
  ::google::protobuf::int64 timestamp_micros() const;
  void set_timestamp_micros(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:google.bigtable.v2.Mutation.SetCell)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr family_name_;
  ::google::protobuf::internal::ArenaStringPtr column_qualifier_;
  ::google::protobuf::internal::ArenaStringPtr value_;
  ::google::protobuf::int64 timestamp_micros_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Mutation_DeleteFromColumn : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.Mutation.DeleteFromColumn) */ {
 public:
  Mutation_DeleteFromColumn();
  virtual ~Mutation_DeleteFromColumn();

  Mutation_DeleteFromColumn(const Mutation_DeleteFromColumn& from);

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

  inline Mutation_DeleteFromColumn& operator=(Mutation_DeleteFromColumn&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Mutation_DeleteFromColumn& default_instance();

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // string family_name = 1;
  void clear_family_name();
  static const int kFamilyNameFieldNumber = 1;
  const ::std::string& family_name() const;
  void set_family_name(const ::std::string& value);
  #if LANG_CXX11
  void set_family_name(::std::string&& value);
  #endif
  void set_family_name(const char* value);
  void set_family_name(const char* value, size_t size);
  ::std::string* mutable_family_name();
  ::std::string* release_family_name();
  void set_allocated_family_name(::std::string* family_name);

  // bytes column_qualifier = 2;
  void clear_column_qualifier();
  static const int kColumnQualifierFieldNumber = 2;
  const ::std::string& column_qualifier() const;
  void set_column_qualifier(const ::std::string& value);
  #if LANG_CXX11
  void set_column_qualifier(::std::string&& value);
  #endif
  void set_column_qualifier(const char* value);
  void set_column_qualifier(const void* value, size_t size);
  ::std::string* mutable_column_qualifier();
  ::std::string* release_column_qualifier();
  void set_allocated_column_qualifier(::std::string* column_qualifier);

  // .google.bigtable.v2.TimestampRange time_range = 3;
  bool has_time_range() const;
  void clear_time_range();
  static const int kTimeRangeFieldNumber = 3;
  private:
  const ::google::bigtable::v2::TimestampRange& _internal_time_range() const;
  public:
  const ::google::bigtable::v2::TimestampRange& time_range() const;
  ::google::bigtable::v2::TimestampRange* release_time_range();
  ::google::bigtable::v2::TimestampRange* mutable_time_range();
  void set_allocated_time_range(::google::bigtable::v2::TimestampRange* time_range);

  // @@protoc_insertion_point(class_scope:google.bigtable.v2.Mutation.DeleteFromColumn)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr family_name_;
  ::google::protobuf::internal::ArenaStringPtr column_qualifier_;
  ::google::bigtable::v2::TimestampRange* time_range_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Mutation_DeleteFromFamily : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.Mutation.DeleteFromFamily) */ {
 public:
  Mutation_DeleteFromFamily();
  virtual ~Mutation_DeleteFromFamily();

  Mutation_DeleteFromFamily(const Mutation_DeleteFromFamily& from);

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

  inline Mutation_DeleteFromFamily& operator=(Mutation_DeleteFromFamily&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Mutation_DeleteFromFamily& default_instance();

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // string family_name = 1;
  void clear_family_name();
  static const int kFamilyNameFieldNumber = 1;
  const ::std::string& family_name() const;
  void set_family_name(const ::std::string& value);
  #if LANG_CXX11
  void set_family_name(::std::string&& value);
  #endif
  void set_family_name(const char* value);
  void set_family_name(const char* value, size_t size);
  ::std::string* mutable_family_name();
  ::std::string* release_family_name();
  void set_allocated_family_name(::std::string* family_name);

  // @@protoc_insertion_point(class_scope:google.bigtable.v2.Mutation.DeleteFromFamily)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr family_name_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Mutation_DeleteFromRow : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.Mutation.DeleteFromRow) */ {
 public:
  Mutation_DeleteFromRow();
  virtual ~Mutation_DeleteFromRow();

  Mutation_DeleteFromRow(const Mutation_DeleteFromRow& from);

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

  inline Mutation_DeleteFromRow& operator=(Mutation_DeleteFromRow&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Mutation_DeleteFromRow& default_instance();

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // @@protoc_insertion_point(class_scope:google.bigtable.v2.Mutation.DeleteFromRow)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Mutation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.Mutation) */ {
 public:
  Mutation();
  virtual ~Mutation();

  Mutation(const Mutation& from);

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

  inline Mutation& operator=(Mutation&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Mutation& default_instance();

  enum MutationCase {
    kSetCell = 1,
    kDeleteFromColumn = 2,
    kDeleteFromFamily = 3,
    kDeleteFromRow = 4,
    MUTATION_NOT_SET = 0,
  };

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

  typedef Mutation_SetCell SetCell;
  typedef Mutation_DeleteFromColumn DeleteFromColumn;
  typedef Mutation_DeleteFromFamily DeleteFromFamily;
  typedef Mutation_DeleteFromRow DeleteFromRow;

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

  // .google.bigtable.v2.Mutation.SetCell set_cell = 1;
  bool has_set_cell() const;
  void clear_set_cell();
  static const int kSetCellFieldNumber = 1;
  private:
  const ::google::bigtable::v2::Mutation_SetCell& _internal_set_cell() const;
  public:
  const ::google::bigtable::v2::Mutation_SetCell& set_cell() const;
  ::google::bigtable::v2::Mutation_SetCell* release_set_cell();
  ::google::bigtable::v2::Mutation_SetCell* mutable_set_cell();
  void set_allocated_set_cell(::google::bigtable::v2::Mutation_SetCell* set_cell);

  // .google.bigtable.v2.Mutation.DeleteFromColumn delete_from_column = 2;
  bool has_delete_from_column() const;
  void clear_delete_from_column();
  static const int kDeleteFromColumnFieldNumber = 2;
  private:
  const ::google::bigtable::v2::Mutation_DeleteFromColumn& _internal_delete_from_column() const;
  public:
  const ::google::bigtable::v2::Mutation_DeleteFromColumn& delete_from_column() const;
  ::google::bigtable::v2::Mutation_DeleteFromColumn* release_delete_from_column();
  ::google::bigtable::v2::Mutation_DeleteFromColumn* mutable_delete_from_column();
  void set_allocated_delete_from_column(::google::bigtable::v2::Mutation_DeleteFromColumn* delete_from_column);

  // .google.bigtable.v2.Mutation.DeleteFromFamily delete_from_family = 3;
  bool has_delete_from_family() const;
  void clear_delete_from_family();
  static const int kDeleteFromFamilyFieldNumber = 3;
  private:
  const ::google::bigtable::v2::Mutation_DeleteFromFamily& _internal_delete_from_family() const;
  public:
  const ::google::bigtable::v2::Mutation_DeleteFromFamily& delete_from_family() const;
  ::google::bigtable::v2::Mutation_DeleteFromFamily* release_delete_from_family();
  ::google::bigtable::v2::Mutation_DeleteFromFamily* mutable_delete_from_family();
  void set_allocated_delete_from_family(::google::bigtable::v2::Mutation_DeleteFromFamily* delete_from_family);

  // .google.bigtable.v2.Mutation.DeleteFromRow delete_from_row = 4;
  bool has_delete_from_row() const;
  void clear_delete_from_row();
  static const int kDeleteFromRowFieldNumber = 4;
  private:
  const ::google::bigtable::v2::Mutation_DeleteFromRow& _internal_delete_from_row() const;
  public:
  const ::google::bigtable::v2::Mutation_DeleteFromRow& delete_from_row() const;
  ::google::bigtable::v2::Mutation_DeleteFromRow* release_delete_from_row();
  ::google::bigtable::v2::Mutation_DeleteFromRow* mutable_delete_from_row();
  void set_allocated_delete_from_row(::google::bigtable::v2::Mutation_DeleteFromRow* delete_from_row);

  void clear_mutation();
  MutationCase mutation_case() const;
  // @@protoc_insertion_point(class_scope:google.bigtable.v2.Mutation)
 private:
  void set_has_set_cell();
  void set_has_delete_from_column();
  void set_has_delete_from_family();
  void set_has_delete_from_row();

  inline bool has_mutation() const;
  inline void clear_has_mutation();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  union MutationUnion {
    MutationUnion() {}
    ::google::bigtable::v2::Mutation_SetCell* set_cell_;
    ::google::bigtable::v2::Mutation_DeleteFromColumn* delete_from_column_;
    ::google::bigtable::v2::Mutation_DeleteFromFamily* delete_from_family_;
    ::google::bigtable::v2::Mutation_DeleteFromRow* delete_from_row_;
  } mutation_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ReadModifyWriteRule : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.bigtable.v2.ReadModifyWriteRule) */ {
 public:
  ReadModifyWriteRule();
  virtual ~ReadModifyWriteRule();

  ReadModifyWriteRule(const ReadModifyWriteRule& from);

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

  inline ReadModifyWriteRule& operator=(ReadModifyWriteRule&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ReadModifyWriteRule& default_instance();

  enum RuleCase {
    kAppendValue = 3,
    kIncrementAmount = 4,
    RULE_NOT_SET = 0,
  };

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

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

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

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

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

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

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

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // string family_name = 1;
  void clear_family_name();
  static const int kFamilyNameFieldNumber = 1;
  const ::std::string& family_name() const;
  void set_family_name(const ::std::string& value);
  #if LANG_CXX11
  void set_family_name(::std::string&& value);
  #endif
  void set_family_name(const char* value);
  void set_family_name(const char* value, size_t size);
  ::std::string* mutable_family_name();
  ::std::string* release_family_name();
  void set_allocated_family_name(::std::string* family_name);

  // bytes column_qualifier = 2;
  void clear_column_qualifier();
  static const int kColumnQualifierFieldNumber = 2;
  const ::std::string& column_qualifier() const;
  void set_column_qualifier(const ::std::string& value);
  #if LANG_CXX11
  void set_column_qualifier(::std::string&& value);
  #endif
  void set_column_qualifier(const char* value);
  void set_column_qualifier(const void* value, size_t size);
  ::std::string* mutable_column_qualifier();
  ::std::string* release_column_qualifier();
  void set_allocated_column_qualifier(::std::string* column_qualifier);

  // bytes append_value = 3;
  private:
  bool has_append_value() const;
  public:
  void clear_append_value();
  static const int kAppendValueFieldNumber = 3;
  const ::std::string& append_value() const;
  void set_append_value(const ::std::string& value);
  #if LANG_CXX11
  void set_append_value(::std::string&& value);
  #endif
  void set_append_value(const char* value);
  void set_append_value(const void* value, size_t size);
  ::std::string* mutable_append_value();
  ::std::string* release_append_value();
  void set_allocated_append_value(::std::string* append_value);

  // int64 increment_amount = 4;
  private:
  bool has_increment_amount() const;
  public:
  void clear_increment_amount();
  static const int kIncrementAmountFieldNumber = 4;
  ::google::protobuf::int64 increment_amount() const;
  void set_increment_amount(::google::protobuf::int64 value);

  void clear_rule();
  RuleCase rule_case() const;
  // @@protoc_insertion_point(class_scope:google.bigtable.v2.ReadModifyWriteRule)
 private:
  void set_has_append_value();
  void set_has_increment_amount();

  inline bool has_rule() const;
  inline void clear_has_rule();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr family_name_;
  ::google::protobuf::internal::ArenaStringPtr column_qualifier_;
  union RuleUnion {
    RuleUnion() {}
    ::google::protobuf::internal::ArenaStringPtr append_value_;
    ::google::protobuf::int64 increment_amount_;
  } rule_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_google_2fbigtable_2fv2_2fdata_2eproto::TableStruct;
};
// ===================================================================


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

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

// bytes key = 1;
inline void Row::clear_key() {
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Row::key() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Row.key)
  return key_.GetNoArena();
}
inline void Row::set_key(const ::std::string& value) {
  
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Row.key)
}
#if LANG_CXX11
inline void Row::set_key(::std::string&& value) {
  
  key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.Row.key)
}
#endif
inline void Row::set_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.Row.key)
}
inline void Row::set_key(const void* value, size_t size) {
  
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.Row.key)
}
inline ::std::string* Row::mutable_key() {
  
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Row.key)
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Row::release_key() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Row.key)
  
  return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Row::set_allocated_key(::std::string* key) {
  if (key != NULL) {
    
  } else {
    
  }
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.Row.key)
}

// repeated .google.bigtable.v2.Family families = 2;
inline int Row::families_size() const {
  return families_.size();
}
inline void Row::clear_families() {
  families_.Clear();
}
inline ::google::bigtable::v2::Family* Row::mutable_families(int index) {
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Row.families)
  return families_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Family >*
Row::mutable_families() {
  // @@protoc_insertion_point(field_mutable_list:google.bigtable.v2.Row.families)
  return &families_;
}
inline const ::google::bigtable::v2::Family& Row::families(int index) const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Row.families)
  return families_.Get(index);
}
inline ::google::bigtable::v2::Family* Row::add_families() {
  // @@protoc_insertion_point(field_add:google.bigtable.v2.Row.families)
  return families_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Family >&
Row::families() const {
  // @@protoc_insertion_point(field_list:google.bigtable.v2.Row.families)
  return families_;
}

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

// Family

// string name = 1;
inline void Family::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Family::name() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Family.name)
  return name_.GetNoArena();
}
inline void Family::set_name(const ::std::string& value) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Family.name)
}
#if LANG_CXX11
inline void Family::set_name(::std::string&& value) {
  
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.Family.name)
}
#endif
inline void Family::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.Family.name)
}
inline void Family::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.Family.name)
}
inline ::std::string* Family::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Family.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Family::release_name() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Family.name)
  
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Family::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.Family.name)
}

// repeated .google.bigtable.v2.Column columns = 2;
inline int Family::columns_size() const {
  return columns_.size();
}
inline void Family::clear_columns() {
  columns_.Clear();
}
inline ::google::bigtable::v2::Column* Family::mutable_columns(int index) {
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Family.columns)
  return columns_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Column >*
Family::mutable_columns() {
  // @@protoc_insertion_point(field_mutable_list:google.bigtable.v2.Family.columns)
  return &columns_;
}
inline const ::google::bigtable::v2::Column& Family::columns(int index) const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Family.columns)
  return columns_.Get(index);
}
inline ::google::bigtable::v2::Column* Family::add_columns() {
  // @@protoc_insertion_point(field_add:google.bigtable.v2.Family.columns)
  return columns_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Column >&
Family::columns() const {
  // @@protoc_insertion_point(field_list:google.bigtable.v2.Family.columns)
  return columns_;
}

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

// Column

// bytes qualifier = 1;
inline void Column::clear_qualifier() {
  qualifier_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Column::qualifier() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Column.qualifier)
  return qualifier_.GetNoArena();
}
inline void Column::set_qualifier(const ::std::string& value) {
  
  qualifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Column.qualifier)
}
#if LANG_CXX11
inline void Column::set_qualifier(::std::string&& value) {
  
  qualifier_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.Column.qualifier)
}
#endif
inline void Column::set_qualifier(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  qualifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.Column.qualifier)
}
inline void Column::set_qualifier(const void* value, size_t size) {
  
  qualifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.Column.qualifier)
}
inline ::std::string* Column::mutable_qualifier() {
  
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Column.qualifier)
  return qualifier_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Column::release_qualifier() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Column.qualifier)
  
  return qualifier_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Column::set_allocated_qualifier(::std::string* qualifier) {
  if (qualifier != NULL) {
    
  } else {
    
  }
  qualifier_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), qualifier);
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.Column.qualifier)
}

// repeated .google.bigtable.v2.Cell cells = 2;
inline int Column::cells_size() const {
  return cells_.size();
}
inline void Column::clear_cells() {
  cells_.Clear();
}
inline ::google::bigtable::v2::Cell* Column::mutable_cells(int index) {
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Column.cells)
  return cells_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Cell >*
Column::mutable_cells() {
  // @@protoc_insertion_point(field_mutable_list:google.bigtable.v2.Column.cells)
  return &cells_;
}
inline const ::google::bigtable::v2::Cell& Column::cells(int index) const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Column.cells)
  return cells_.Get(index);
}
inline ::google::bigtable::v2::Cell* Column::add_cells() {
  // @@protoc_insertion_point(field_add:google.bigtable.v2.Column.cells)
  return cells_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::Cell >&
Column::cells() const {
  // @@protoc_insertion_point(field_list:google.bigtable.v2.Column.cells)
  return cells_;
}

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

// Cell

// int64 timestamp_micros = 1;
inline void Cell::clear_timestamp_micros() {
  timestamp_micros_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 Cell::timestamp_micros() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Cell.timestamp_micros)
  return timestamp_micros_;
}
inline void Cell::set_timestamp_micros(::google::protobuf::int64 value) {
  
  timestamp_micros_ = value;
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Cell.timestamp_micros)
}

// bytes value = 2;
inline void Cell::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Cell::value() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Cell.value)
  return value_.GetNoArena();
}
inline void Cell::set_value(const ::std::string& value) {
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Cell.value)
}
#if LANG_CXX11
inline void Cell::set_value(::std::string&& value) {
  
  value_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.Cell.value)
}
#endif
inline void Cell::set_value(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.Cell.value)
}
inline void Cell::set_value(const void* value, size_t size) {
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.Cell.value)
}
inline ::std::string* Cell::mutable_value() {
  
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Cell.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Cell::release_value() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Cell.value)
  
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Cell::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    
  } else {
    
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.Cell.value)
}

// repeated string labels = 3;
inline int Cell::labels_size() const {
  return labels_.size();
}
inline void Cell::clear_labels() {
  labels_.Clear();
}
inline const ::std::string& Cell::labels(int index) const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Cell.labels)
  return labels_.Get(index);
}
inline ::std::string* Cell::mutable_labels(int index) {
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Cell.labels)
  return labels_.Mutable(index);
}
inline void Cell::set_labels(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Cell.labels)
  labels_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void Cell::set_labels(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Cell.labels)
  labels_.Mutable(index)->assign(std::move(value));
}
#endif
inline void Cell::set_labels(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  labels_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.Cell.labels)
}
inline void Cell::set_labels(int index, const char* value, size_t size) {
  labels_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.Cell.labels)
}
inline ::std::string* Cell::add_labels() {
  // @@protoc_insertion_point(field_add_mutable:google.bigtable.v2.Cell.labels)
  return labels_.Add();
}
inline void Cell::add_labels(const ::std::string& value) {
  labels_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:google.bigtable.v2.Cell.labels)
}
#if LANG_CXX11
inline void Cell::add_labels(::std::string&& value) {
  labels_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:google.bigtable.v2.Cell.labels)
}
#endif
inline void Cell::add_labels(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  labels_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:google.bigtable.v2.Cell.labels)
}
inline void Cell::add_labels(const char* value, size_t size) {
  labels_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:google.bigtable.v2.Cell.labels)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
Cell::labels() const {
  // @@protoc_insertion_point(field_list:google.bigtable.v2.Cell.labels)
  return labels_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
Cell::mutable_labels() {
  // @@protoc_insertion_point(field_mutable_list:google.bigtable.v2.Cell.labels)
  return &labels_;
}

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

// RowRange

// bytes start_key_closed = 1;
inline bool RowRange::has_start_key_closed() const {
  return start_key_case() == kStartKeyClosed;
}
inline void RowRange::set_has_start_key_closed() {
  _oneof_case_[0] = kStartKeyClosed;
}
inline void RowRange::clear_start_key_closed() {
  if (has_start_key_closed()) {
    start_key_.start_key_closed_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_start_key();
  }
}
inline const ::std::string& RowRange::start_key_closed() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowRange.start_key_closed)
  if (has_start_key_closed()) {
    return start_key_.start_key_closed_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void RowRange::set_start_key_closed(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowRange.start_key_closed)
  if (!has_start_key_closed()) {
    clear_start_key();
    set_has_start_key_closed();
    start_key_.start_key_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_key_.start_key_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowRange.start_key_closed)
}
#if LANG_CXX11
inline void RowRange::set_start_key_closed(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowRange.start_key_closed)
  if (!has_start_key_closed()) {
    clear_start_key();
    set_has_start_key_closed();
    start_key_.start_key_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_key_.start_key_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.RowRange.start_key_closed)
}
#endif
inline void RowRange::set_start_key_closed(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_start_key_closed()) {
    clear_start_key();
    set_has_start_key_closed();
    start_key_.start_key_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_key_.start_key_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.RowRange.start_key_closed)
}
inline void RowRange::set_start_key_closed(const void* value, size_t size) {
  if (!has_start_key_closed()) {
    clear_start_key();
    set_has_start_key_closed();
    start_key_.start_key_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_key_.start_key_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.RowRange.start_key_closed)
}
inline ::std::string* RowRange::mutable_start_key_closed() {
  if (!has_start_key_closed()) {
    clear_start_key();
    set_has_start_key_closed();
    start_key_.start_key_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowRange.start_key_closed)
  return start_key_.start_key_closed_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RowRange::release_start_key_closed() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowRange.start_key_closed)
  if (has_start_key_closed()) {
    clear_has_start_key();
    return start_key_.start_key_closed_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void RowRange::set_allocated_start_key_closed(::std::string* start_key_closed) {
  if (!has_start_key_closed()) {
    start_key_.start_key_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_start_key();
  if (start_key_closed != NULL) {
    set_has_start_key_closed();
    start_key_.start_key_closed_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), start_key_closed);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.RowRange.start_key_closed)
}

// bytes start_key_open = 2;
inline bool RowRange::has_start_key_open() const {
  return start_key_case() == kStartKeyOpen;
}
inline void RowRange::set_has_start_key_open() {
  _oneof_case_[0] = kStartKeyOpen;
}
inline void RowRange::clear_start_key_open() {
  if (has_start_key_open()) {
    start_key_.start_key_open_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_start_key();
  }
}
inline const ::std::string& RowRange::start_key_open() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowRange.start_key_open)
  if (has_start_key_open()) {
    return start_key_.start_key_open_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void RowRange::set_start_key_open(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowRange.start_key_open)
  if (!has_start_key_open()) {
    clear_start_key();
    set_has_start_key_open();
    start_key_.start_key_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_key_.start_key_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowRange.start_key_open)
}
#if LANG_CXX11
inline void RowRange::set_start_key_open(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowRange.start_key_open)
  if (!has_start_key_open()) {
    clear_start_key();
    set_has_start_key_open();
    start_key_.start_key_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_key_.start_key_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.RowRange.start_key_open)
}
#endif
inline void RowRange::set_start_key_open(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_start_key_open()) {
    clear_start_key();
    set_has_start_key_open();
    start_key_.start_key_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_key_.start_key_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.RowRange.start_key_open)
}
inline void RowRange::set_start_key_open(const void* value, size_t size) {
  if (!has_start_key_open()) {
    clear_start_key();
    set_has_start_key_open();
    start_key_.start_key_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_key_.start_key_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.RowRange.start_key_open)
}
inline ::std::string* RowRange::mutable_start_key_open() {
  if (!has_start_key_open()) {
    clear_start_key();
    set_has_start_key_open();
    start_key_.start_key_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowRange.start_key_open)
  return start_key_.start_key_open_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RowRange::release_start_key_open() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowRange.start_key_open)
  if (has_start_key_open()) {
    clear_has_start_key();
    return start_key_.start_key_open_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void RowRange::set_allocated_start_key_open(::std::string* start_key_open) {
  if (!has_start_key_open()) {
    start_key_.start_key_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_start_key();
  if (start_key_open != NULL) {
    set_has_start_key_open();
    start_key_.start_key_open_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), start_key_open);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.RowRange.start_key_open)
}

// bytes end_key_open = 3;
inline bool RowRange::has_end_key_open() const {
  return end_key_case() == kEndKeyOpen;
}
inline void RowRange::set_has_end_key_open() {
  _oneof_case_[1] = kEndKeyOpen;
}
inline void RowRange::clear_end_key_open() {
  if (has_end_key_open()) {
    end_key_.end_key_open_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_end_key();
  }
}
inline const ::std::string& RowRange::end_key_open() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowRange.end_key_open)
  if (has_end_key_open()) {
    return end_key_.end_key_open_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void RowRange::set_end_key_open(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowRange.end_key_open)
  if (!has_end_key_open()) {
    clear_end_key();
    set_has_end_key_open();
    end_key_.end_key_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_key_.end_key_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowRange.end_key_open)
}
#if LANG_CXX11
inline void RowRange::set_end_key_open(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowRange.end_key_open)
  if (!has_end_key_open()) {
    clear_end_key();
    set_has_end_key_open();
    end_key_.end_key_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_key_.end_key_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.RowRange.end_key_open)
}
#endif
inline void RowRange::set_end_key_open(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_end_key_open()) {
    clear_end_key();
    set_has_end_key_open();
    end_key_.end_key_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_key_.end_key_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.RowRange.end_key_open)
}
inline void RowRange::set_end_key_open(const void* value, size_t size) {
  if (!has_end_key_open()) {
    clear_end_key();
    set_has_end_key_open();
    end_key_.end_key_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_key_.end_key_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.RowRange.end_key_open)
}
inline ::std::string* RowRange::mutable_end_key_open() {
  if (!has_end_key_open()) {
    clear_end_key();
    set_has_end_key_open();
    end_key_.end_key_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowRange.end_key_open)
  return end_key_.end_key_open_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RowRange::release_end_key_open() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowRange.end_key_open)
  if (has_end_key_open()) {
    clear_has_end_key();
    return end_key_.end_key_open_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void RowRange::set_allocated_end_key_open(::std::string* end_key_open) {
  if (!has_end_key_open()) {
    end_key_.end_key_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_end_key();
  if (end_key_open != NULL) {
    set_has_end_key_open();
    end_key_.end_key_open_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), end_key_open);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.RowRange.end_key_open)
}

// bytes end_key_closed = 4;
inline bool RowRange::has_end_key_closed() const {
  return end_key_case() == kEndKeyClosed;
}
inline void RowRange::set_has_end_key_closed() {
  _oneof_case_[1] = kEndKeyClosed;
}
inline void RowRange::clear_end_key_closed() {
  if (has_end_key_closed()) {
    end_key_.end_key_closed_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_end_key();
  }
}
inline const ::std::string& RowRange::end_key_closed() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowRange.end_key_closed)
  if (has_end_key_closed()) {
    return end_key_.end_key_closed_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void RowRange::set_end_key_closed(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowRange.end_key_closed)
  if (!has_end_key_closed()) {
    clear_end_key();
    set_has_end_key_closed();
    end_key_.end_key_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_key_.end_key_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowRange.end_key_closed)
}
#if LANG_CXX11
inline void RowRange::set_end_key_closed(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowRange.end_key_closed)
  if (!has_end_key_closed()) {
    clear_end_key();
    set_has_end_key_closed();
    end_key_.end_key_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_key_.end_key_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.RowRange.end_key_closed)
}
#endif
inline void RowRange::set_end_key_closed(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_end_key_closed()) {
    clear_end_key();
    set_has_end_key_closed();
    end_key_.end_key_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_key_.end_key_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.RowRange.end_key_closed)
}
inline void RowRange::set_end_key_closed(const void* value, size_t size) {
  if (!has_end_key_closed()) {
    clear_end_key();
    set_has_end_key_closed();
    end_key_.end_key_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_key_.end_key_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.RowRange.end_key_closed)
}
inline ::std::string* RowRange::mutable_end_key_closed() {
  if (!has_end_key_closed()) {
    clear_end_key();
    set_has_end_key_closed();
    end_key_.end_key_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowRange.end_key_closed)
  return end_key_.end_key_closed_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RowRange::release_end_key_closed() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowRange.end_key_closed)
  if (has_end_key_closed()) {
    clear_has_end_key();
    return end_key_.end_key_closed_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void RowRange::set_allocated_end_key_closed(::std::string* end_key_closed) {
  if (!has_end_key_closed()) {
    end_key_.end_key_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_end_key();
  if (end_key_closed != NULL) {
    set_has_end_key_closed();
    end_key_.end_key_closed_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), end_key_closed);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.RowRange.end_key_closed)
}

inline bool RowRange::has_start_key() const {
  return start_key_case() != START_KEY_NOT_SET;
}
inline void RowRange::clear_has_start_key() {
  _oneof_case_[0] = START_KEY_NOT_SET;
}
inline bool RowRange::has_end_key() const {
  return end_key_case() != END_KEY_NOT_SET;
}
inline void RowRange::clear_has_end_key() {
  _oneof_case_[1] = END_KEY_NOT_SET;
}
inline RowRange::StartKeyCase RowRange::start_key_case() const {
  return RowRange::StartKeyCase(_oneof_case_[0]);
}
inline RowRange::EndKeyCase RowRange::end_key_case() const {
  return RowRange::EndKeyCase(_oneof_case_[1]);
}
// -------------------------------------------------------------------

// RowSet

// repeated bytes row_keys = 1;
inline int RowSet::row_keys_size() const {
  return row_keys_.size();
}
inline void RowSet::clear_row_keys() {
  row_keys_.Clear();
}
inline const ::std::string& RowSet::row_keys(int index) const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowSet.row_keys)
  return row_keys_.Get(index);
}
inline ::std::string* RowSet::mutable_row_keys(int index) {
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowSet.row_keys)
  return row_keys_.Mutable(index);
}
inline void RowSet::set_row_keys(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowSet.row_keys)
  row_keys_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void RowSet::set_row_keys(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowSet.row_keys)
  row_keys_.Mutable(index)->assign(std::move(value));
}
#endif
inline void RowSet::set_row_keys(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  row_keys_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.RowSet.row_keys)
}
inline void RowSet::set_row_keys(int index, const void* value, size_t size) {
  row_keys_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.RowSet.row_keys)
}
inline ::std::string* RowSet::add_row_keys() {
  // @@protoc_insertion_point(field_add_mutable:google.bigtable.v2.RowSet.row_keys)
  return row_keys_.Add();
}
inline void RowSet::add_row_keys(const ::std::string& value) {
  row_keys_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:google.bigtable.v2.RowSet.row_keys)
}
#if LANG_CXX11
inline void RowSet::add_row_keys(::std::string&& value) {
  row_keys_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:google.bigtable.v2.RowSet.row_keys)
}
#endif
inline void RowSet::add_row_keys(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  row_keys_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:google.bigtable.v2.RowSet.row_keys)
}
inline void RowSet::add_row_keys(const void* value, size_t size) {
  row_keys_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:google.bigtable.v2.RowSet.row_keys)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
RowSet::row_keys() const {
  // @@protoc_insertion_point(field_list:google.bigtable.v2.RowSet.row_keys)
  return row_keys_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
RowSet::mutable_row_keys() {
  // @@protoc_insertion_point(field_mutable_list:google.bigtable.v2.RowSet.row_keys)
  return &row_keys_;
}

// repeated .google.bigtable.v2.RowRange row_ranges = 2;
inline int RowSet::row_ranges_size() const {
  return row_ranges_.size();
}
inline void RowSet::clear_row_ranges() {
  row_ranges_.Clear();
}
inline ::google::bigtable::v2::RowRange* RowSet::mutable_row_ranges(int index) {
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowSet.row_ranges)
  return row_ranges_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowRange >*
RowSet::mutable_row_ranges() {
  // @@protoc_insertion_point(field_mutable_list:google.bigtable.v2.RowSet.row_ranges)
  return &row_ranges_;
}
inline const ::google::bigtable::v2::RowRange& RowSet::row_ranges(int index) const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowSet.row_ranges)
  return row_ranges_.Get(index);
}
inline ::google::bigtable::v2::RowRange* RowSet::add_row_ranges() {
  // @@protoc_insertion_point(field_add:google.bigtable.v2.RowSet.row_ranges)
  return row_ranges_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowRange >&
RowSet::row_ranges() const {
  // @@protoc_insertion_point(field_list:google.bigtable.v2.RowSet.row_ranges)
  return row_ranges_;
}

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

// ColumnRange

// string family_name = 1;
inline void ColumnRange::clear_family_name() {
  family_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ColumnRange::family_name() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.ColumnRange.family_name)
  return family_name_.GetNoArena();
}
inline void ColumnRange::set_family_name(const ::std::string& value) {
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ColumnRange.family_name)
}
#if LANG_CXX11
inline void ColumnRange::set_family_name(::std::string&& value) {
  
  family_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.ColumnRange.family_name)
}
#endif
inline void ColumnRange::set_family_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.ColumnRange.family_name)
}
inline void ColumnRange::set_family_name(const char* value, size_t size) {
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.ColumnRange.family_name)
}
inline ::std::string* ColumnRange::mutable_family_name() {
  
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.ColumnRange.family_name)
  return family_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ColumnRange::release_family_name() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.ColumnRange.family_name)
  
  return family_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ColumnRange::set_allocated_family_name(::std::string* family_name) {
  if (family_name != NULL) {
    
  } else {
    
  }
  family_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), family_name);
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.ColumnRange.family_name)
}

// bytes start_qualifier_closed = 2;
inline bool ColumnRange::has_start_qualifier_closed() const {
  return start_qualifier_case() == kStartQualifierClosed;
}
inline void ColumnRange::set_has_start_qualifier_closed() {
  _oneof_case_[0] = kStartQualifierClosed;
}
inline void ColumnRange::clear_start_qualifier_closed() {
  if (has_start_qualifier_closed()) {
    start_qualifier_.start_qualifier_closed_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_start_qualifier();
  }
}
inline const ::std::string& ColumnRange::start_qualifier_closed() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.ColumnRange.start_qualifier_closed)
  if (has_start_qualifier_closed()) {
    return start_qualifier_.start_qualifier_closed_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void ColumnRange::set_start_qualifier_closed(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ColumnRange.start_qualifier_closed)
  if (!has_start_qualifier_closed()) {
    clear_start_qualifier();
    set_has_start_qualifier_closed();
    start_qualifier_.start_qualifier_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_qualifier_.start_qualifier_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ColumnRange.start_qualifier_closed)
}
#if LANG_CXX11
inline void ColumnRange::set_start_qualifier_closed(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ColumnRange.start_qualifier_closed)
  if (!has_start_qualifier_closed()) {
    clear_start_qualifier();
    set_has_start_qualifier_closed();
    start_qualifier_.start_qualifier_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_qualifier_.start_qualifier_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.ColumnRange.start_qualifier_closed)
}
#endif
inline void ColumnRange::set_start_qualifier_closed(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_start_qualifier_closed()) {
    clear_start_qualifier();
    set_has_start_qualifier_closed();
    start_qualifier_.start_qualifier_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_qualifier_.start_qualifier_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.ColumnRange.start_qualifier_closed)
}
inline void ColumnRange::set_start_qualifier_closed(const void* value, size_t size) {
  if (!has_start_qualifier_closed()) {
    clear_start_qualifier();
    set_has_start_qualifier_closed();
    start_qualifier_.start_qualifier_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_qualifier_.start_qualifier_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.ColumnRange.start_qualifier_closed)
}
inline ::std::string* ColumnRange::mutable_start_qualifier_closed() {
  if (!has_start_qualifier_closed()) {
    clear_start_qualifier();
    set_has_start_qualifier_closed();
    start_qualifier_.start_qualifier_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.ColumnRange.start_qualifier_closed)
  return start_qualifier_.start_qualifier_closed_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ColumnRange::release_start_qualifier_closed() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.ColumnRange.start_qualifier_closed)
  if (has_start_qualifier_closed()) {
    clear_has_start_qualifier();
    return start_qualifier_.start_qualifier_closed_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void ColumnRange::set_allocated_start_qualifier_closed(::std::string* start_qualifier_closed) {
  if (!has_start_qualifier_closed()) {
    start_qualifier_.start_qualifier_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_start_qualifier();
  if (start_qualifier_closed != NULL) {
    set_has_start_qualifier_closed();
    start_qualifier_.start_qualifier_closed_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), start_qualifier_closed);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.ColumnRange.start_qualifier_closed)
}

// bytes start_qualifier_open = 3;
inline bool ColumnRange::has_start_qualifier_open() const {
  return start_qualifier_case() == kStartQualifierOpen;
}
inline void ColumnRange::set_has_start_qualifier_open() {
  _oneof_case_[0] = kStartQualifierOpen;
}
inline void ColumnRange::clear_start_qualifier_open() {
  if (has_start_qualifier_open()) {
    start_qualifier_.start_qualifier_open_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_start_qualifier();
  }
}
inline const ::std::string& ColumnRange::start_qualifier_open() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.ColumnRange.start_qualifier_open)
  if (has_start_qualifier_open()) {
    return start_qualifier_.start_qualifier_open_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void ColumnRange::set_start_qualifier_open(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ColumnRange.start_qualifier_open)
  if (!has_start_qualifier_open()) {
    clear_start_qualifier();
    set_has_start_qualifier_open();
    start_qualifier_.start_qualifier_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_qualifier_.start_qualifier_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ColumnRange.start_qualifier_open)
}
#if LANG_CXX11
inline void ColumnRange::set_start_qualifier_open(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ColumnRange.start_qualifier_open)
  if (!has_start_qualifier_open()) {
    clear_start_qualifier();
    set_has_start_qualifier_open();
    start_qualifier_.start_qualifier_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_qualifier_.start_qualifier_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.ColumnRange.start_qualifier_open)
}
#endif
inline void ColumnRange::set_start_qualifier_open(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_start_qualifier_open()) {
    clear_start_qualifier();
    set_has_start_qualifier_open();
    start_qualifier_.start_qualifier_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_qualifier_.start_qualifier_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.ColumnRange.start_qualifier_open)
}
inline void ColumnRange::set_start_qualifier_open(const void* value, size_t size) {
  if (!has_start_qualifier_open()) {
    clear_start_qualifier();
    set_has_start_qualifier_open();
    start_qualifier_.start_qualifier_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_qualifier_.start_qualifier_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.ColumnRange.start_qualifier_open)
}
inline ::std::string* ColumnRange::mutable_start_qualifier_open() {
  if (!has_start_qualifier_open()) {
    clear_start_qualifier();
    set_has_start_qualifier_open();
    start_qualifier_.start_qualifier_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.ColumnRange.start_qualifier_open)
  return start_qualifier_.start_qualifier_open_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ColumnRange::release_start_qualifier_open() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.ColumnRange.start_qualifier_open)
  if (has_start_qualifier_open()) {
    clear_has_start_qualifier();
    return start_qualifier_.start_qualifier_open_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void ColumnRange::set_allocated_start_qualifier_open(::std::string* start_qualifier_open) {
  if (!has_start_qualifier_open()) {
    start_qualifier_.start_qualifier_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_start_qualifier();
  if (start_qualifier_open != NULL) {
    set_has_start_qualifier_open();
    start_qualifier_.start_qualifier_open_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), start_qualifier_open);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.ColumnRange.start_qualifier_open)
}

// bytes end_qualifier_closed = 4;
inline bool ColumnRange::has_end_qualifier_closed() const {
  return end_qualifier_case() == kEndQualifierClosed;
}
inline void ColumnRange::set_has_end_qualifier_closed() {
  _oneof_case_[1] = kEndQualifierClosed;
}
inline void ColumnRange::clear_end_qualifier_closed() {
  if (has_end_qualifier_closed()) {
    end_qualifier_.end_qualifier_closed_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_end_qualifier();
  }
}
inline const ::std::string& ColumnRange::end_qualifier_closed() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.ColumnRange.end_qualifier_closed)
  if (has_end_qualifier_closed()) {
    return end_qualifier_.end_qualifier_closed_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void ColumnRange::set_end_qualifier_closed(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ColumnRange.end_qualifier_closed)
  if (!has_end_qualifier_closed()) {
    clear_end_qualifier();
    set_has_end_qualifier_closed();
    end_qualifier_.end_qualifier_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_qualifier_.end_qualifier_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ColumnRange.end_qualifier_closed)
}
#if LANG_CXX11
inline void ColumnRange::set_end_qualifier_closed(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ColumnRange.end_qualifier_closed)
  if (!has_end_qualifier_closed()) {
    clear_end_qualifier();
    set_has_end_qualifier_closed();
    end_qualifier_.end_qualifier_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_qualifier_.end_qualifier_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.ColumnRange.end_qualifier_closed)
}
#endif
inline void ColumnRange::set_end_qualifier_closed(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_end_qualifier_closed()) {
    clear_end_qualifier();
    set_has_end_qualifier_closed();
    end_qualifier_.end_qualifier_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_qualifier_.end_qualifier_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.ColumnRange.end_qualifier_closed)
}
inline void ColumnRange::set_end_qualifier_closed(const void* value, size_t size) {
  if (!has_end_qualifier_closed()) {
    clear_end_qualifier();
    set_has_end_qualifier_closed();
    end_qualifier_.end_qualifier_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_qualifier_.end_qualifier_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.ColumnRange.end_qualifier_closed)
}
inline ::std::string* ColumnRange::mutable_end_qualifier_closed() {
  if (!has_end_qualifier_closed()) {
    clear_end_qualifier();
    set_has_end_qualifier_closed();
    end_qualifier_.end_qualifier_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.ColumnRange.end_qualifier_closed)
  return end_qualifier_.end_qualifier_closed_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ColumnRange::release_end_qualifier_closed() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.ColumnRange.end_qualifier_closed)
  if (has_end_qualifier_closed()) {
    clear_has_end_qualifier();
    return end_qualifier_.end_qualifier_closed_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void ColumnRange::set_allocated_end_qualifier_closed(::std::string* end_qualifier_closed) {
  if (!has_end_qualifier_closed()) {
    end_qualifier_.end_qualifier_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_end_qualifier();
  if (end_qualifier_closed != NULL) {
    set_has_end_qualifier_closed();
    end_qualifier_.end_qualifier_closed_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), end_qualifier_closed);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.ColumnRange.end_qualifier_closed)
}

// bytes end_qualifier_open = 5;
inline bool ColumnRange::has_end_qualifier_open() const {
  return end_qualifier_case() == kEndQualifierOpen;
}
inline void ColumnRange::set_has_end_qualifier_open() {
  _oneof_case_[1] = kEndQualifierOpen;
}
inline void ColumnRange::clear_end_qualifier_open() {
  if (has_end_qualifier_open()) {
    end_qualifier_.end_qualifier_open_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_end_qualifier();
  }
}
inline const ::std::string& ColumnRange::end_qualifier_open() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.ColumnRange.end_qualifier_open)
  if (has_end_qualifier_open()) {
    return end_qualifier_.end_qualifier_open_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void ColumnRange::set_end_qualifier_open(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ColumnRange.end_qualifier_open)
  if (!has_end_qualifier_open()) {
    clear_end_qualifier();
    set_has_end_qualifier_open();
    end_qualifier_.end_qualifier_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_qualifier_.end_qualifier_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ColumnRange.end_qualifier_open)
}
#if LANG_CXX11
inline void ColumnRange::set_end_qualifier_open(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ColumnRange.end_qualifier_open)
  if (!has_end_qualifier_open()) {
    clear_end_qualifier();
    set_has_end_qualifier_open();
    end_qualifier_.end_qualifier_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_qualifier_.end_qualifier_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.ColumnRange.end_qualifier_open)
}
#endif
inline void ColumnRange::set_end_qualifier_open(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_end_qualifier_open()) {
    clear_end_qualifier();
    set_has_end_qualifier_open();
    end_qualifier_.end_qualifier_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_qualifier_.end_qualifier_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.ColumnRange.end_qualifier_open)
}
inline void ColumnRange::set_end_qualifier_open(const void* value, size_t size) {
  if (!has_end_qualifier_open()) {
    clear_end_qualifier();
    set_has_end_qualifier_open();
    end_qualifier_.end_qualifier_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_qualifier_.end_qualifier_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.ColumnRange.end_qualifier_open)
}
inline ::std::string* ColumnRange::mutable_end_qualifier_open() {
  if (!has_end_qualifier_open()) {
    clear_end_qualifier();
    set_has_end_qualifier_open();
    end_qualifier_.end_qualifier_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.ColumnRange.end_qualifier_open)
  return end_qualifier_.end_qualifier_open_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ColumnRange::release_end_qualifier_open() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.ColumnRange.end_qualifier_open)
  if (has_end_qualifier_open()) {
    clear_has_end_qualifier();
    return end_qualifier_.end_qualifier_open_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void ColumnRange::set_allocated_end_qualifier_open(::std::string* end_qualifier_open) {
  if (!has_end_qualifier_open()) {
    end_qualifier_.end_qualifier_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_end_qualifier();
  if (end_qualifier_open != NULL) {
    set_has_end_qualifier_open();
    end_qualifier_.end_qualifier_open_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), end_qualifier_open);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.ColumnRange.end_qualifier_open)
}

inline bool ColumnRange::has_start_qualifier() const {
  return start_qualifier_case() != START_QUALIFIER_NOT_SET;
}
inline void ColumnRange::clear_has_start_qualifier() {
  _oneof_case_[0] = START_QUALIFIER_NOT_SET;
}
inline bool ColumnRange::has_end_qualifier() const {
  return end_qualifier_case() != END_QUALIFIER_NOT_SET;
}
inline void ColumnRange::clear_has_end_qualifier() {
  _oneof_case_[1] = END_QUALIFIER_NOT_SET;
}
inline ColumnRange::StartQualifierCase ColumnRange::start_qualifier_case() const {
  return ColumnRange::StartQualifierCase(_oneof_case_[0]);
}
inline ColumnRange::EndQualifierCase ColumnRange::end_qualifier_case() const {
  return ColumnRange::EndQualifierCase(_oneof_case_[1]);
}
// -------------------------------------------------------------------

// TimestampRange

// int64 start_timestamp_micros = 1;
inline void TimestampRange::clear_start_timestamp_micros() {
  start_timestamp_micros_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 TimestampRange::start_timestamp_micros() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.TimestampRange.start_timestamp_micros)
  return start_timestamp_micros_;
}
inline void TimestampRange::set_start_timestamp_micros(::google::protobuf::int64 value) {
  
  start_timestamp_micros_ = value;
  // @@protoc_insertion_point(field_set:google.bigtable.v2.TimestampRange.start_timestamp_micros)
}

// int64 end_timestamp_micros = 2;
inline void TimestampRange::clear_end_timestamp_micros() {
  end_timestamp_micros_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 TimestampRange::end_timestamp_micros() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.TimestampRange.end_timestamp_micros)
  return end_timestamp_micros_;
}
inline void TimestampRange::set_end_timestamp_micros(::google::protobuf::int64 value) {
  
  end_timestamp_micros_ = value;
  // @@protoc_insertion_point(field_set:google.bigtable.v2.TimestampRange.end_timestamp_micros)
}

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

// ValueRange

// bytes start_value_closed = 1;
inline bool ValueRange::has_start_value_closed() const {
  return start_value_case() == kStartValueClosed;
}
inline void ValueRange::set_has_start_value_closed() {
  _oneof_case_[0] = kStartValueClosed;
}
inline void ValueRange::clear_start_value_closed() {
  if (has_start_value_closed()) {
    start_value_.start_value_closed_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_start_value();
  }
}
inline const ::std::string& ValueRange::start_value_closed() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.ValueRange.start_value_closed)
  if (has_start_value_closed()) {
    return start_value_.start_value_closed_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void ValueRange::set_start_value_closed(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ValueRange.start_value_closed)
  if (!has_start_value_closed()) {
    clear_start_value();
    set_has_start_value_closed();
    start_value_.start_value_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_value_.start_value_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ValueRange.start_value_closed)
}
#if LANG_CXX11
inline void ValueRange::set_start_value_closed(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ValueRange.start_value_closed)
  if (!has_start_value_closed()) {
    clear_start_value();
    set_has_start_value_closed();
    start_value_.start_value_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_value_.start_value_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.ValueRange.start_value_closed)
}
#endif
inline void ValueRange::set_start_value_closed(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_start_value_closed()) {
    clear_start_value();
    set_has_start_value_closed();
    start_value_.start_value_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_value_.start_value_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.ValueRange.start_value_closed)
}
inline void ValueRange::set_start_value_closed(const void* value, size_t size) {
  if (!has_start_value_closed()) {
    clear_start_value();
    set_has_start_value_closed();
    start_value_.start_value_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_value_.start_value_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.ValueRange.start_value_closed)
}
inline ::std::string* ValueRange::mutable_start_value_closed() {
  if (!has_start_value_closed()) {
    clear_start_value();
    set_has_start_value_closed();
    start_value_.start_value_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.ValueRange.start_value_closed)
  return start_value_.start_value_closed_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ValueRange::release_start_value_closed() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.ValueRange.start_value_closed)
  if (has_start_value_closed()) {
    clear_has_start_value();
    return start_value_.start_value_closed_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void ValueRange::set_allocated_start_value_closed(::std::string* start_value_closed) {
  if (!has_start_value_closed()) {
    start_value_.start_value_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_start_value();
  if (start_value_closed != NULL) {
    set_has_start_value_closed();
    start_value_.start_value_closed_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), start_value_closed);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.ValueRange.start_value_closed)
}

// bytes start_value_open = 2;
inline bool ValueRange::has_start_value_open() const {
  return start_value_case() == kStartValueOpen;
}
inline void ValueRange::set_has_start_value_open() {
  _oneof_case_[0] = kStartValueOpen;
}
inline void ValueRange::clear_start_value_open() {
  if (has_start_value_open()) {
    start_value_.start_value_open_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_start_value();
  }
}
inline const ::std::string& ValueRange::start_value_open() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.ValueRange.start_value_open)
  if (has_start_value_open()) {
    return start_value_.start_value_open_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void ValueRange::set_start_value_open(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ValueRange.start_value_open)
  if (!has_start_value_open()) {
    clear_start_value();
    set_has_start_value_open();
    start_value_.start_value_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_value_.start_value_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ValueRange.start_value_open)
}
#if LANG_CXX11
inline void ValueRange::set_start_value_open(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ValueRange.start_value_open)
  if (!has_start_value_open()) {
    clear_start_value();
    set_has_start_value_open();
    start_value_.start_value_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_value_.start_value_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.ValueRange.start_value_open)
}
#endif
inline void ValueRange::set_start_value_open(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_start_value_open()) {
    clear_start_value();
    set_has_start_value_open();
    start_value_.start_value_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_value_.start_value_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.ValueRange.start_value_open)
}
inline void ValueRange::set_start_value_open(const void* value, size_t size) {
  if (!has_start_value_open()) {
    clear_start_value();
    set_has_start_value_open();
    start_value_.start_value_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  start_value_.start_value_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.ValueRange.start_value_open)
}
inline ::std::string* ValueRange::mutable_start_value_open() {
  if (!has_start_value_open()) {
    clear_start_value();
    set_has_start_value_open();
    start_value_.start_value_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.ValueRange.start_value_open)
  return start_value_.start_value_open_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ValueRange::release_start_value_open() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.ValueRange.start_value_open)
  if (has_start_value_open()) {
    clear_has_start_value();
    return start_value_.start_value_open_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void ValueRange::set_allocated_start_value_open(::std::string* start_value_open) {
  if (!has_start_value_open()) {
    start_value_.start_value_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_start_value();
  if (start_value_open != NULL) {
    set_has_start_value_open();
    start_value_.start_value_open_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), start_value_open);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.ValueRange.start_value_open)
}

// bytes end_value_closed = 3;
inline bool ValueRange::has_end_value_closed() const {
  return end_value_case() == kEndValueClosed;
}
inline void ValueRange::set_has_end_value_closed() {
  _oneof_case_[1] = kEndValueClosed;
}
inline void ValueRange::clear_end_value_closed() {
  if (has_end_value_closed()) {
    end_value_.end_value_closed_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_end_value();
  }
}
inline const ::std::string& ValueRange::end_value_closed() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.ValueRange.end_value_closed)
  if (has_end_value_closed()) {
    return end_value_.end_value_closed_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void ValueRange::set_end_value_closed(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ValueRange.end_value_closed)
  if (!has_end_value_closed()) {
    clear_end_value();
    set_has_end_value_closed();
    end_value_.end_value_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_value_.end_value_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ValueRange.end_value_closed)
}
#if LANG_CXX11
inline void ValueRange::set_end_value_closed(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ValueRange.end_value_closed)
  if (!has_end_value_closed()) {
    clear_end_value();
    set_has_end_value_closed();
    end_value_.end_value_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_value_.end_value_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.ValueRange.end_value_closed)
}
#endif
inline void ValueRange::set_end_value_closed(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_end_value_closed()) {
    clear_end_value();
    set_has_end_value_closed();
    end_value_.end_value_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_value_.end_value_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.ValueRange.end_value_closed)
}
inline void ValueRange::set_end_value_closed(const void* value, size_t size) {
  if (!has_end_value_closed()) {
    clear_end_value();
    set_has_end_value_closed();
    end_value_.end_value_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_value_.end_value_closed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.ValueRange.end_value_closed)
}
inline ::std::string* ValueRange::mutable_end_value_closed() {
  if (!has_end_value_closed()) {
    clear_end_value();
    set_has_end_value_closed();
    end_value_.end_value_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.ValueRange.end_value_closed)
  return end_value_.end_value_closed_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ValueRange::release_end_value_closed() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.ValueRange.end_value_closed)
  if (has_end_value_closed()) {
    clear_has_end_value();
    return end_value_.end_value_closed_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void ValueRange::set_allocated_end_value_closed(::std::string* end_value_closed) {
  if (!has_end_value_closed()) {
    end_value_.end_value_closed_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_end_value();
  if (end_value_closed != NULL) {
    set_has_end_value_closed();
    end_value_.end_value_closed_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), end_value_closed);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.ValueRange.end_value_closed)
}

// bytes end_value_open = 4;
inline bool ValueRange::has_end_value_open() const {
  return end_value_case() == kEndValueOpen;
}
inline void ValueRange::set_has_end_value_open() {
  _oneof_case_[1] = kEndValueOpen;
}
inline void ValueRange::clear_end_value_open() {
  if (has_end_value_open()) {
    end_value_.end_value_open_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_end_value();
  }
}
inline const ::std::string& ValueRange::end_value_open() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.ValueRange.end_value_open)
  if (has_end_value_open()) {
    return end_value_.end_value_open_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void ValueRange::set_end_value_open(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ValueRange.end_value_open)
  if (!has_end_value_open()) {
    clear_end_value();
    set_has_end_value_open();
    end_value_.end_value_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_value_.end_value_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ValueRange.end_value_open)
}
#if LANG_CXX11
inline void ValueRange::set_end_value_open(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ValueRange.end_value_open)
  if (!has_end_value_open()) {
    clear_end_value();
    set_has_end_value_open();
    end_value_.end_value_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_value_.end_value_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.ValueRange.end_value_open)
}
#endif
inline void ValueRange::set_end_value_open(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_end_value_open()) {
    clear_end_value();
    set_has_end_value_open();
    end_value_.end_value_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_value_.end_value_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.ValueRange.end_value_open)
}
inline void ValueRange::set_end_value_open(const void* value, size_t size) {
  if (!has_end_value_open()) {
    clear_end_value();
    set_has_end_value_open();
    end_value_.end_value_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  end_value_.end_value_open_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.ValueRange.end_value_open)
}
inline ::std::string* ValueRange::mutable_end_value_open() {
  if (!has_end_value_open()) {
    clear_end_value();
    set_has_end_value_open();
    end_value_.end_value_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.ValueRange.end_value_open)
  return end_value_.end_value_open_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ValueRange::release_end_value_open() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.ValueRange.end_value_open)
  if (has_end_value_open()) {
    clear_has_end_value();
    return end_value_.end_value_open_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void ValueRange::set_allocated_end_value_open(::std::string* end_value_open) {
  if (!has_end_value_open()) {
    end_value_.end_value_open_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_end_value();
  if (end_value_open != NULL) {
    set_has_end_value_open();
    end_value_.end_value_open_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), end_value_open);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.ValueRange.end_value_open)
}

inline bool ValueRange::has_start_value() const {
  return start_value_case() != START_VALUE_NOT_SET;
}
inline void ValueRange::clear_has_start_value() {
  _oneof_case_[0] = START_VALUE_NOT_SET;
}
inline bool ValueRange::has_end_value() const {
  return end_value_case() != END_VALUE_NOT_SET;
}
inline void ValueRange::clear_has_end_value() {
  _oneof_case_[1] = END_VALUE_NOT_SET;
}
inline ValueRange::StartValueCase ValueRange::start_value_case() const {
  return ValueRange::StartValueCase(_oneof_case_[0]);
}
inline ValueRange::EndValueCase ValueRange::end_value_case() const {
  return ValueRange::EndValueCase(_oneof_case_[1]);
}
// -------------------------------------------------------------------

// RowFilter_Chain

// repeated .google.bigtable.v2.RowFilter filters = 1;
inline int RowFilter_Chain::filters_size() const {
  return filters_.size();
}
inline void RowFilter_Chain::clear_filters() {
  filters_.Clear();
}
inline ::google::bigtable::v2::RowFilter* RowFilter_Chain::mutable_filters(int index) {
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.Chain.filters)
  return filters_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowFilter >*
RowFilter_Chain::mutable_filters() {
  // @@protoc_insertion_point(field_mutable_list:google.bigtable.v2.RowFilter.Chain.filters)
  return &filters_;
}
inline const ::google::bigtable::v2::RowFilter& RowFilter_Chain::filters(int index) const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.Chain.filters)
  return filters_.Get(index);
}
inline ::google::bigtable::v2::RowFilter* RowFilter_Chain::add_filters() {
  // @@protoc_insertion_point(field_add:google.bigtable.v2.RowFilter.Chain.filters)
  return filters_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowFilter >&
RowFilter_Chain::filters() const {
  // @@protoc_insertion_point(field_list:google.bigtable.v2.RowFilter.Chain.filters)
  return filters_;
}

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

// RowFilter_Interleave

// repeated .google.bigtable.v2.RowFilter filters = 1;
inline int RowFilter_Interleave::filters_size() const {
  return filters_.size();
}
inline void RowFilter_Interleave::clear_filters() {
  filters_.Clear();
}
inline ::google::bigtable::v2::RowFilter* RowFilter_Interleave::mutable_filters(int index) {
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.Interleave.filters)
  return filters_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowFilter >*
RowFilter_Interleave::mutable_filters() {
  // @@protoc_insertion_point(field_mutable_list:google.bigtable.v2.RowFilter.Interleave.filters)
  return &filters_;
}
inline const ::google::bigtable::v2::RowFilter& RowFilter_Interleave::filters(int index) const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.Interleave.filters)
  return filters_.Get(index);
}
inline ::google::bigtable::v2::RowFilter* RowFilter_Interleave::add_filters() {
  // @@protoc_insertion_point(field_add:google.bigtable.v2.RowFilter.Interleave.filters)
  return filters_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::google::bigtable::v2::RowFilter >&
RowFilter_Interleave::filters() const {
  // @@protoc_insertion_point(field_list:google.bigtable.v2.RowFilter.Interleave.filters)
  return filters_;
}

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

// RowFilter_Condition

// .google.bigtable.v2.RowFilter predicate_filter = 1;
inline bool RowFilter_Condition::has_predicate_filter() const {
  return this != internal_default_instance() && predicate_filter_ != NULL;
}
inline void RowFilter_Condition::clear_predicate_filter() {
  if (GetArenaNoVirtual() == NULL && predicate_filter_ != NULL) {
    delete predicate_filter_;
  }
  predicate_filter_ = NULL;
}
inline const ::google::bigtable::v2::RowFilter& RowFilter_Condition::_internal_predicate_filter() const {
  return *predicate_filter_;
}
inline const ::google::bigtable::v2::RowFilter& RowFilter_Condition::predicate_filter() const {
  const ::google::bigtable::v2::RowFilter* p = predicate_filter_;
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.Condition.predicate_filter)
  return p != NULL ? *p : *reinterpret_cast<const ::google::bigtable::v2::RowFilter*>(
      &::google::bigtable::v2::_RowFilter_default_instance_);
}
inline ::google::bigtable::v2::RowFilter* RowFilter_Condition::release_predicate_filter() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.Condition.predicate_filter)
  
  ::google::bigtable::v2::RowFilter* temp = predicate_filter_;
  predicate_filter_ = NULL;
  return temp;
}
inline ::google::bigtable::v2::RowFilter* RowFilter_Condition::mutable_predicate_filter() {
  
  if (predicate_filter_ == NULL) {
    auto* p = CreateMaybeMessage<::google::bigtable::v2::RowFilter>(GetArenaNoVirtual());
    predicate_filter_ = p;
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.Condition.predicate_filter)
  return predicate_filter_;
}
inline void RowFilter_Condition::set_allocated_predicate_filter(::google::bigtable::v2::RowFilter* predicate_filter) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete predicate_filter_;
  }
  if (predicate_filter) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      predicate_filter = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, predicate_filter, submessage_arena);
    }
    
  } else {
    
  }
  predicate_filter_ = predicate_filter;
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.RowFilter.Condition.predicate_filter)
}

// .google.bigtable.v2.RowFilter true_filter = 2;
inline bool RowFilter_Condition::has_true_filter() const {
  return this != internal_default_instance() && true_filter_ != NULL;
}
inline void RowFilter_Condition::clear_true_filter() {
  if (GetArenaNoVirtual() == NULL && true_filter_ != NULL) {
    delete true_filter_;
  }
  true_filter_ = NULL;
}
inline const ::google::bigtable::v2::RowFilter& RowFilter_Condition::_internal_true_filter() const {
  return *true_filter_;
}
inline const ::google::bigtable::v2::RowFilter& RowFilter_Condition::true_filter() const {
  const ::google::bigtable::v2::RowFilter* p = true_filter_;
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.Condition.true_filter)
  return p != NULL ? *p : *reinterpret_cast<const ::google::bigtable::v2::RowFilter*>(
      &::google::bigtable::v2::_RowFilter_default_instance_);
}
inline ::google::bigtable::v2::RowFilter* RowFilter_Condition::release_true_filter() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.Condition.true_filter)
  
  ::google::bigtable::v2::RowFilter* temp = true_filter_;
  true_filter_ = NULL;
  return temp;
}
inline ::google::bigtable::v2::RowFilter* RowFilter_Condition::mutable_true_filter() {
  
  if (true_filter_ == NULL) {
    auto* p = CreateMaybeMessage<::google::bigtable::v2::RowFilter>(GetArenaNoVirtual());
    true_filter_ = p;
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.Condition.true_filter)
  return true_filter_;
}
inline void RowFilter_Condition::set_allocated_true_filter(::google::bigtable::v2::RowFilter* true_filter) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete true_filter_;
  }
  if (true_filter) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      true_filter = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, true_filter, submessage_arena);
    }
    
  } else {
    
  }
  true_filter_ = true_filter;
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.RowFilter.Condition.true_filter)
}

// .google.bigtable.v2.RowFilter false_filter = 3;
inline bool RowFilter_Condition::has_false_filter() const {
  return this != internal_default_instance() && false_filter_ != NULL;
}
inline void RowFilter_Condition::clear_false_filter() {
  if (GetArenaNoVirtual() == NULL && false_filter_ != NULL) {
    delete false_filter_;
  }
  false_filter_ = NULL;
}
inline const ::google::bigtable::v2::RowFilter& RowFilter_Condition::_internal_false_filter() const {
  return *false_filter_;
}
inline const ::google::bigtable::v2::RowFilter& RowFilter_Condition::false_filter() const {
  const ::google::bigtable::v2::RowFilter* p = false_filter_;
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.Condition.false_filter)
  return p != NULL ? *p : *reinterpret_cast<const ::google::bigtable::v2::RowFilter*>(
      &::google::bigtable::v2::_RowFilter_default_instance_);
}
inline ::google::bigtable::v2::RowFilter* RowFilter_Condition::release_false_filter() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.Condition.false_filter)
  
  ::google::bigtable::v2::RowFilter* temp = false_filter_;
  false_filter_ = NULL;
  return temp;
}
inline ::google::bigtable::v2::RowFilter* RowFilter_Condition::mutable_false_filter() {
  
  if (false_filter_ == NULL) {
    auto* p = CreateMaybeMessage<::google::bigtable::v2::RowFilter>(GetArenaNoVirtual());
    false_filter_ = p;
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.Condition.false_filter)
  return false_filter_;
}
inline void RowFilter_Condition::set_allocated_false_filter(::google::bigtable::v2::RowFilter* false_filter) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete false_filter_;
  }
  if (false_filter) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      false_filter = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, false_filter, submessage_arena);
    }
    
  } else {
    
  }
  false_filter_ = false_filter;
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.RowFilter.Condition.false_filter)
}

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

// RowFilter

// .google.bigtable.v2.RowFilter.Chain chain = 1;
inline bool RowFilter::has_chain() const {
  return filter_case() == kChain;
}
inline void RowFilter::set_has_chain() {
  _oneof_case_[0] = kChain;
}
inline void RowFilter::clear_chain() {
  if (has_chain()) {
    delete filter_.chain_;
    clear_has_filter();
  }
}
inline const ::google::bigtable::v2::RowFilter_Chain& RowFilter::_internal_chain() const {
  return *filter_.chain_;
}
inline ::google::bigtable::v2::RowFilter_Chain* RowFilter::release_chain() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.chain)
  if (has_chain()) {
    clear_has_filter();
      ::google::bigtable::v2::RowFilter_Chain* temp = filter_.chain_;
    filter_.chain_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::google::bigtable::v2::RowFilter_Chain& RowFilter::chain() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.chain)
  return has_chain()
      ? *filter_.chain_
      : *reinterpret_cast< ::google::bigtable::v2::RowFilter_Chain*>(&::google::bigtable::v2::_RowFilter_Chain_default_instance_);
}
inline ::google::bigtable::v2::RowFilter_Chain* RowFilter::mutable_chain() {
  if (!has_chain()) {
    clear_filter();
    set_has_chain();
    filter_.chain_ = CreateMaybeMessage< ::google::bigtable::v2::RowFilter_Chain >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.chain)
  return filter_.chain_;
}

// .google.bigtable.v2.RowFilter.Interleave interleave = 2;
inline bool RowFilter::has_interleave() const {
  return filter_case() == kInterleave;
}
inline void RowFilter::set_has_interleave() {
  _oneof_case_[0] = kInterleave;
}
inline void RowFilter::clear_interleave() {
  if (has_interleave()) {
    delete filter_.interleave_;
    clear_has_filter();
  }
}
inline const ::google::bigtable::v2::RowFilter_Interleave& RowFilter::_internal_interleave() const {
  return *filter_.interleave_;
}
inline ::google::bigtable::v2::RowFilter_Interleave* RowFilter::release_interleave() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.interleave)
  if (has_interleave()) {
    clear_has_filter();
      ::google::bigtable::v2::RowFilter_Interleave* temp = filter_.interleave_;
    filter_.interleave_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::google::bigtable::v2::RowFilter_Interleave& RowFilter::interleave() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.interleave)
  return has_interleave()
      ? *filter_.interleave_
      : *reinterpret_cast< ::google::bigtable::v2::RowFilter_Interleave*>(&::google::bigtable::v2::_RowFilter_Interleave_default_instance_);
}
inline ::google::bigtable::v2::RowFilter_Interleave* RowFilter::mutable_interleave() {
  if (!has_interleave()) {
    clear_filter();
    set_has_interleave();
    filter_.interleave_ = CreateMaybeMessage< ::google::bigtable::v2::RowFilter_Interleave >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.interleave)
  return filter_.interleave_;
}

// .google.bigtable.v2.RowFilter.Condition condition = 3;
inline bool RowFilter::has_condition() const {
  return filter_case() == kCondition;
}
inline void RowFilter::set_has_condition() {
  _oneof_case_[0] = kCondition;
}
inline void RowFilter::clear_condition() {
  if (has_condition()) {
    delete filter_.condition_;
    clear_has_filter();
  }
}
inline const ::google::bigtable::v2::RowFilter_Condition& RowFilter::_internal_condition() const {
  return *filter_.condition_;
}
inline ::google::bigtable::v2::RowFilter_Condition* RowFilter::release_condition() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.condition)
  if (has_condition()) {
    clear_has_filter();
      ::google::bigtable::v2::RowFilter_Condition* temp = filter_.condition_;
    filter_.condition_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::google::bigtable::v2::RowFilter_Condition& RowFilter::condition() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.condition)
  return has_condition()
      ? *filter_.condition_
      : *reinterpret_cast< ::google::bigtable::v2::RowFilter_Condition*>(&::google::bigtable::v2::_RowFilter_Condition_default_instance_);
}
inline ::google::bigtable::v2::RowFilter_Condition* RowFilter::mutable_condition() {
  if (!has_condition()) {
    clear_filter();
    set_has_condition();
    filter_.condition_ = CreateMaybeMessage< ::google::bigtable::v2::RowFilter_Condition >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.condition)
  return filter_.condition_;
}

// bool sink = 16;
inline bool RowFilter::has_sink() const {
  return filter_case() == kSink;
}
inline void RowFilter::set_has_sink() {
  _oneof_case_[0] = kSink;
}
inline void RowFilter::clear_sink() {
  if (has_sink()) {
    filter_.sink_ = false;
    clear_has_filter();
  }
}
inline bool RowFilter::sink() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.sink)
  if (has_sink()) {
    return filter_.sink_;
  }
  return false;
}
inline void RowFilter::set_sink(bool value) {
  if (!has_sink()) {
    clear_filter();
    set_has_sink();
  }
  filter_.sink_ = value;
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.sink)
}

// bool pass_all_filter = 17;
inline bool RowFilter::has_pass_all_filter() const {
  return filter_case() == kPassAllFilter;
}
inline void RowFilter::set_has_pass_all_filter() {
  _oneof_case_[0] = kPassAllFilter;
}
inline void RowFilter::clear_pass_all_filter() {
  if (has_pass_all_filter()) {
    filter_.pass_all_filter_ = false;
    clear_has_filter();
  }
}
inline bool RowFilter::pass_all_filter() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.pass_all_filter)
  if (has_pass_all_filter()) {
    return filter_.pass_all_filter_;
  }
  return false;
}
inline void RowFilter::set_pass_all_filter(bool value) {
  if (!has_pass_all_filter()) {
    clear_filter();
    set_has_pass_all_filter();
  }
  filter_.pass_all_filter_ = value;
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.pass_all_filter)
}

// bool block_all_filter = 18;
inline bool RowFilter::has_block_all_filter() const {
  return filter_case() == kBlockAllFilter;
}
inline void RowFilter::set_has_block_all_filter() {
  _oneof_case_[0] = kBlockAllFilter;
}
inline void RowFilter::clear_block_all_filter() {
  if (has_block_all_filter()) {
    filter_.block_all_filter_ = false;
    clear_has_filter();
  }
}
inline bool RowFilter::block_all_filter() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.block_all_filter)
  if (has_block_all_filter()) {
    return filter_.block_all_filter_;
  }
  return false;
}
inline void RowFilter::set_block_all_filter(bool value) {
  if (!has_block_all_filter()) {
    clear_filter();
    set_has_block_all_filter();
  }
  filter_.block_all_filter_ = value;
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.block_all_filter)
}

// bytes row_key_regex_filter = 4;
inline bool RowFilter::has_row_key_regex_filter() const {
  return filter_case() == kRowKeyRegexFilter;
}
inline void RowFilter::set_has_row_key_regex_filter() {
  _oneof_case_[0] = kRowKeyRegexFilter;
}
inline void RowFilter::clear_row_key_regex_filter() {
  if (has_row_key_regex_filter()) {
    filter_.row_key_regex_filter_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_filter();
  }
}
inline const ::std::string& RowFilter::row_key_regex_filter() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.row_key_regex_filter)
  if (has_row_key_regex_filter()) {
    return filter_.row_key_regex_filter_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void RowFilter::set_row_key_regex_filter(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.row_key_regex_filter)
  if (!has_row_key_regex_filter()) {
    clear_filter();
    set_has_row_key_regex_filter();
    filter_.row_key_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.row_key_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.row_key_regex_filter)
}
#if LANG_CXX11
inline void RowFilter::set_row_key_regex_filter(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.row_key_regex_filter)
  if (!has_row_key_regex_filter()) {
    clear_filter();
    set_has_row_key_regex_filter();
    filter_.row_key_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.row_key_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.RowFilter.row_key_regex_filter)
}
#endif
inline void RowFilter::set_row_key_regex_filter(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_row_key_regex_filter()) {
    clear_filter();
    set_has_row_key_regex_filter();
    filter_.row_key_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.row_key_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.RowFilter.row_key_regex_filter)
}
inline void RowFilter::set_row_key_regex_filter(const void* value, size_t size) {
  if (!has_row_key_regex_filter()) {
    clear_filter();
    set_has_row_key_regex_filter();
    filter_.row_key_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.row_key_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.RowFilter.row_key_regex_filter)
}
inline ::std::string* RowFilter::mutable_row_key_regex_filter() {
  if (!has_row_key_regex_filter()) {
    clear_filter();
    set_has_row_key_regex_filter();
    filter_.row_key_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.row_key_regex_filter)
  return filter_.row_key_regex_filter_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RowFilter::release_row_key_regex_filter() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.row_key_regex_filter)
  if (has_row_key_regex_filter()) {
    clear_has_filter();
    return filter_.row_key_regex_filter_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void RowFilter::set_allocated_row_key_regex_filter(::std::string* row_key_regex_filter) {
  if (!has_row_key_regex_filter()) {
    filter_.row_key_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_filter();
  if (row_key_regex_filter != NULL) {
    set_has_row_key_regex_filter();
    filter_.row_key_regex_filter_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), row_key_regex_filter);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.RowFilter.row_key_regex_filter)
}

// double row_sample_filter = 14;
inline bool RowFilter::has_row_sample_filter() const {
  return filter_case() == kRowSampleFilter;
}
inline void RowFilter::set_has_row_sample_filter() {
  _oneof_case_[0] = kRowSampleFilter;
}
inline void RowFilter::clear_row_sample_filter() {
  if (has_row_sample_filter()) {
    filter_.row_sample_filter_ = 0;
    clear_has_filter();
  }
}
inline double RowFilter::row_sample_filter() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.row_sample_filter)
  if (has_row_sample_filter()) {
    return filter_.row_sample_filter_;
  }
  return 0;
}
inline void RowFilter::set_row_sample_filter(double value) {
  if (!has_row_sample_filter()) {
    clear_filter();
    set_has_row_sample_filter();
  }
  filter_.row_sample_filter_ = value;
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.row_sample_filter)
}

// string family_name_regex_filter = 5;
inline bool RowFilter::has_family_name_regex_filter() const {
  return filter_case() == kFamilyNameRegexFilter;
}
inline void RowFilter::set_has_family_name_regex_filter() {
  _oneof_case_[0] = kFamilyNameRegexFilter;
}
inline void RowFilter::clear_family_name_regex_filter() {
  if (has_family_name_regex_filter()) {
    filter_.family_name_regex_filter_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_filter();
  }
}
inline const ::std::string& RowFilter::family_name_regex_filter() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.family_name_regex_filter)
  if (has_family_name_regex_filter()) {
    return filter_.family_name_regex_filter_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void RowFilter::set_family_name_regex_filter(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.family_name_regex_filter)
  if (!has_family_name_regex_filter()) {
    clear_filter();
    set_has_family_name_regex_filter();
    filter_.family_name_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.family_name_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.family_name_regex_filter)
}
#if LANG_CXX11
inline void RowFilter::set_family_name_regex_filter(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.family_name_regex_filter)
  if (!has_family_name_regex_filter()) {
    clear_filter();
    set_has_family_name_regex_filter();
    filter_.family_name_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.family_name_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.RowFilter.family_name_regex_filter)
}
#endif
inline void RowFilter::set_family_name_regex_filter(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_family_name_regex_filter()) {
    clear_filter();
    set_has_family_name_regex_filter();
    filter_.family_name_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.family_name_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.RowFilter.family_name_regex_filter)
}
inline void RowFilter::set_family_name_regex_filter(const char* value, size_t size) {
  if (!has_family_name_regex_filter()) {
    clear_filter();
    set_has_family_name_regex_filter();
    filter_.family_name_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.family_name_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.RowFilter.family_name_regex_filter)
}
inline ::std::string* RowFilter::mutable_family_name_regex_filter() {
  if (!has_family_name_regex_filter()) {
    clear_filter();
    set_has_family_name_regex_filter();
    filter_.family_name_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.family_name_regex_filter)
  return filter_.family_name_regex_filter_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RowFilter::release_family_name_regex_filter() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.family_name_regex_filter)
  if (has_family_name_regex_filter()) {
    clear_has_filter();
    return filter_.family_name_regex_filter_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void RowFilter::set_allocated_family_name_regex_filter(::std::string* family_name_regex_filter) {
  if (!has_family_name_regex_filter()) {
    filter_.family_name_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_filter();
  if (family_name_regex_filter != NULL) {
    set_has_family_name_regex_filter();
    filter_.family_name_regex_filter_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), family_name_regex_filter);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.RowFilter.family_name_regex_filter)
}

// bytes column_qualifier_regex_filter = 6;
inline bool RowFilter::has_column_qualifier_regex_filter() const {
  return filter_case() == kColumnQualifierRegexFilter;
}
inline void RowFilter::set_has_column_qualifier_regex_filter() {
  _oneof_case_[0] = kColumnQualifierRegexFilter;
}
inline void RowFilter::clear_column_qualifier_regex_filter() {
  if (has_column_qualifier_regex_filter()) {
    filter_.column_qualifier_regex_filter_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_filter();
  }
}
inline const ::std::string& RowFilter::column_qualifier_regex_filter() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.column_qualifier_regex_filter)
  if (has_column_qualifier_regex_filter()) {
    return filter_.column_qualifier_regex_filter_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void RowFilter::set_column_qualifier_regex_filter(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.column_qualifier_regex_filter)
  if (!has_column_qualifier_regex_filter()) {
    clear_filter();
    set_has_column_qualifier_regex_filter();
    filter_.column_qualifier_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.column_qualifier_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.column_qualifier_regex_filter)
}
#if LANG_CXX11
inline void RowFilter::set_column_qualifier_regex_filter(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.column_qualifier_regex_filter)
  if (!has_column_qualifier_regex_filter()) {
    clear_filter();
    set_has_column_qualifier_regex_filter();
    filter_.column_qualifier_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.column_qualifier_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.RowFilter.column_qualifier_regex_filter)
}
#endif
inline void RowFilter::set_column_qualifier_regex_filter(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_column_qualifier_regex_filter()) {
    clear_filter();
    set_has_column_qualifier_regex_filter();
    filter_.column_qualifier_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.column_qualifier_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.RowFilter.column_qualifier_regex_filter)
}
inline void RowFilter::set_column_qualifier_regex_filter(const void* value, size_t size) {
  if (!has_column_qualifier_regex_filter()) {
    clear_filter();
    set_has_column_qualifier_regex_filter();
    filter_.column_qualifier_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.column_qualifier_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.RowFilter.column_qualifier_regex_filter)
}
inline ::std::string* RowFilter::mutable_column_qualifier_regex_filter() {
  if (!has_column_qualifier_regex_filter()) {
    clear_filter();
    set_has_column_qualifier_regex_filter();
    filter_.column_qualifier_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.column_qualifier_regex_filter)
  return filter_.column_qualifier_regex_filter_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RowFilter::release_column_qualifier_regex_filter() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.column_qualifier_regex_filter)
  if (has_column_qualifier_regex_filter()) {
    clear_has_filter();
    return filter_.column_qualifier_regex_filter_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void RowFilter::set_allocated_column_qualifier_regex_filter(::std::string* column_qualifier_regex_filter) {
  if (!has_column_qualifier_regex_filter()) {
    filter_.column_qualifier_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_filter();
  if (column_qualifier_regex_filter != NULL) {
    set_has_column_qualifier_regex_filter();
    filter_.column_qualifier_regex_filter_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), column_qualifier_regex_filter);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.RowFilter.column_qualifier_regex_filter)
}

// .google.bigtable.v2.ColumnRange column_range_filter = 7;
inline bool RowFilter::has_column_range_filter() const {
  return filter_case() == kColumnRangeFilter;
}
inline void RowFilter::set_has_column_range_filter() {
  _oneof_case_[0] = kColumnRangeFilter;
}
inline void RowFilter::clear_column_range_filter() {
  if (has_column_range_filter()) {
    delete filter_.column_range_filter_;
    clear_has_filter();
  }
}
inline const ::google::bigtable::v2::ColumnRange& RowFilter::_internal_column_range_filter() const {
  return *filter_.column_range_filter_;
}
inline ::google::bigtable::v2::ColumnRange* RowFilter::release_column_range_filter() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.column_range_filter)
  if (has_column_range_filter()) {
    clear_has_filter();
      ::google::bigtable::v2::ColumnRange* temp = filter_.column_range_filter_;
    filter_.column_range_filter_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::google::bigtable::v2::ColumnRange& RowFilter::column_range_filter() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.column_range_filter)
  return has_column_range_filter()
      ? *filter_.column_range_filter_
      : *reinterpret_cast< ::google::bigtable::v2::ColumnRange*>(&::google::bigtable::v2::_ColumnRange_default_instance_);
}
inline ::google::bigtable::v2::ColumnRange* RowFilter::mutable_column_range_filter() {
  if (!has_column_range_filter()) {
    clear_filter();
    set_has_column_range_filter();
    filter_.column_range_filter_ = CreateMaybeMessage< ::google::bigtable::v2::ColumnRange >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.column_range_filter)
  return filter_.column_range_filter_;
}

// .google.bigtable.v2.TimestampRange timestamp_range_filter = 8;
inline bool RowFilter::has_timestamp_range_filter() const {
  return filter_case() == kTimestampRangeFilter;
}
inline void RowFilter::set_has_timestamp_range_filter() {
  _oneof_case_[0] = kTimestampRangeFilter;
}
inline void RowFilter::clear_timestamp_range_filter() {
  if (has_timestamp_range_filter()) {
    delete filter_.timestamp_range_filter_;
    clear_has_filter();
  }
}
inline const ::google::bigtable::v2::TimestampRange& RowFilter::_internal_timestamp_range_filter() const {
  return *filter_.timestamp_range_filter_;
}
inline ::google::bigtable::v2::TimestampRange* RowFilter::release_timestamp_range_filter() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.timestamp_range_filter)
  if (has_timestamp_range_filter()) {
    clear_has_filter();
      ::google::bigtable::v2::TimestampRange* temp = filter_.timestamp_range_filter_;
    filter_.timestamp_range_filter_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::google::bigtable::v2::TimestampRange& RowFilter::timestamp_range_filter() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.timestamp_range_filter)
  return has_timestamp_range_filter()
      ? *filter_.timestamp_range_filter_
      : *reinterpret_cast< ::google::bigtable::v2::TimestampRange*>(&::google::bigtable::v2::_TimestampRange_default_instance_);
}
inline ::google::bigtable::v2::TimestampRange* RowFilter::mutable_timestamp_range_filter() {
  if (!has_timestamp_range_filter()) {
    clear_filter();
    set_has_timestamp_range_filter();
    filter_.timestamp_range_filter_ = CreateMaybeMessage< ::google::bigtable::v2::TimestampRange >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.timestamp_range_filter)
  return filter_.timestamp_range_filter_;
}

// bytes value_regex_filter = 9;
inline bool RowFilter::has_value_regex_filter() const {
  return filter_case() == kValueRegexFilter;
}
inline void RowFilter::set_has_value_regex_filter() {
  _oneof_case_[0] = kValueRegexFilter;
}
inline void RowFilter::clear_value_regex_filter() {
  if (has_value_regex_filter()) {
    filter_.value_regex_filter_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_filter();
  }
}
inline const ::std::string& RowFilter::value_regex_filter() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.value_regex_filter)
  if (has_value_regex_filter()) {
    return filter_.value_regex_filter_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void RowFilter::set_value_regex_filter(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.value_regex_filter)
  if (!has_value_regex_filter()) {
    clear_filter();
    set_has_value_regex_filter();
    filter_.value_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.value_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.value_regex_filter)
}
#if LANG_CXX11
inline void RowFilter::set_value_regex_filter(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.value_regex_filter)
  if (!has_value_regex_filter()) {
    clear_filter();
    set_has_value_regex_filter();
    filter_.value_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.value_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.RowFilter.value_regex_filter)
}
#endif
inline void RowFilter::set_value_regex_filter(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_value_regex_filter()) {
    clear_filter();
    set_has_value_regex_filter();
    filter_.value_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.value_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.RowFilter.value_regex_filter)
}
inline void RowFilter::set_value_regex_filter(const void* value, size_t size) {
  if (!has_value_regex_filter()) {
    clear_filter();
    set_has_value_regex_filter();
    filter_.value_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.value_regex_filter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.RowFilter.value_regex_filter)
}
inline ::std::string* RowFilter::mutable_value_regex_filter() {
  if (!has_value_regex_filter()) {
    clear_filter();
    set_has_value_regex_filter();
    filter_.value_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.value_regex_filter)
  return filter_.value_regex_filter_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RowFilter::release_value_regex_filter() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.value_regex_filter)
  if (has_value_regex_filter()) {
    clear_has_filter();
    return filter_.value_regex_filter_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void RowFilter::set_allocated_value_regex_filter(::std::string* value_regex_filter) {
  if (!has_value_regex_filter()) {
    filter_.value_regex_filter_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_filter();
  if (value_regex_filter != NULL) {
    set_has_value_regex_filter();
    filter_.value_regex_filter_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value_regex_filter);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.RowFilter.value_regex_filter)
}

// .google.bigtable.v2.ValueRange value_range_filter = 15;
inline bool RowFilter::has_value_range_filter() const {
  return filter_case() == kValueRangeFilter;
}
inline void RowFilter::set_has_value_range_filter() {
  _oneof_case_[0] = kValueRangeFilter;
}
inline void RowFilter::clear_value_range_filter() {
  if (has_value_range_filter()) {
    delete filter_.value_range_filter_;
    clear_has_filter();
  }
}
inline const ::google::bigtable::v2::ValueRange& RowFilter::_internal_value_range_filter() const {
  return *filter_.value_range_filter_;
}
inline ::google::bigtable::v2::ValueRange* RowFilter::release_value_range_filter() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.value_range_filter)
  if (has_value_range_filter()) {
    clear_has_filter();
      ::google::bigtable::v2::ValueRange* temp = filter_.value_range_filter_;
    filter_.value_range_filter_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::google::bigtable::v2::ValueRange& RowFilter::value_range_filter() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.value_range_filter)
  return has_value_range_filter()
      ? *filter_.value_range_filter_
      : *reinterpret_cast< ::google::bigtable::v2::ValueRange*>(&::google::bigtable::v2::_ValueRange_default_instance_);
}
inline ::google::bigtable::v2::ValueRange* RowFilter::mutable_value_range_filter() {
  if (!has_value_range_filter()) {
    clear_filter();
    set_has_value_range_filter();
    filter_.value_range_filter_ = CreateMaybeMessage< ::google::bigtable::v2::ValueRange >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.value_range_filter)
  return filter_.value_range_filter_;
}

// int32 cells_per_row_offset_filter = 10;
inline bool RowFilter::has_cells_per_row_offset_filter() const {
  return filter_case() == kCellsPerRowOffsetFilter;
}
inline void RowFilter::set_has_cells_per_row_offset_filter() {
  _oneof_case_[0] = kCellsPerRowOffsetFilter;
}
inline void RowFilter::clear_cells_per_row_offset_filter() {
  if (has_cells_per_row_offset_filter()) {
    filter_.cells_per_row_offset_filter_ = 0;
    clear_has_filter();
  }
}
inline ::google::protobuf::int32 RowFilter::cells_per_row_offset_filter() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.cells_per_row_offset_filter)
  if (has_cells_per_row_offset_filter()) {
    return filter_.cells_per_row_offset_filter_;
  }
  return 0;
}
inline void RowFilter::set_cells_per_row_offset_filter(::google::protobuf::int32 value) {
  if (!has_cells_per_row_offset_filter()) {
    clear_filter();
    set_has_cells_per_row_offset_filter();
  }
  filter_.cells_per_row_offset_filter_ = value;
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.cells_per_row_offset_filter)
}

// int32 cells_per_row_limit_filter = 11;
inline bool RowFilter::has_cells_per_row_limit_filter() const {
  return filter_case() == kCellsPerRowLimitFilter;
}
inline void RowFilter::set_has_cells_per_row_limit_filter() {
  _oneof_case_[0] = kCellsPerRowLimitFilter;
}
inline void RowFilter::clear_cells_per_row_limit_filter() {
  if (has_cells_per_row_limit_filter()) {
    filter_.cells_per_row_limit_filter_ = 0;
    clear_has_filter();
  }
}
inline ::google::protobuf::int32 RowFilter::cells_per_row_limit_filter() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.cells_per_row_limit_filter)
  if (has_cells_per_row_limit_filter()) {
    return filter_.cells_per_row_limit_filter_;
  }
  return 0;
}
inline void RowFilter::set_cells_per_row_limit_filter(::google::protobuf::int32 value) {
  if (!has_cells_per_row_limit_filter()) {
    clear_filter();
    set_has_cells_per_row_limit_filter();
  }
  filter_.cells_per_row_limit_filter_ = value;
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.cells_per_row_limit_filter)
}

// int32 cells_per_column_limit_filter = 12;
inline bool RowFilter::has_cells_per_column_limit_filter() const {
  return filter_case() == kCellsPerColumnLimitFilter;
}
inline void RowFilter::set_has_cells_per_column_limit_filter() {
  _oneof_case_[0] = kCellsPerColumnLimitFilter;
}
inline void RowFilter::clear_cells_per_column_limit_filter() {
  if (has_cells_per_column_limit_filter()) {
    filter_.cells_per_column_limit_filter_ = 0;
    clear_has_filter();
  }
}
inline ::google::protobuf::int32 RowFilter::cells_per_column_limit_filter() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.cells_per_column_limit_filter)
  if (has_cells_per_column_limit_filter()) {
    return filter_.cells_per_column_limit_filter_;
  }
  return 0;
}
inline void RowFilter::set_cells_per_column_limit_filter(::google::protobuf::int32 value) {
  if (!has_cells_per_column_limit_filter()) {
    clear_filter();
    set_has_cells_per_column_limit_filter();
  }
  filter_.cells_per_column_limit_filter_ = value;
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.cells_per_column_limit_filter)
}

// bool strip_value_transformer = 13;
inline bool RowFilter::has_strip_value_transformer() const {
  return filter_case() == kStripValueTransformer;
}
inline void RowFilter::set_has_strip_value_transformer() {
  _oneof_case_[0] = kStripValueTransformer;
}
inline void RowFilter::clear_strip_value_transformer() {
  if (has_strip_value_transformer()) {
    filter_.strip_value_transformer_ = false;
    clear_has_filter();
  }
}
inline bool RowFilter::strip_value_transformer() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.strip_value_transformer)
  if (has_strip_value_transformer()) {
    return filter_.strip_value_transformer_;
  }
  return false;
}
inline void RowFilter::set_strip_value_transformer(bool value) {
  if (!has_strip_value_transformer()) {
    clear_filter();
    set_has_strip_value_transformer();
  }
  filter_.strip_value_transformer_ = value;
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.strip_value_transformer)
}

// string apply_label_transformer = 19;
inline bool RowFilter::has_apply_label_transformer() const {
  return filter_case() == kApplyLabelTransformer;
}
inline void RowFilter::set_has_apply_label_transformer() {
  _oneof_case_[0] = kApplyLabelTransformer;
}
inline void RowFilter::clear_apply_label_transformer() {
  if (has_apply_label_transformer()) {
    filter_.apply_label_transformer_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_filter();
  }
}
inline const ::std::string& RowFilter::apply_label_transformer() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.RowFilter.apply_label_transformer)
  if (has_apply_label_transformer()) {
    return filter_.apply_label_transformer_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void RowFilter::set_apply_label_transformer(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.apply_label_transformer)
  if (!has_apply_label_transformer()) {
    clear_filter();
    set_has_apply_label_transformer();
    filter_.apply_label_transformer_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.apply_label_transformer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.apply_label_transformer)
}
#if LANG_CXX11
inline void RowFilter::set_apply_label_transformer(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.RowFilter.apply_label_transformer)
  if (!has_apply_label_transformer()) {
    clear_filter();
    set_has_apply_label_transformer();
    filter_.apply_label_transformer_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.apply_label_transformer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.RowFilter.apply_label_transformer)
}
#endif
inline void RowFilter::set_apply_label_transformer(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_apply_label_transformer()) {
    clear_filter();
    set_has_apply_label_transformer();
    filter_.apply_label_transformer_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.apply_label_transformer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.RowFilter.apply_label_transformer)
}
inline void RowFilter::set_apply_label_transformer(const char* value, size_t size) {
  if (!has_apply_label_transformer()) {
    clear_filter();
    set_has_apply_label_transformer();
    filter_.apply_label_transformer_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  filter_.apply_label_transformer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.RowFilter.apply_label_transformer)
}
inline ::std::string* RowFilter::mutable_apply_label_transformer() {
  if (!has_apply_label_transformer()) {
    clear_filter();
    set_has_apply_label_transformer();
    filter_.apply_label_transformer_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.RowFilter.apply_label_transformer)
  return filter_.apply_label_transformer_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RowFilter::release_apply_label_transformer() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.RowFilter.apply_label_transformer)
  if (has_apply_label_transformer()) {
    clear_has_filter();
    return filter_.apply_label_transformer_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void RowFilter::set_allocated_apply_label_transformer(::std::string* apply_label_transformer) {
  if (!has_apply_label_transformer()) {
    filter_.apply_label_transformer_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_filter();
  if (apply_label_transformer != NULL) {
    set_has_apply_label_transformer();
    filter_.apply_label_transformer_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), apply_label_transformer);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.RowFilter.apply_label_transformer)
}

inline bool RowFilter::has_filter() const {
  return filter_case() != FILTER_NOT_SET;
}
inline void RowFilter::clear_has_filter() {
  _oneof_case_[0] = FILTER_NOT_SET;
}
inline RowFilter::FilterCase RowFilter::filter_case() const {
  return RowFilter::FilterCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// Mutation_SetCell

// string family_name = 1;
inline void Mutation_SetCell::clear_family_name() {
  family_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Mutation_SetCell::family_name() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Mutation.SetCell.family_name)
  return family_name_.GetNoArena();
}
inline void Mutation_SetCell::set_family_name(const ::std::string& value) {
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Mutation.SetCell.family_name)
}
#if LANG_CXX11
inline void Mutation_SetCell::set_family_name(::std::string&& value) {
  
  family_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.Mutation.SetCell.family_name)
}
#endif
inline void Mutation_SetCell::set_family_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.Mutation.SetCell.family_name)
}
inline void Mutation_SetCell::set_family_name(const char* value, size_t size) {
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.Mutation.SetCell.family_name)
}
inline ::std::string* Mutation_SetCell::mutable_family_name() {
  
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Mutation.SetCell.family_name)
  return family_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Mutation_SetCell::release_family_name() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Mutation.SetCell.family_name)
  
  return family_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Mutation_SetCell::set_allocated_family_name(::std::string* family_name) {
  if (family_name != NULL) {
    
  } else {
    
  }
  family_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), family_name);
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.Mutation.SetCell.family_name)
}

// bytes column_qualifier = 2;
inline void Mutation_SetCell::clear_column_qualifier() {
  column_qualifier_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Mutation_SetCell::column_qualifier() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Mutation.SetCell.column_qualifier)
  return column_qualifier_.GetNoArena();
}
inline void Mutation_SetCell::set_column_qualifier(const ::std::string& value) {
  
  column_qualifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Mutation.SetCell.column_qualifier)
}
#if LANG_CXX11
inline void Mutation_SetCell::set_column_qualifier(::std::string&& value) {
  
  column_qualifier_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.Mutation.SetCell.column_qualifier)
}
#endif
inline void Mutation_SetCell::set_column_qualifier(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  column_qualifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.Mutation.SetCell.column_qualifier)
}
inline void Mutation_SetCell::set_column_qualifier(const void* value, size_t size) {
  
  column_qualifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.Mutation.SetCell.column_qualifier)
}
inline ::std::string* Mutation_SetCell::mutable_column_qualifier() {
  
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Mutation.SetCell.column_qualifier)
  return column_qualifier_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Mutation_SetCell::release_column_qualifier() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Mutation.SetCell.column_qualifier)
  
  return column_qualifier_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Mutation_SetCell::set_allocated_column_qualifier(::std::string* column_qualifier) {
  if (column_qualifier != NULL) {
    
  } else {
    
  }
  column_qualifier_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), column_qualifier);
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.Mutation.SetCell.column_qualifier)
}

// int64 timestamp_micros = 3;
inline void Mutation_SetCell::clear_timestamp_micros() {
  timestamp_micros_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 Mutation_SetCell::timestamp_micros() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Mutation.SetCell.timestamp_micros)
  return timestamp_micros_;
}
inline void Mutation_SetCell::set_timestamp_micros(::google::protobuf::int64 value) {
  
  timestamp_micros_ = value;
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Mutation.SetCell.timestamp_micros)
}

// bytes value = 4;
inline void Mutation_SetCell::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Mutation_SetCell::value() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Mutation.SetCell.value)
  return value_.GetNoArena();
}
inline void Mutation_SetCell::set_value(const ::std::string& value) {
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Mutation.SetCell.value)
}
#if LANG_CXX11
inline void Mutation_SetCell::set_value(::std::string&& value) {
  
  value_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.Mutation.SetCell.value)
}
#endif
inline void Mutation_SetCell::set_value(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.Mutation.SetCell.value)
}
inline void Mutation_SetCell::set_value(const void* value, size_t size) {
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.Mutation.SetCell.value)
}
inline ::std::string* Mutation_SetCell::mutable_value() {
  
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Mutation.SetCell.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Mutation_SetCell::release_value() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Mutation.SetCell.value)
  
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Mutation_SetCell::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    
  } else {
    
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.Mutation.SetCell.value)
}

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

// Mutation_DeleteFromColumn

// string family_name = 1;
inline void Mutation_DeleteFromColumn::clear_family_name() {
  family_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Mutation_DeleteFromColumn::family_name() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Mutation.DeleteFromColumn.family_name)
  return family_name_.GetNoArena();
}
inline void Mutation_DeleteFromColumn::set_family_name(const ::std::string& value) {
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Mutation.DeleteFromColumn.family_name)
}
#if LANG_CXX11
inline void Mutation_DeleteFromColumn::set_family_name(::std::string&& value) {
  
  family_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.Mutation.DeleteFromColumn.family_name)
}
#endif
inline void Mutation_DeleteFromColumn::set_family_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.Mutation.DeleteFromColumn.family_name)
}
inline void Mutation_DeleteFromColumn::set_family_name(const char* value, size_t size) {
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.Mutation.DeleteFromColumn.family_name)
}
inline ::std::string* Mutation_DeleteFromColumn::mutable_family_name() {
  
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Mutation.DeleteFromColumn.family_name)
  return family_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Mutation_DeleteFromColumn::release_family_name() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Mutation.DeleteFromColumn.family_name)
  
  return family_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Mutation_DeleteFromColumn::set_allocated_family_name(::std::string* family_name) {
  if (family_name != NULL) {
    
  } else {
    
  }
  family_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), family_name);
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.Mutation.DeleteFromColumn.family_name)
}

// bytes column_qualifier = 2;
inline void Mutation_DeleteFromColumn::clear_column_qualifier() {
  column_qualifier_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Mutation_DeleteFromColumn::column_qualifier() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Mutation.DeleteFromColumn.column_qualifier)
  return column_qualifier_.GetNoArena();
}
inline void Mutation_DeleteFromColumn::set_column_qualifier(const ::std::string& value) {
  
  column_qualifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Mutation.DeleteFromColumn.column_qualifier)
}
#if LANG_CXX11
inline void Mutation_DeleteFromColumn::set_column_qualifier(::std::string&& value) {
  
  column_qualifier_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.Mutation.DeleteFromColumn.column_qualifier)
}
#endif
inline void Mutation_DeleteFromColumn::set_column_qualifier(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  column_qualifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.Mutation.DeleteFromColumn.column_qualifier)
}
inline void Mutation_DeleteFromColumn::set_column_qualifier(const void* value, size_t size) {
  
  column_qualifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.Mutation.DeleteFromColumn.column_qualifier)
}
inline ::std::string* Mutation_DeleteFromColumn::mutable_column_qualifier() {
  
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Mutation.DeleteFromColumn.column_qualifier)
  return column_qualifier_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Mutation_DeleteFromColumn::release_column_qualifier() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Mutation.DeleteFromColumn.column_qualifier)
  
  return column_qualifier_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Mutation_DeleteFromColumn::set_allocated_column_qualifier(::std::string* column_qualifier) {
  if (column_qualifier != NULL) {
    
  } else {
    
  }
  column_qualifier_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), column_qualifier);
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.Mutation.DeleteFromColumn.column_qualifier)
}

// .google.bigtable.v2.TimestampRange time_range = 3;
inline bool Mutation_DeleteFromColumn::has_time_range() const {
  return this != internal_default_instance() && time_range_ != NULL;
}
inline void Mutation_DeleteFromColumn::clear_time_range() {
  if (GetArenaNoVirtual() == NULL && time_range_ != NULL) {
    delete time_range_;
  }
  time_range_ = NULL;
}
inline const ::google::bigtable::v2::TimestampRange& Mutation_DeleteFromColumn::_internal_time_range() const {
  return *time_range_;
}
inline const ::google::bigtable::v2::TimestampRange& Mutation_DeleteFromColumn::time_range() const {
  const ::google::bigtable::v2::TimestampRange* p = time_range_;
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Mutation.DeleteFromColumn.time_range)
  return p != NULL ? *p : *reinterpret_cast<const ::google::bigtable::v2::TimestampRange*>(
      &::google::bigtable::v2::_TimestampRange_default_instance_);
}
inline ::google::bigtable::v2::TimestampRange* Mutation_DeleteFromColumn::release_time_range() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Mutation.DeleteFromColumn.time_range)
  
  ::google::bigtable::v2::TimestampRange* temp = time_range_;
  time_range_ = NULL;
  return temp;
}
inline ::google::bigtable::v2::TimestampRange* Mutation_DeleteFromColumn::mutable_time_range() {
  
  if (time_range_ == NULL) {
    auto* p = CreateMaybeMessage<::google::bigtable::v2::TimestampRange>(GetArenaNoVirtual());
    time_range_ = p;
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Mutation.DeleteFromColumn.time_range)
  return time_range_;
}
inline void Mutation_DeleteFromColumn::set_allocated_time_range(::google::bigtable::v2::TimestampRange* time_range) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete time_range_;
  }
  if (time_range) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      time_range = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, time_range, submessage_arena);
    }
    
  } else {
    
  }
  time_range_ = time_range;
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.Mutation.DeleteFromColumn.time_range)
}

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

// Mutation_DeleteFromFamily

// string family_name = 1;
inline void Mutation_DeleteFromFamily::clear_family_name() {
  family_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Mutation_DeleteFromFamily::family_name() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Mutation.DeleteFromFamily.family_name)
  return family_name_.GetNoArena();
}
inline void Mutation_DeleteFromFamily::set_family_name(const ::std::string& value) {
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.Mutation.DeleteFromFamily.family_name)
}
#if LANG_CXX11
inline void Mutation_DeleteFromFamily::set_family_name(::std::string&& value) {
  
  family_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.Mutation.DeleteFromFamily.family_name)
}
#endif
inline void Mutation_DeleteFromFamily::set_family_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.Mutation.DeleteFromFamily.family_name)
}
inline void Mutation_DeleteFromFamily::set_family_name(const char* value, size_t size) {
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.Mutation.DeleteFromFamily.family_name)
}
inline ::std::string* Mutation_DeleteFromFamily::mutable_family_name() {
  
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Mutation.DeleteFromFamily.family_name)
  return family_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Mutation_DeleteFromFamily::release_family_name() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Mutation.DeleteFromFamily.family_name)
  
  return family_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Mutation_DeleteFromFamily::set_allocated_family_name(::std::string* family_name) {
  if (family_name != NULL) {
    
  } else {
    
  }
  family_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), family_name);
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.Mutation.DeleteFromFamily.family_name)
}

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

// Mutation_DeleteFromRow

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

// Mutation

// .google.bigtable.v2.Mutation.SetCell set_cell = 1;
inline bool Mutation::has_set_cell() const {
  return mutation_case() == kSetCell;
}
inline void Mutation::set_has_set_cell() {
  _oneof_case_[0] = kSetCell;
}
inline void Mutation::clear_set_cell() {
  if (has_set_cell()) {
    delete mutation_.set_cell_;
    clear_has_mutation();
  }
}
inline const ::google::bigtable::v2::Mutation_SetCell& Mutation::_internal_set_cell() const {
  return *mutation_.set_cell_;
}
inline ::google::bigtable::v2::Mutation_SetCell* Mutation::release_set_cell() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Mutation.set_cell)
  if (has_set_cell()) {
    clear_has_mutation();
      ::google::bigtable::v2::Mutation_SetCell* temp = mutation_.set_cell_;
    mutation_.set_cell_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::google::bigtable::v2::Mutation_SetCell& Mutation::set_cell() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Mutation.set_cell)
  return has_set_cell()
      ? *mutation_.set_cell_
      : *reinterpret_cast< ::google::bigtable::v2::Mutation_SetCell*>(&::google::bigtable::v2::_Mutation_SetCell_default_instance_);
}
inline ::google::bigtable::v2::Mutation_SetCell* Mutation::mutable_set_cell() {
  if (!has_set_cell()) {
    clear_mutation();
    set_has_set_cell();
    mutation_.set_cell_ = CreateMaybeMessage< ::google::bigtable::v2::Mutation_SetCell >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Mutation.set_cell)
  return mutation_.set_cell_;
}

// .google.bigtable.v2.Mutation.DeleteFromColumn delete_from_column = 2;
inline bool Mutation::has_delete_from_column() const {
  return mutation_case() == kDeleteFromColumn;
}
inline void Mutation::set_has_delete_from_column() {
  _oneof_case_[0] = kDeleteFromColumn;
}
inline void Mutation::clear_delete_from_column() {
  if (has_delete_from_column()) {
    delete mutation_.delete_from_column_;
    clear_has_mutation();
  }
}
inline const ::google::bigtable::v2::Mutation_DeleteFromColumn& Mutation::_internal_delete_from_column() const {
  return *mutation_.delete_from_column_;
}
inline ::google::bigtable::v2::Mutation_DeleteFromColumn* Mutation::release_delete_from_column() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Mutation.delete_from_column)
  if (has_delete_from_column()) {
    clear_has_mutation();
      ::google::bigtable::v2::Mutation_DeleteFromColumn* temp = mutation_.delete_from_column_;
    mutation_.delete_from_column_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::google::bigtable::v2::Mutation_DeleteFromColumn& Mutation::delete_from_column() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Mutation.delete_from_column)
  return has_delete_from_column()
      ? *mutation_.delete_from_column_
      : *reinterpret_cast< ::google::bigtable::v2::Mutation_DeleteFromColumn*>(&::google::bigtable::v2::_Mutation_DeleteFromColumn_default_instance_);
}
inline ::google::bigtable::v2::Mutation_DeleteFromColumn* Mutation::mutable_delete_from_column() {
  if (!has_delete_from_column()) {
    clear_mutation();
    set_has_delete_from_column();
    mutation_.delete_from_column_ = CreateMaybeMessage< ::google::bigtable::v2::Mutation_DeleteFromColumn >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Mutation.delete_from_column)
  return mutation_.delete_from_column_;
}

// .google.bigtable.v2.Mutation.DeleteFromFamily delete_from_family = 3;
inline bool Mutation::has_delete_from_family() const {
  return mutation_case() == kDeleteFromFamily;
}
inline void Mutation::set_has_delete_from_family() {
  _oneof_case_[0] = kDeleteFromFamily;
}
inline void Mutation::clear_delete_from_family() {
  if (has_delete_from_family()) {
    delete mutation_.delete_from_family_;
    clear_has_mutation();
  }
}
inline const ::google::bigtable::v2::Mutation_DeleteFromFamily& Mutation::_internal_delete_from_family() const {
  return *mutation_.delete_from_family_;
}
inline ::google::bigtable::v2::Mutation_DeleteFromFamily* Mutation::release_delete_from_family() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Mutation.delete_from_family)
  if (has_delete_from_family()) {
    clear_has_mutation();
      ::google::bigtable::v2::Mutation_DeleteFromFamily* temp = mutation_.delete_from_family_;
    mutation_.delete_from_family_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::google::bigtable::v2::Mutation_DeleteFromFamily& Mutation::delete_from_family() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Mutation.delete_from_family)
  return has_delete_from_family()
      ? *mutation_.delete_from_family_
      : *reinterpret_cast< ::google::bigtable::v2::Mutation_DeleteFromFamily*>(&::google::bigtable::v2::_Mutation_DeleteFromFamily_default_instance_);
}
inline ::google::bigtable::v2::Mutation_DeleteFromFamily* Mutation::mutable_delete_from_family() {
  if (!has_delete_from_family()) {
    clear_mutation();
    set_has_delete_from_family();
    mutation_.delete_from_family_ = CreateMaybeMessage< ::google::bigtable::v2::Mutation_DeleteFromFamily >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Mutation.delete_from_family)
  return mutation_.delete_from_family_;
}

// .google.bigtable.v2.Mutation.DeleteFromRow delete_from_row = 4;
inline bool Mutation::has_delete_from_row() const {
  return mutation_case() == kDeleteFromRow;
}
inline void Mutation::set_has_delete_from_row() {
  _oneof_case_[0] = kDeleteFromRow;
}
inline void Mutation::clear_delete_from_row() {
  if (has_delete_from_row()) {
    delete mutation_.delete_from_row_;
    clear_has_mutation();
  }
}
inline const ::google::bigtable::v2::Mutation_DeleteFromRow& Mutation::_internal_delete_from_row() const {
  return *mutation_.delete_from_row_;
}
inline ::google::bigtable::v2::Mutation_DeleteFromRow* Mutation::release_delete_from_row() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.Mutation.delete_from_row)
  if (has_delete_from_row()) {
    clear_has_mutation();
      ::google::bigtable::v2::Mutation_DeleteFromRow* temp = mutation_.delete_from_row_;
    mutation_.delete_from_row_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::google::bigtable::v2::Mutation_DeleteFromRow& Mutation::delete_from_row() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.Mutation.delete_from_row)
  return has_delete_from_row()
      ? *mutation_.delete_from_row_
      : *reinterpret_cast< ::google::bigtable::v2::Mutation_DeleteFromRow*>(&::google::bigtable::v2::_Mutation_DeleteFromRow_default_instance_);
}
inline ::google::bigtable::v2::Mutation_DeleteFromRow* Mutation::mutable_delete_from_row() {
  if (!has_delete_from_row()) {
    clear_mutation();
    set_has_delete_from_row();
    mutation_.delete_from_row_ = CreateMaybeMessage< ::google::bigtable::v2::Mutation_DeleteFromRow >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.Mutation.delete_from_row)
  return mutation_.delete_from_row_;
}

inline bool Mutation::has_mutation() const {
  return mutation_case() != MUTATION_NOT_SET;
}
inline void Mutation::clear_has_mutation() {
  _oneof_case_[0] = MUTATION_NOT_SET;
}
inline Mutation::MutationCase Mutation::mutation_case() const {
  return Mutation::MutationCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// ReadModifyWriteRule

// string family_name = 1;
inline void ReadModifyWriteRule::clear_family_name() {
  family_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ReadModifyWriteRule::family_name() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.ReadModifyWriteRule.family_name)
  return family_name_.GetNoArena();
}
inline void ReadModifyWriteRule::set_family_name(const ::std::string& value) {
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ReadModifyWriteRule.family_name)
}
#if LANG_CXX11
inline void ReadModifyWriteRule::set_family_name(::std::string&& value) {
  
  family_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.ReadModifyWriteRule.family_name)
}
#endif
inline void ReadModifyWriteRule::set_family_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.ReadModifyWriteRule.family_name)
}
inline void ReadModifyWriteRule::set_family_name(const char* value, size_t size) {
  
  family_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.ReadModifyWriteRule.family_name)
}
inline ::std::string* ReadModifyWriteRule::mutable_family_name() {
  
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.ReadModifyWriteRule.family_name)
  return family_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReadModifyWriteRule::release_family_name() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.ReadModifyWriteRule.family_name)
  
  return family_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadModifyWriteRule::set_allocated_family_name(::std::string* family_name) {
  if (family_name != NULL) {
    
  } else {
    
  }
  family_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), family_name);
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.ReadModifyWriteRule.family_name)
}

// bytes column_qualifier = 2;
inline void ReadModifyWriteRule::clear_column_qualifier() {
  column_qualifier_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ReadModifyWriteRule::column_qualifier() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.ReadModifyWriteRule.column_qualifier)
  return column_qualifier_.GetNoArena();
}
inline void ReadModifyWriteRule::set_column_qualifier(const ::std::string& value) {
  
  column_qualifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ReadModifyWriteRule.column_qualifier)
}
#if LANG_CXX11
inline void ReadModifyWriteRule::set_column_qualifier(::std::string&& value) {
  
  column_qualifier_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.ReadModifyWriteRule.column_qualifier)
}
#endif
inline void ReadModifyWriteRule::set_column_qualifier(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  column_qualifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.ReadModifyWriteRule.column_qualifier)
}
inline void ReadModifyWriteRule::set_column_qualifier(const void* value, size_t size) {
  
  column_qualifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.ReadModifyWriteRule.column_qualifier)
}
inline ::std::string* ReadModifyWriteRule::mutable_column_qualifier() {
  
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.ReadModifyWriteRule.column_qualifier)
  return column_qualifier_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReadModifyWriteRule::release_column_qualifier() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.ReadModifyWriteRule.column_qualifier)
  
  return column_qualifier_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReadModifyWriteRule::set_allocated_column_qualifier(::std::string* column_qualifier) {
  if (column_qualifier != NULL) {
    
  } else {
    
  }
  column_qualifier_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), column_qualifier);
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.ReadModifyWriteRule.column_qualifier)
}

// bytes append_value = 3;
inline bool ReadModifyWriteRule::has_append_value() const {
  return rule_case() == kAppendValue;
}
inline void ReadModifyWriteRule::set_has_append_value() {
  _oneof_case_[0] = kAppendValue;
}
inline void ReadModifyWriteRule::clear_append_value() {
  if (has_append_value()) {
    rule_.append_value_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_rule();
  }
}
inline const ::std::string& ReadModifyWriteRule::append_value() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.ReadModifyWriteRule.append_value)
  if (has_append_value()) {
    return rule_.append_value_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void ReadModifyWriteRule::set_append_value(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ReadModifyWriteRule.append_value)
  if (!has_append_value()) {
    clear_rule();
    set_has_append_value();
    rule_.append_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  rule_.append_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ReadModifyWriteRule.append_value)
}
#if LANG_CXX11
inline void ReadModifyWriteRule::set_append_value(::std::string&& value) {
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ReadModifyWriteRule.append_value)
  if (!has_append_value()) {
    clear_rule();
    set_has_append_value();
    rule_.append_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  rule_.append_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:google.bigtable.v2.ReadModifyWriteRule.append_value)
}
#endif
inline void ReadModifyWriteRule::set_append_value(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_append_value()) {
    clear_rule();
    set_has_append_value();
    rule_.append_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  rule_.append_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:google.bigtable.v2.ReadModifyWriteRule.append_value)
}
inline void ReadModifyWriteRule::set_append_value(const void* value, size_t size) {
  if (!has_append_value()) {
    clear_rule();
    set_has_append_value();
    rule_.append_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  rule_.append_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:google.bigtable.v2.ReadModifyWriteRule.append_value)
}
inline ::std::string* ReadModifyWriteRule::mutable_append_value() {
  if (!has_append_value()) {
    clear_rule();
    set_has_append_value();
    rule_.append_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:google.bigtable.v2.ReadModifyWriteRule.append_value)
  return rule_.append_value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReadModifyWriteRule::release_append_value() {
  // @@protoc_insertion_point(field_release:google.bigtable.v2.ReadModifyWriteRule.append_value)
  if (has_append_value()) {
    clear_has_rule();
    return rule_.append_value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void ReadModifyWriteRule::set_allocated_append_value(::std::string* append_value) {
  if (!has_append_value()) {
    rule_.append_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_rule();
  if (append_value != NULL) {
    set_has_append_value();
    rule_.append_value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), append_value);
  }
  // @@protoc_insertion_point(field_set_allocated:google.bigtable.v2.ReadModifyWriteRule.append_value)
}

// int64 increment_amount = 4;
inline bool ReadModifyWriteRule::has_increment_amount() const {
  return rule_case() == kIncrementAmount;
}
inline void ReadModifyWriteRule::set_has_increment_amount() {
  _oneof_case_[0] = kIncrementAmount;
}
inline void ReadModifyWriteRule::clear_increment_amount() {
  if (has_increment_amount()) {
    rule_.increment_amount_ = GOOGLE_LONGLONG(0);
    clear_has_rule();
  }
}
inline ::google::protobuf::int64 ReadModifyWriteRule::increment_amount() const {
  // @@protoc_insertion_point(field_get:google.bigtable.v2.ReadModifyWriteRule.increment_amount)
  if (has_increment_amount()) {
    return rule_.increment_amount_;
  }
  return GOOGLE_LONGLONG(0);
}
inline void ReadModifyWriteRule::set_increment_amount(::google::protobuf::int64 value) {
  if (!has_increment_amount()) {
    clear_rule();
    set_has_increment_amount();
  }
  rule_.increment_amount_ = value;
  // @@protoc_insertion_point(field_set:google.bigtable.v2.ReadModifyWriteRule.increment_amount)
}

inline bool ReadModifyWriteRule::has_rule() const {
  return rule_case() != RULE_NOT_SET;
}
inline void ReadModifyWriteRule::clear_has_rule() {
  _oneof_case_[0] = RULE_NOT_SET;
}
inline ReadModifyWriteRule::RuleCase ReadModifyWriteRule::rule_case() const {
  return ReadModifyWriteRule::RuleCase(_oneof_case_[0]);
}
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace v2
}  // namespace bigtable
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_google_2fbigtable_2fv2_2fdata_2eproto
