YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

// Generated by the protocol buffer compiler.  DO NOT EDIT!

// source: yb/common/redis_protocol.proto

#ifndef PROTOBUF_yb_2fcommon_2fredis_5fprotocol_2eproto__INCLUDED

#define PROTOBUF_yb_2fcommon_2fredis_5fprotocol_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 3005000

#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 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION

#error This file was generated by an older version of protoc which is

#error incompatible with your Protocol Buffer headers.  Please

#error regenerate this file with a newer version of protoc.

#endif

#include <google/protobuf/io/coded_stream.h>

#include <google/protobuf/arena.h>

#include <google/protobuf/arenastring.h>

#include <google/protobuf/generated_message_table_driven.h>

#include <google/protobuf/generated_message_util.h>

#include <google/protobuf/metadata.h>

#include <google/protobuf/message.h>

#include <google/protobuf/repeated_field.h>  // IWYU pragma: export

#include <google/protobuf/extension_set.h>  // IWYU pragma: export

#include <google/protobuf/generated_enum_reflection.h>

#include <google/protobuf/unknown_field_set.h>

// @@protoc_insertion_point(includes)

namespace protobuf_yb_2fcommon_2fredis_5fprotocol_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[31];

  static const ::google::protobuf::internal::FieldMetadata field_metadata[];

  static const ::google::protobuf::internal::SerializationTable serialization_table[];

  static const ::google::protobuf::uint32 offsets[];

};

void AddDescriptors();

void InitDefaultsRedisWriteRequestPBImpl();

void InitDefaultsRedisWriteRequestPB();

void InitDefaultsRedisReadRequestPBImpl();

void InitDefaultsRedisReadRequestPB();

void InitDefaultsRedisSubKeyRangePBImpl();

void InitDefaultsRedisSubKeyRangePB();

void InitDefaultsRedisIndexRangePBImpl();

void InitDefaultsRedisIndexRangePB();

void InitDefaultsRedisIndexBoundPBImpl();

void InitDefaultsRedisIndexBoundPB();

void InitDefaultsRedisSubKeyBoundPBImpl();

void InitDefaultsRedisSubKeyBoundPB();

void InitDefaultsRedisKeyValueSubKeyPBImpl();

void InitDefaultsRedisKeyValueSubKeyPB();

void InitDefaultsRedisKeyValuePBImpl();

void InitDefaultsRedisKeyValuePB();

void InitDefaultsSortedSetOptionsPBImpl();

void InitDefaultsSortedSetOptionsPB();

void InitDefaultsRedisSetRequestPBImpl();

void InitDefaultsRedisSetRequestPB();

void InitDefaultsRedisGetRequestPBImpl();

void InitDefaultsRedisGetRequestPB();

void InitDefaultsRedisCollectionGetRangeRequestPBImpl();

void InitDefaultsRedisCollectionGetRangeRequestPB();

void InitDefaultsRedisNoOpRequestPBImpl();

void InitDefaultsRedisNoOpRequestPB();

void InitDefaultsRedisSetTtlRequestPBImpl();

void InitDefaultsRedisSetTtlRequestPB();

void InitDefaultsRedisGetTtlRequestPBImpl();

void InitDefaultsRedisGetTtlRequestPB();

void InitDefaultsRedisKeysRequestPBImpl();

void InitDefaultsRedisKeysRequestPB();

void InitDefaultsRedisGetForRenameRequestPBImpl();

void InitDefaultsRedisGetForRenameRequestPB();

void InitDefaultsRedisGetSetRequestPBImpl();

void InitDefaultsRedisGetSetRequestPB();

void InitDefaultsRedisAppendRequestPBImpl();

void InitDefaultsRedisAppendRequestPB();

void InitDefaultsRedisStrLenRequestPBImpl();

void InitDefaultsRedisStrLenRequestPB();

void InitDefaultsRedisDelRequestPBImpl();

void InitDefaultsRedisDelRequestPB();

void InitDefaultsRedisExistsRequestPBImpl();

void InitDefaultsRedisExistsRequestPB();

void InitDefaultsRedisSetRangeRequestPBImpl();

void InitDefaultsRedisSetRangeRequestPB();

void InitDefaultsRedisGetRangeRequestPBImpl();

void InitDefaultsRedisGetRangeRequestPB();

void InitDefaultsRedisIncrRequestPBImpl();

void InitDefaultsRedisIncrRequestPB();

void InitDefaultsRedisPushRequestPBImpl();

void InitDefaultsRedisPushRequestPB();

void InitDefaultsRedisInsertRequestPBImpl();

void InitDefaultsRedisInsertRequestPB();

void InitDefaultsRedisPopRequestPBImpl();

void InitDefaultsRedisPopRequestPB();

void InitDefaultsRedisAddRequestPBImpl();

void InitDefaultsRedisAddRequestPB();

void InitDefaultsRedisResponsePBImpl();

void InitDefaultsRedisResponsePB();

void InitDefaultsRedisArrayPBImpl();

void InitDefaultsRedisArrayPB();

inline void InitDefaults() {

  InitDefaultsRedisWriteRequestPB();

  InitDefaultsRedisReadRequestPB();

  InitDefaultsRedisSubKeyRangePB();

  InitDefaultsRedisIndexRangePB();

  InitDefaultsRedisIndexBoundPB();

  InitDefaultsRedisSubKeyBoundPB();

  InitDefaultsRedisKeyValueSubKeyPB();

  InitDefaultsRedisKeyValuePB();

  InitDefaultsSortedSetOptionsPB();

  InitDefaultsRedisSetRequestPB();

  InitDefaultsRedisGetRequestPB();

  InitDefaultsRedisCollectionGetRangeRequestPB();

  InitDefaultsRedisNoOpRequestPB();

  InitDefaultsRedisSetTtlRequestPB();

  InitDefaultsRedisGetTtlRequestPB();

  InitDefaultsRedisKeysRequestPB();

  InitDefaultsRedisGetForRenameRequestPB();

  InitDefaultsRedisGetSetRequestPB();

  InitDefaultsRedisAppendRequestPB();

  InitDefaultsRedisStrLenRequestPB();

  InitDefaultsRedisDelRequestPB();

  InitDefaultsRedisExistsRequestPB();

  InitDefaultsRedisSetRangeRequestPB();

  InitDefaultsRedisGetRangeRequestPB();

  InitDefaultsRedisIncrRequestPB();

  InitDefaultsRedisPushRequestPB();

  InitDefaultsRedisInsertRequestPB();

  InitDefaultsRedisPopRequestPB();

  InitDefaultsRedisAddRequestPB();

  InitDefaultsRedisResponsePB();

  InitDefaultsRedisArrayPB();

}

}  // namespace protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto

namespace yb {

class RedisAddRequestPB;

class RedisAddRequestPBDefaultTypeInternal;

extern RedisAddRequestPBDefaultTypeInternal _RedisAddRequestPB_default_instance_;

class RedisAppendRequestPB;

class RedisAppendRequestPBDefaultTypeInternal;

extern RedisAppendRequestPBDefaultTypeInternal _RedisAppendRequestPB_default_instance_;

class RedisArrayPB;

class RedisArrayPBDefaultTypeInternal;

extern RedisArrayPBDefaultTypeInternal _RedisArrayPB_default_instance_;

class RedisCollectionGetRangeRequestPB;

class RedisCollectionGetRangeRequestPBDefaultTypeInternal;

extern RedisCollectionGetRangeRequestPBDefaultTypeInternal _RedisCollectionGetRangeRequestPB_default_instance_;

class RedisDelRequestPB;

class RedisDelRequestPBDefaultTypeInternal;

extern RedisDelRequestPBDefaultTypeInternal _RedisDelRequestPB_default_instance_;

class RedisExistsRequestPB;

class RedisExistsRequestPBDefaultTypeInternal;

extern RedisExistsRequestPBDefaultTypeInternal _RedisExistsRequestPB_default_instance_;

class RedisGetForRenameRequestPB;

class RedisGetForRenameRequestPBDefaultTypeInternal;

extern RedisGetForRenameRequestPBDefaultTypeInternal _RedisGetForRenameRequestPB_default_instance_;

class RedisGetRangeRequestPB;

class RedisGetRangeRequestPBDefaultTypeInternal;

extern RedisGetRangeRequestPBDefaultTypeInternal _RedisGetRangeRequestPB_default_instance_;

class RedisGetRequestPB;

class RedisGetRequestPBDefaultTypeInternal;

extern RedisGetRequestPBDefaultTypeInternal _RedisGetRequestPB_default_instance_;

class RedisGetSetRequestPB;

class RedisGetSetRequestPBDefaultTypeInternal;

extern RedisGetSetRequestPBDefaultTypeInternal _RedisGetSetRequestPB_default_instance_;

class RedisGetTtlRequestPB;

class RedisGetTtlRequestPBDefaultTypeInternal;

extern RedisGetTtlRequestPBDefaultTypeInternal _RedisGetTtlRequestPB_default_instance_;

class RedisIncrRequestPB;

class RedisIncrRequestPBDefaultTypeInternal;

extern RedisIncrRequestPBDefaultTypeInternal _RedisIncrRequestPB_default_instance_;

class RedisIndexBoundPB;

class RedisIndexBoundPBDefaultTypeInternal;

extern RedisIndexBoundPBDefaultTypeInternal _RedisIndexBoundPB_default_instance_;

class RedisIndexRangePB;

class RedisIndexRangePBDefaultTypeInternal;

extern RedisIndexRangePBDefaultTypeInternal _RedisIndexRangePB_default_instance_;

class RedisInsertRequestPB;

class RedisInsertRequestPBDefaultTypeInternal;

extern RedisInsertRequestPBDefaultTypeInternal _RedisInsertRequestPB_default_instance_;

class RedisKeyValuePB;

class RedisKeyValuePBDefaultTypeInternal;

extern RedisKeyValuePBDefaultTypeInternal _RedisKeyValuePB_default_instance_;

class RedisKeyValueSubKeyPB;

class RedisKeyValueSubKeyPBDefaultTypeInternal;

extern RedisKeyValueSubKeyPBDefaultTypeInternal _RedisKeyValueSubKeyPB_default_instance_;

class RedisKeysRequestPB;

class RedisKeysRequestPBDefaultTypeInternal;

extern RedisKeysRequestPBDefaultTypeInternal _RedisKeysRequestPB_default_instance_;

class RedisNoOpRequestPB;

class RedisNoOpRequestPBDefaultTypeInternal;

extern RedisNoOpRequestPBDefaultTypeInternal _RedisNoOpRequestPB_default_instance_;

class RedisPopRequestPB;

class RedisPopRequestPBDefaultTypeInternal;

extern RedisPopRequestPBDefaultTypeInternal _RedisPopRequestPB_default_instance_;

class RedisPushRequestPB;

class RedisPushRequestPBDefaultTypeInternal;

extern RedisPushRequestPBDefaultTypeInternal _RedisPushRequestPB_default_instance_;

class RedisReadRequestPB;

class RedisReadRequestPBDefaultTypeInternal;

extern RedisReadRequestPBDefaultTypeInternal _RedisReadRequestPB_default_instance_;

class RedisResponsePB;

class RedisResponsePBDefaultTypeInternal;

extern RedisResponsePBDefaultTypeInternal _RedisResponsePB_default_instance_;

class RedisSetRangeRequestPB;

class RedisSetRangeRequestPBDefaultTypeInternal;

extern RedisSetRangeRequestPBDefaultTypeInternal _RedisSetRangeRequestPB_default_instance_;

class RedisSetRequestPB;

class RedisSetRequestPBDefaultTypeInternal;

extern RedisSetRequestPBDefaultTypeInternal _RedisSetRequestPB_default_instance_;

class RedisSetTtlRequestPB;

class RedisSetTtlRequestPBDefaultTypeInternal;

extern RedisSetTtlRequestPBDefaultTypeInternal _RedisSetTtlRequestPB_default_instance_;

class RedisStrLenRequestPB;

class RedisStrLenRequestPBDefaultTypeInternal;

extern RedisStrLenRequestPBDefaultTypeInternal _RedisStrLenRequestPB_default_instance_;

class RedisSubKeyBoundPB;

class RedisSubKeyBoundPBDefaultTypeInternal;

extern RedisSubKeyBoundPBDefaultTypeInternal _RedisSubKeyBoundPB_default_instance_;

class RedisSubKeyRangePB;

class RedisSubKeyRangePBDefaultTypeInternal;

extern RedisSubKeyRangePBDefaultTypeInternal _RedisSubKeyRangePB_default_instance_;

class RedisWriteRequestPB;

class RedisWriteRequestPBDefaultTypeInternal;

extern RedisWriteRequestPBDefaultTypeInternal _RedisWriteRequestPB_default_instance_;

class SortedSetOptionsPB;

class SortedSetOptionsPBDefaultTypeInternal;

extern SortedSetOptionsPBDefaultTypeInternal _SortedSetOptionsPB_default_instance_;

}  // namespace yb

namespace yb {

enum RedisSubKeyBoundPB_InfinityType {

  RedisSubKeyBoundPB_InfinityType_POSITIVE = 1,

  RedisSubKeyBoundPB_InfinityType_NEGATIVE = 2

};

bool RedisSubKeyBoundPB_InfinityType_IsValid(int value);

const RedisSubKeyBoundPB_InfinityType RedisSubKeyBoundPB_InfinityType_InfinityType_MIN = RedisSubKeyBoundPB_InfinityType_POSITIVE;

const RedisSubKeyBoundPB_InfinityType RedisSubKeyBoundPB_InfinityType_InfinityType_MAX = RedisSubKeyBoundPB_InfinityType_NEGATIVE;

const int RedisSubKeyBoundPB_InfinityType_InfinityType_ARRAYSIZE = RedisSubKeyBoundPB_InfinityType_InfinityType_MAX + 1;

const ::google::protobuf::EnumDescriptor* RedisSubKeyBoundPB_InfinityType_descriptor();

inline const ::std::string& RedisSubKeyBoundPB_InfinityType_Name(RedisSubKeyBoundPB_InfinityType value) {

  return ::google::protobuf::internal::NameOfEnum(

    RedisSubKeyBoundPB_InfinityType_descriptor(), value);

}

inline bool RedisSubKeyBoundPB_InfinityType_Parse(

    const ::std::string& name, RedisSubKeyBoundPB_InfinityType* value) {

  return ::google::protobuf::internal::ParseNamedEnum<RedisSubKeyBoundPB_InfinityType>(

    RedisSubKeyBoundPB_InfinityType_descriptor(), name, value);

}

enum SortedSetOptionsPB_UpdateOptions {

  SortedSetOptionsPB_UpdateOptions_NX = 1,

  SortedSetOptionsPB_UpdateOptions_XX = 2,

  SortedSetOptionsPB_UpdateOptions_NONE = 3

};

bool SortedSetOptionsPB_UpdateOptions_IsValid(int value);

const SortedSetOptionsPB_UpdateOptions SortedSetOptionsPB_UpdateOptions_UpdateOptions_MIN = SortedSetOptionsPB_UpdateOptions_NX;

const SortedSetOptionsPB_UpdateOptions SortedSetOptionsPB_UpdateOptions_UpdateOptions_MAX = SortedSetOptionsPB_UpdateOptions_NONE;

const int SortedSetOptionsPB_UpdateOptions_UpdateOptions_ARRAYSIZE = SortedSetOptionsPB_UpdateOptions_UpdateOptions_MAX + 1;

const ::google::protobuf::EnumDescriptor* SortedSetOptionsPB_UpdateOptions_descriptor();

inline const ::std::string& SortedSetOptionsPB_UpdateOptions_Name(SortedSetOptionsPB_UpdateOptions value) {

  return ::google::protobuf::internal::NameOfEnum(

    SortedSetOptionsPB_UpdateOptions_descriptor(), value);

}

inline bool SortedSetOptionsPB_UpdateOptions_Parse(

    const ::std::string& name, SortedSetOptionsPB_UpdateOptions* value) {

  return ::google::protobuf::internal::ParseNamedEnum<SortedSetOptionsPB_UpdateOptions>(

    SortedSetOptionsPB_UpdateOptions_descriptor(), name, value);

}

enum RedisGetRequestPB_GetRequestType {

  RedisGetRequestPB_GetRequestType_GET = 1,

  RedisGetRequestPB_GetRequestType_MGET = 3,

  RedisGetRequestPB_GetRequestType_HGET = 2,

  RedisGetRequestPB_GetRequestType_HMGET = 4,

  RedisGetRequestPB_GetRequestType_HGETALL = 5,

  RedisGetRequestPB_GetRequestType_HKEYS = 7,

  RedisGetRequestPB_GetRequestType_HVALS = 8,

  RedisGetRequestPB_GetRequestType_HLEN = 9,

  RedisGetRequestPB_GetRequestType_HEXISTS = 10,

  RedisGetRequestPB_GetRequestType_HSTRLEN = 11,

  RedisGetRequestPB_GetRequestType_SMEMBERS = 6,

  RedisGetRequestPB_GetRequestType_SISMEMBER = 12,

  RedisGetRequestPB_GetRequestType_SCARD = 13,

  RedisGetRequestPB_GetRequestType_ZCARD = 15,

  RedisGetRequestPB_GetRequestType_TSGET = 14,

  RedisGetRequestPB_GetRequestType_TSCARD = 16,

  RedisGetRequestPB_GetRequestType_ZSCORE = 17,

  RedisGetRequestPB_GetRequestType_LLEN = 18,

  RedisGetRequestPB_GetRequestType_UNKNOWN = 99

};

bool RedisGetRequestPB_GetRequestType_IsValid(int value);

const RedisGetRequestPB_GetRequestType RedisGetRequestPB_GetRequestType_GetRequestType_MIN = RedisGetRequestPB_GetRequestType_GET;

const RedisGetRequestPB_GetRequestType RedisGetRequestPB_GetRequestType_GetRequestType_MAX = RedisGetRequestPB_GetRequestType_UNKNOWN;

const int RedisGetRequestPB_GetRequestType_GetRequestType_ARRAYSIZE = RedisGetRequestPB_GetRequestType_GetRequestType_MAX + 1;

const ::google::protobuf::EnumDescriptor* RedisGetRequestPB_GetRequestType_descriptor();

inline const ::std::string& RedisGetRequestPB_GetRequestType_Name(RedisGetRequestPB_GetRequestType value) {

  return ::google::protobuf::internal::NameOfEnum(

    RedisGetRequestPB_GetRequestType_descriptor(), value);

}

inline bool RedisGetRequestPB_GetRequestType_Parse(

    const ::std::string& name, RedisGetRequestPB_GetRequestType* value) {

  return ::google::protobuf::internal::ParseNamedEnum<RedisGetRequestPB_GetRequestType>(

    RedisGetRequestPB_GetRequestType_descriptor(), name, value);

}

enum RedisCollectionGetRangeRequestPB_GetRangeRequestType {

  RedisCollectionGetRangeRequestPB_GetRangeRequestType_TSRANGEBYTIME = 1,

  RedisCollectionGetRangeRequestPB_GetRangeRequestType_ZRANGEBYSCORE = 2,

  RedisCollectionGetRangeRequestPB_GetRangeRequestType_ZREVRANGE = 3,

  RedisCollectionGetRangeRequestPB_GetRangeRequestType_ZRANGE = 4,

  RedisCollectionGetRangeRequestPB_GetRangeRequestType_TSREVRANGEBYTIME = 5,

  RedisCollectionGetRangeRequestPB_GetRangeRequestType_UNKNOWN = 99

};

bool RedisCollectionGetRangeRequestPB_GetRangeRequestType_IsValid(int value);

const RedisCollectionGetRangeRequestPB_GetRangeRequestType RedisCollectionGetRangeRequestPB_GetRangeRequestType_GetRangeRequestType_MIN = RedisCollectionGetRangeRequestPB_GetRangeRequestType_TSRANGEBYTIME;

const RedisCollectionGetRangeRequestPB_GetRangeRequestType RedisCollectionGetRangeRequestPB_GetRangeRequestType_GetRangeRequestType_MAX = RedisCollectionGetRangeRequestPB_GetRangeRequestType_UNKNOWN;

const int RedisCollectionGetRangeRequestPB_GetRangeRequestType_GetRangeRequestType_ARRAYSIZE = RedisCollectionGetRangeRequestPB_GetRangeRequestType_GetRangeRequestType_MAX + 1;

const ::google::protobuf::EnumDescriptor* RedisCollectionGetRangeRequestPB_GetRangeRequestType_descriptor();

inline const ::std::string& RedisCollectionGetRangeRequestPB_GetRangeRequestType_Name(RedisCollectionGetRangeRequestPB_GetRangeRequestType value) {

  return ::google::protobuf::internal::NameOfEnum(

    RedisCollectionGetRangeRequestPB_GetRangeRequestType_descriptor(), value);

}

inline bool RedisCollectionGetRangeRequestPB_GetRangeRequestType_Parse(

    const ::std::string& name, RedisCollectionGetRangeRequestPB_GetRangeRequestType* value) {

  return ::google::protobuf::internal::ParseNamedEnum<RedisCollectionGetRangeRequestPB_GetRangeRequestType>(

    RedisCollectionGetRangeRequestPB_GetRangeRequestType_descriptor(), name, value);

}

enum RedisResponsePB_RedisStatusCode {

  RedisResponsePB_RedisStatusCode_OK = 1,

  RedisResponsePB_RedisStatusCode_NIL = 2,

  RedisResponsePB_RedisStatusCode_NOT_FOUND = 5,

  RedisResponsePB_RedisStatusCode_UNKNOWN_COMMAND = 3,

  RedisResponsePB_RedisStatusCode_WRONG_TYPE = 4,

  RedisResponsePB_RedisStatusCode_SERVER_ERROR = 6,

  RedisResponsePB_RedisStatusCode_INDEX_OUT_OF_BOUNDS = 7,

  RedisResponsePB_RedisStatusCode_PARSING_ERROR = 8

};

bool RedisResponsePB_RedisStatusCode_IsValid(int value);

const RedisResponsePB_RedisStatusCode RedisResponsePB_RedisStatusCode_RedisStatusCode_MIN = RedisResponsePB_RedisStatusCode_OK;

const RedisResponsePB_RedisStatusCode RedisResponsePB_RedisStatusCode_RedisStatusCode_MAX = RedisResponsePB_RedisStatusCode_PARSING_ERROR;

const int RedisResponsePB_RedisStatusCode_RedisStatusCode_ARRAYSIZE = RedisResponsePB_RedisStatusCode_RedisStatusCode_MAX + 1;

const ::google::protobuf::EnumDescriptor* RedisResponsePB_RedisStatusCode_descriptor();

inline const ::std::string& RedisResponsePB_RedisStatusCode_Name(RedisResponsePB_RedisStatusCode value) {

  return ::google::protobuf::internal::NameOfEnum(

    RedisResponsePB_RedisStatusCode_descriptor(), value);

}

inline bool RedisResponsePB_RedisStatusCode_Parse(

    const ::std::string& name, RedisResponsePB_RedisStatusCode* value) {

  return ::google::protobuf::internal::ParseNamedEnum<RedisResponsePB_RedisStatusCode>(

    RedisResponsePB_RedisStatusCode_descriptor(), name, value);

}

enum RedisDataType {

  REDIS_TYPE_NONE = 1,

  REDIS_TYPE_STRING = 2,

  REDIS_TYPE_LIST = 3,

  REDIS_TYPE_SET = 4,

  REDIS_TYPE_HASH = 5,

  REDIS_TYPE_SORTEDSET = 6,

  REDIS_TYPE_TIMESERIES = 7

};

bool RedisDataType_IsValid(int value);

const RedisDataType RedisDataType_MIN = REDIS_TYPE_NONE;

const RedisDataType RedisDataType_MAX = REDIS_TYPE_TIMESERIES;

const int RedisDataType_ARRAYSIZE = RedisDataType_MAX + 1;

const ::google::protobuf::EnumDescriptor* RedisDataType_descriptor();

inline const ::std::string& RedisDataType_Name(RedisDataType value) {

  return ::google::protobuf::internal::NameOfEnum(

    RedisDataType_descriptor(), value);

}

inline bool RedisDataType_Parse(

    const ::std::string& name, RedisDataType* value) {

  return ::google::protobuf::internal::ParseNamedEnum<RedisDataType>(

    RedisDataType_descriptor(), name, value);

}

enum RedisSide {

  REDIS_SIDE_LEFT = 1,

  REDIS_SIDE_RIGHT = 2

};

bool RedisSide_IsValid(int value);

const RedisSide RedisSide_MIN = REDIS_SIDE_LEFT;

const RedisSide RedisSide_MAX = REDIS_SIDE_RIGHT;

const int RedisSide_ARRAYSIZE = RedisSide_MAX + 1;

const ::google::protobuf::EnumDescriptor* RedisSide_descriptor();

inline const ::std::string& RedisSide_Name(RedisSide value) {

  return ::google::protobuf::internal::NameOfEnum(

    RedisSide_descriptor(), value);

}

inline bool RedisSide_Parse(

    const ::std::string& name, RedisSide* value) {

  return ::google::protobuf::internal::ParseNamedEnum<RedisSide>(

    RedisSide_descriptor(), name, value);

}

enum RedisOrder {

  REDIS_ORDER_BEFORE = 1,

  REDIS_ORDER_AFTER = 2

};

bool RedisOrder_IsValid(int value);

const RedisOrder RedisOrder_MIN = REDIS_ORDER_BEFORE;

const RedisOrder RedisOrder_MAX = REDIS_ORDER_AFTER;

const int RedisOrder_ARRAYSIZE = RedisOrder_MAX + 1;

const ::google::protobuf::EnumDescriptor* RedisOrder_descriptor();

inline const ::std::string& RedisOrder_Name(RedisOrder value) {

  return ::google::protobuf::internal::NameOfEnum(

    RedisOrder_descriptor(), value);

}

inline bool RedisOrder_Parse(

    const ::std::string& name, RedisOrder* value) {

  return ::google::protobuf::internal::ParseNamedEnum<RedisOrder>(

    RedisOrder_descriptor(), name, value);

}

enum RedisWriteMode {

  REDIS_WRITEMODE_UPSERT = 1,

  REDIS_WRITEMODE_INSERT = 2,

  REDIS_WRITEMODE_UPDATE = 3

};

bool RedisWriteMode_IsValid(int value);

const RedisWriteMode RedisWriteMode_MIN = REDIS_WRITEMODE_UPSERT;

const RedisWriteMode RedisWriteMode_MAX = REDIS_WRITEMODE_UPDATE;

const int RedisWriteMode_ARRAYSIZE = RedisWriteMode_MAX + 1;

const ::google::protobuf::EnumDescriptor* RedisWriteMode_descriptor();

inline const ::std::string& RedisWriteMode_Name(RedisWriteMode value) {

  return ::google::protobuf::internal::NameOfEnum(

    RedisWriteMode_descriptor(), value);

}

inline bool RedisWriteMode_Parse(

    const ::std::string& name, RedisWriteMode* value) {

  return ::google::protobuf::internal::ParseNamedEnum<RedisWriteMode>(

    RedisWriteMode_descriptor(), name, value);

}

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

class RedisWriteRequestPB : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:yb.RedisWriteRequestPB) */ {

 public:

  RedisWriteRequestPB();

  virtual ~RedisWriteRequestPB();

  RedisWriteRequestPB(const RedisWriteRequestPB& from);

  inline RedisWriteRequestPB& operator=(const RedisWriteRequestPB& from) {

    CopyFrom(from);

    return *this;

  }

  #if LANG_CXX11

  RedisWriteRequestPB(RedisWriteRequestPB&& from) noexcept

    : RedisWriteRequestPB() {

    *this = ::std::move(from);

  }

  inline RedisWriteRequestPB& operator=(RedisWriteRequestPB&& from) noexcept {

    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {

      if (this != &from) InternalSwap(&from);

    } else {

      CopyFrom(from);

    }

    return *this;

  }

  #endif

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {

    return _internal_metadata_.unknown_fields();

  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {

    return _internal_metadata_.mutable_unknown_fields();

  }

  static const ::google::protobuf::Descriptor* descriptor();

  static const RedisWriteRequestPB& default_instance();

  enum RequestCase {

    kSetRequest = 2,

    kGetsetRequest = 3,

    kAppendRequest = 4,

    kDelRequest = 5,

    kSetRangeRequest = 6,

    kIncrRequest = 7,

    kPushRequest = 8,

    kInsertRequest = 9,

    kPopRequest = 10,

    kAddRequest = 11,

    kSetTtlRequest = 12,

    kNoOpRequest = 14,

    REQUEST_NOT_SET = 0,

  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY

  static inline const RedisWriteRequestPB* internal_default_instance() {

    return reinterpret_cast<const RedisWriteRequestPB*>(

               &_RedisWriteRequestPB_default_instance_);

  }

  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =

    0;

  void Swap(RedisWriteRequestPB* other);

  friend void swap(RedisWriteRequestPB& a, RedisWriteRequestPB& b) {

    a.Swap(&b);

  }

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

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

  RedisWriteRequestPB* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;

  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;

  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;

  void CopyFrom(const RedisWriteRequestPB& from);

  void MergeFrom(const RedisWriteRequestPB& from);

  void Clear() PROTOBUF_FINAL;

  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;

  bool MergePartialFromCodedStream(

      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;

  void SerializeWithCachedSizes(

      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;

  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(

      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;

  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }

  private:

  void SharedCtor();

  void SharedDtor();

  void SetCachedSize(int size) const PROTOBUF_FINAL;

  void InternalSwap(RedisWriteRequestPB* other);

  private:

  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {

    return NULL;

  }

  inline void* MaybeArenaPtr() const {

    return NULL;

  }

  public:

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

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

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

  // optional .yb.RedisKeyValuePB key_value = 13;

  bool has_key_value() const;

  void clear_key_value();

  static const int kKeyValueFieldNumber = 13;

  const ::yb::RedisKeyValuePB& key_value() const;

  ::yb::RedisKeyValuePB* release_key_value();

  ::yb::RedisKeyValuePB* mutable_key_value();

  void set_allocated_key_value(::yb::RedisKeyValuePB* key_value);

  // optional .yb.RedisSetRequestPB set_request = 2;

  bool has_set_request() const;

  void clear_set_request();

  static const int kSetRequestFieldNumber = 2;

  const ::yb::RedisSetRequestPB& set_request() const;

  ::yb::RedisSetRequestPB* release_set_request();

  ::yb::RedisSetRequestPB* mutable_set_request();

  void set_allocated_set_request(::yb::RedisSetRequestPB* set_request);

  // optional .yb.RedisGetSetRequestPB getset_request = 3;

  bool has_getset_request() const;

  void clear_getset_request();

  static const int kGetsetRequestFieldNumber = 3;

  const ::yb::RedisGetSetRequestPB& getset_request() const;

  ::yb::RedisGetSetRequestPB* release_getset_request();

  ::yb::RedisGetSetRequestPB* mutable_getset_request();

  void set_allocated_getset_request(::yb::RedisGetSetRequestPB* getset_request);

  // optional .yb.RedisAppendRequestPB append_request = 4;

  bool has_append_request() const;

  void clear_append_request();

  static const int kAppendRequestFieldNumber = 4;

  const ::yb::RedisAppendRequestPB& append_request() const;

  ::yb::RedisAppendRequestPB* release_append_request();

  ::yb::RedisAppendRequestPB* mutable_append_request();

  void set_allocated_append_request(::yb::RedisAppendRequestPB* append_request);

  // optional .yb.RedisDelRequestPB del_request = 5;

  bool has_del_request() const;

  void clear_del_request();

  static const int kDelRequestFieldNumber = 5;

  const ::yb::RedisDelRequestPB& del_request() const;

  ::yb::RedisDelRequestPB* release_del_request();

  ::yb::RedisDelRequestPB* mutable_del_request();

  void set_allocated_del_request(::yb::RedisDelRequestPB* del_request);

  // optional .yb.RedisSetRangeRequestPB set_range_request = 6;

  bool has_set_range_request() const;

  void clear_set_range_request();

  static const int kSetRangeRequestFieldNumber = 6;

  const ::yb::RedisSetRangeRequestPB& set_range_request() const;

  ::yb::RedisSetRangeRequestPB* release_set_range_request();

  ::yb::RedisSetRangeRequestPB* mutable_set_range_request();

  void set_allocated_set_range_request(::yb::RedisSetRangeRequestPB* set_range_request);

  // optional .yb.RedisIncrRequestPB incr_request = 7;

  bool has_incr_request() const;

  void clear_incr_request();

  static const int kIncrRequestFieldNumber = 7;

  const ::yb::RedisIncrRequestPB& incr_request() const;

  ::yb::RedisIncrRequestPB* release_incr_request();

  ::yb::RedisIncrRequestPB* mutable_incr_request();

  void set_allocated_incr_request(::yb::RedisIncrRequestPB* incr_request);

  // optional .yb.RedisPushRequestPB push_request = 8;

  bool has_push_request() const;

  void clear_push_request();

  static const int kPushRequestFieldNumber = 8;

  const ::yb::RedisPushRequestPB& push_request() const;

  ::yb::RedisPushRequestPB* release_push_request();

  ::yb::RedisPushRequestPB* mutable_push_request();

  void set_allocated_push_request(::yb::RedisPushRequestPB* push_request);

  // optional .yb.RedisInsertRequestPB insert_request = 9;

  bool has_insert_request() const;

  void clear_insert_request();

  static const int kInsertRequestFieldNumber = 9;

  const ::yb::RedisInsertRequestPB& insert_request() const;

  ::yb::RedisInsertRequestPB* release_insert_request();

  ::yb::RedisInsertRequestPB* mutable_insert_request();

  void set_allocated_insert_request(::yb::RedisInsertRequestPB* insert_request);

  // optional .yb.RedisPopRequestPB pop_request = 10;

  bool has_pop_request() const;

  void clear_pop_request();

  static const int kPopRequestFieldNumber = 10;

  const ::yb::RedisPopRequestPB& pop_request() const;

  ::yb::RedisPopRequestPB* release_pop_request();

  ::yb::RedisPopRequestPB* mutable_pop_request();

  void set_allocated_pop_request(::yb::RedisPopRequestPB* pop_request);

  // optional .yb.RedisAddRequestPB add_request = 11;

  bool has_add_request() const;

  void clear_add_request();

  static const int kAddRequestFieldNumber = 11;

  const ::yb::RedisAddRequestPB& add_request() const;

  ::yb::RedisAddRequestPB* release_add_request();

  ::yb::RedisAddRequestPB* mutable_add_request();

  void set_allocated_add_request(::yb::RedisAddRequestPB* add_request);

  // optional .yb.RedisSetTtlRequestPB set_ttl_request = 12;

  bool has_set_ttl_request() const;

  void clear_set_ttl_request();

  static const int kSetTtlRequestFieldNumber = 12;

  const ::yb::RedisSetTtlRequestPB& set_ttl_request() const;

  ::yb::RedisSetTtlRequestPB* release_set_ttl_request();

  ::yb::RedisSetTtlRequestPB* mutable_set_ttl_request();

  void set_allocated_set_ttl_request(::yb::RedisSetTtlRequestPB* set_ttl_request);

  // optional .yb.RedisNoOpRequestPB no_op_request = 14;

  bool has_no_op_request() const;

  void clear_no_op_request();

  static const int kNoOpRequestFieldNumber = 14;

  const ::yb::RedisNoOpRequestPB& no_op_request() const;

  ::yb::RedisNoOpRequestPB* release_no_op_request();

  ::yb::RedisNoOpRequestPB* mutable_no_op_request();

  void set_allocated_no_op_request(::yb::RedisNoOpRequestPB* no_op_request);

  RequestCase request_case() const;

  // @@protoc_insertion_point(class_scope:yb.RedisWriteRequestPB)

 private:

  void set_has_set_request();

  void set_has_getset_request();

  void set_has_append_request();

  void set_has_del_request();

  void set_has_set_range_request();

  void set_has_incr_request();

  void set_has_push_request();

  void set_has_insert_request();

  void set_has_pop_request();

  void set_has_add_request();

  void set_has_set_ttl_request();

  void set_has_no_op_request();

  void set_has_key_value();

  void clear_has_key_value();

  inline bool has_request() const;

  void clear_request();

  inline void clear_has_request();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;

  ::google::protobuf::internal::HasBits<1> _has_bits_;

  mutable int _cached_size_;

  ::yb::RedisKeyValuePB* key_value_;

  union RequestUnion {

    RequestUnion() {}

    ::yb::RedisSetRequestPB* set_request_;

    ::yb::RedisGetSetRequestPB* getset_request_;

    ::yb::RedisAppendRequestPB* append_request_;

    ::yb::RedisDelRequestPB* del_request_;

    ::yb::RedisSetRangeRequestPB* set_range_request_;

    ::yb::RedisIncrRequestPB* incr_request_;

    ::yb::RedisPushRequestPB* push_request_;

    ::yb::RedisInsertRequestPB* insert_request_;

    ::yb::RedisPopRequestPB* pop_request_;

    ::yb::RedisAddRequestPB* add_request_;

    ::yb::RedisSetTtlRequestPB* set_ttl_request_;

    ::yb::RedisNoOpRequestPB* no_op_request_;

  } request_;

  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::TableStruct;

  friend void ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisWriteRequestPBImpl();

};

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

class RedisReadRequestPB : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:yb.RedisReadRequestPB) */ {

 public:

  RedisReadRequestPB();

  virtual ~RedisReadRequestPB();

  RedisReadRequestPB(const RedisReadRequestPB& from);

  inline RedisReadRequestPB& operator=(const RedisReadRequestPB& from) {

    CopyFrom(from);

    return *this;

  }

  #if LANG_CXX11

  RedisReadRequestPB(RedisReadRequestPB&& from) noexcept

    : RedisReadRequestPB() {

    *this = ::std::move(from);

  }

  inline RedisReadRequestPB& operator=(RedisReadRequestPB&& from) noexcept {

    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {

      if (this != &from) InternalSwap(&from);

    } else {

      CopyFrom(from);

    }

    return *this;

  }

  #endif

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {

    return _internal_metadata_.unknown_fields();

  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {

    return _internal_metadata_.mutable_unknown_fields();

  }

  static const ::google::protobuf::Descriptor* descriptor();

  static const RedisReadRequestPB& default_instance();

  enum RequestCase {

    kGetRequest = 2,

    kStrlenRequest = 3,

    kExistsRequest = 4,

    kGetRangeRequest = 5,

    kGetCollectionRangeRequest = 9,

    kGetTtlRequest = 11,

    kKeysRequest = 12,

    kGetForRenameRequest = 13,

    REQUEST_NOT_SET = 0,

  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY

  static inline const RedisReadRequestPB* internal_default_instance() {

    return reinterpret_cast<const RedisReadRequestPB*>(

               &_RedisReadRequestPB_default_instance_);

  }

  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =

    1;

  void Swap(RedisReadRequestPB* other);

  friend void swap(RedisReadRequestPB& a, RedisReadRequestPB& b) {

    a.Swap(&b);

  }

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

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

  RedisReadRequestPB* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;

  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;

  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;

  void CopyFrom(const RedisReadRequestPB& from);

  void MergeFrom(const RedisReadRequestPB& from);

  void Clear() PROTOBUF_FINAL;

  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;

  bool MergePartialFromCodedStream(

      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;

  void SerializeWithCachedSizes(

      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;

  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(

      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;

  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }

  private:

  void SharedCtor();

  void SharedDtor();

  void SetCachedSize(int size) const PROTOBUF_FINAL;

  void InternalSwap(RedisReadRequestPB* other);

  private:

  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {

    return NULL;

  }

  inline void* MaybeArenaPtr() const {

    return NULL;

  }

  public:

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

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

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

  // optional .yb.RedisKeyValuePB key_value = 6;

  bool has_key_value() const;

  void clear_key_value();

  static const int kKeyValueFieldNumber = 6;

  const ::yb::RedisKeyValuePB& key_value() const;

  ::yb::RedisKeyValuePB* release_key_value();

  ::yb::RedisKeyValuePB* mutable_key_value();

  void set_allocated_key_value(::yb::RedisKeyValuePB* key_value);

  // optional .yb.RedisSubKeyRangePB subkey_range = 7;

  bool has_subkey_range() const;

  void clear_subkey_range();

  static const int kSubkeyRangeFieldNumber = 7;

  const ::yb::RedisSubKeyRangePB& subkey_range() const;

  ::yb::RedisSubKeyRangePB* release_subkey_range();

  ::yb::RedisSubKeyRangePB* mutable_subkey_range();

  void set_allocated_subkey_range(::yb::RedisSubKeyRangePB* subkey_range);

  // optional .yb.RedisIndexRangePB index_range = 8;

  bool has_index_range() const;

  void clear_index_range();

  static const int kIndexRangeFieldNumber = 8;

  const ::yb::RedisIndexRangePB& index_range() const;

  ::yb::RedisIndexRangePB* release_index_range();

  ::yb::RedisIndexRangePB* mutable_index_range();

  void set_allocated_index_range(::yb::RedisIndexRangePB* index_range);

  // optional int32 range_request_limit = 10 [default = 0];

  bool has_range_request_limit() const;

  void clear_range_request_limit();

  static const int kRangeRequestLimitFieldNumber = 10;

  ::google::protobuf::int32 range_request_limit() const;

  void set_range_request_limit(::google::protobuf::int32 value);

  // optional .yb.RedisGetRequestPB get_request = 2;

  bool has_get_request() const;

  void clear_get_request();

  static const int kGetRequestFieldNumber = 2;

  const ::yb::RedisGetRequestPB& get_request() const;

  ::yb::RedisGetRequestPB* release_get_request();

  ::yb::RedisGetRequestPB* mutable_get_request();

  void set_allocated_get_request(::yb::RedisGetRequestPB* get_request);

  // optional .yb.RedisStrLenRequestPB strlen_request = 3;

  bool has_strlen_request() const;

  void clear_strlen_request();

  static const int kStrlenRequestFieldNumber = 3;

  const ::yb::RedisStrLenRequestPB& strlen_request() const;

  ::yb::RedisStrLenRequestPB* release_strlen_request();

  ::yb::RedisStrLenRequestPB* mutable_strlen_request();

  void set_allocated_strlen_request(::yb::RedisStrLenRequestPB* strlen_request);

  // optional .yb.RedisExistsRequestPB exists_request = 4;

  bool has_exists_request() const;

  void clear_exists_request();

  static const int kExistsRequestFieldNumber = 4;

  const ::yb::RedisExistsRequestPB& exists_request() const;

  ::yb::RedisExistsRequestPB* release_exists_request();

  ::yb::RedisExistsRequestPB* mutable_exists_request();

  void set_allocated_exists_request(::yb::RedisExistsRequestPB* exists_request);

  // optional .yb.RedisGetRangeRequestPB get_range_request = 5;

  bool has_get_range_request() const;

  void clear_get_range_request();

  static const int kGetRangeRequestFieldNumber = 5;

  const ::yb::RedisGetRangeRequestPB& get_range_request() const;

  ::yb::RedisGetRangeRequestPB* release_get_range_request();

  ::yb::RedisGetRangeRequestPB* mutable_get_range_request();

  void set_allocated_get_range_request(::yb::RedisGetRangeRequestPB* get_range_request);

  // optional .yb.RedisCollectionGetRangeRequestPB get_collection_range_request = 9;

  bool has_get_collection_range_request() const;

  void clear_get_collection_range_request();

  static const int kGetCollectionRangeRequestFieldNumber = 9;

  const ::yb::RedisCollectionGetRangeRequestPB& get_collection_range_request() const;

  ::yb::RedisCollectionGetRangeRequestPB* release_get_collection_range_request();

  ::yb::RedisCollectionGetRangeRequestPB* mutable_get_collection_range_request();

  void set_allocated_get_collection_range_request(::yb::RedisCollectionGetRangeRequestPB* get_collection_range_request);

  // optional .yb.RedisGetTtlRequestPB get_ttl_request = 11;

  bool has_get_ttl_request() const;

  void clear_get_ttl_request();

  static const int kGetTtlRequestFieldNumber = 11;

  const ::yb::RedisGetTtlRequestPB& get_ttl_request() const;

  ::yb::RedisGetTtlRequestPB* release_get_ttl_request();

  ::yb::RedisGetTtlRequestPB* mutable_get_ttl_request();

  void set_allocated_get_ttl_request(::yb::RedisGetTtlRequestPB* get_ttl_request);

  // optional .yb.RedisKeysRequestPB keys_request = 12;

  bool has_keys_request() const;

  void clear_keys_request();

  static const int kKeysRequestFieldNumber = 12;

  const ::yb::RedisKeysRequestPB& keys_request() const;

  ::yb::RedisKeysRequestPB* release_keys_request();

  ::yb::RedisKeysRequestPB* mutable_keys_request();

  void set_allocated_keys_request(::yb::RedisKeysRequestPB* keys_request);

  // optional .yb.RedisGetForRenameRequestPB get_for_rename_request = 13;

  bool has_get_for_rename_request() const;

  void clear_get_for_rename_request();

  static const int kGetForRenameRequestFieldNumber = 13;

  const ::yb::RedisGetForRenameRequestPB& get_for_rename_request() const;

  ::yb::RedisGetForRenameRequestPB* release_get_for_rename_request();

  ::yb::RedisGetForRenameRequestPB* mutable_get_for_rename_request();

  void set_allocated_get_for_rename_request(::yb::RedisGetForRenameRequestPB* get_for_rename_request);

  RequestCase request_case() const;

  // @@protoc_insertion_point(class_scope:yb.RedisReadRequestPB)

 private:

  void set_has_get_request();

  void set_has_strlen_request();

  void set_has_exists_request();

  void set_has_get_range_request();

  void set_has_get_collection_range_request();

  void set_has_get_ttl_request();

  void set_has_keys_request();

  void set_has_get_for_rename_request();

  void set_has_key_value();

  void clear_has_key_value();

  void set_has_subkey_range();

  void clear_has_subkey_range();

  void set_has_index_range();

  void clear_has_index_range();

  void set_has_range_request_limit();

  void clear_has_range_request_limit();

  inline bool has_request() const;

  void clear_request();

  inline void clear_has_request();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;

  ::google::protobuf::internal::HasBits<1> _has_bits_;

  mutable int _cached_size_;

  ::yb::RedisKeyValuePB* key_value_;

  ::yb::RedisSubKeyRangePB* subkey_range_;

  ::yb::RedisIndexRangePB* index_range_;

  ::google::protobuf::int32 range_request_limit_;

  union RequestUnion {

    RequestUnion() {}

    ::yb::RedisGetRequestPB* get_request_;

    ::yb::RedisStrLenRequestPB* strlen_request_;

    ::yb::RedisExistsRequestPB* exists_request_;

    ::yb::RedisGetRangeRequestPB* get_range_request_;

    ::yb::RedisCollectionGetRangeRequestPB* get_collection_range_request_;

    ::yb::RedisGetTtlRequestPB* get_ttl_request_;

    ::yb::RedisKeysRequestPB* keys_request_;

    ::yb::RedisGetForRenameRequestPB* get_for_rename_request_;

  } request_;

  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::TableStruct;

  friend void ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisReadRequestPBImpl();

};

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

class RedisSubKeyRangePB : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:yb.RedisSubKeyRangePB) */ {

 public:

  RedisSubKeyRangePB();

  virtual ~RedisSubKeyRangePB();

  RedisSubKeyRangePB(const RedisSubKeyRangePB& from);

  inline RedisSubKeyRangePB& operator=(const RedisSubKeyRangePB& from) {

    CopyFrom(from);

    return *this;

  }

  #if LANG_CXX11

  RedisSubKeyRangePB(RedisSubKeyRangePB&& from) noexcept

    : RedisSubKeyRangePB() {

    *this = ::std::move(from);

  }

  inline RedisSubKeyRangePB& operator=(RedisSubKeyRangePB&& from) noexcept {

    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {

      if (this != &from) InternalSwap(&from);

    } else {

      CopyFrom(from);

    }

    return *this;

  }

  #endif

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {

    return _internal_metadata_.unknown_fields();

  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {

    return _internal_metadata_.mutable_unknown_fields();

  }

  static const ::google::protobuf::Descriptor* descriptor();

  static const RedisSubKeyRangePB& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY

  static inline const RedisSubKeyRangePB* internal_default_instance() {

    return reinterpret_cast<const RedisSubKeyRangePB*>(

               &_RedisSubKeyRangePB_default_instance_);

  }

  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =

    2;

  void Swap(RedisSubKeyRangePB* other);

  friend void swap(RedisSubKeyRangePB& a, RedisSubKeyRangePB& b) {

    a.Swap(&b);

  }

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

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

  RedisSubKeyRangePB* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;

  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;

  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;

  void CopyFrom(const RedisSubKeyRangePB& from);

  void MergeFrom(const RedisSubKeyRangePB& from);

  void Clear() PROTOBUF_FINAL;

  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;

  bool MergePartialFromCodedStream(

      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;

  void SerializeWithCachedSizes(

      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;

  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(

      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;

  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }

  private:

  void SharedCtor();

  void SharedDtor();

  void SetCachedSize(int size) const PROTOBUF_FINAL;

  void InternalSwap(RedisSubKeyRangePB* other);

  private:

  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {

    return NULL;

  }

  inline void* MaybeArenaPtr() const {

    return NULL;

  }

  public:

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

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

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

  // optional .yb.RedisSubKeyBoundPB lower_bound = 1;

  bool has_lower_bound() const;

  void clear_lower_bound();

  static const int kLowerBoundFieldNumber = 1;

  const ::yb::RedisSubKeyBoundPB& lower_bound() const;

  ::yb::RedisSubKeyBoundPB* release_lower_bound();

  ::yb::RedisSubKeyBoundPB* mutable_lower_bound();

  void set_allocated_lower_bound(::yb::RedisSubKeyBoundPB* lower_bound);

  // optional .yb.RedisSubKeyBoundPB upper_bound = 2;

  bool has_upper_bound() const;

  void clear_upper_bound();

  static const int kUpperBoundFieldNumber = 2;

  const ::yb::RedisSubKeyBoundPB& upper_bound() const;

  ::yb::RedisSubKeyBoundPB* release_upper_bound();

  ::yb::RedisSubKeyBoundPB* mutable_upper_bound();

  void set_allocated_upper_bound(::yb::RedisSubKeyBoundPB* upper_bound);

  // @@protoc_insertion_point(class_scope:yb.RedisSubKeyRangePB)

 private:

  void set_has_lower_bound();

  void clear_has_lower_bound();

  void set_has_upper_bound();

  void clear_has_upper_bound();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;