/Users/deen/code/yugabyte-db/build/debugcov-clang-dynamic-arm64-ninja/src/yb/common/redis_protocol.pb.cc

Source (jump to first uncovered line)
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: yb/common/redis_protocol.proto

#include "yb/common/redis_protocol.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// This is a temporary google only hack
#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
#include "third_party/protobuf/version.h"
#endif
#include "yb/util/protobuf-annotations.h"
// @@protoc_insertion_point(includes)
namespace yb {
class RedisWriteRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisWriteRequestPB>
      _instance;
  const ::yb::RedisSetRequestPB* set_request_;
  const ::yb::RedisGetSetRequestPB* getset_request_;
  const ::yb::RedisAppendRequestPB* append_request_;
  const ::yb::RedisDelRequestPB* del_request_;
  const ::yb::RedisSetRangeRequestPB* set_range_request_;
  const ::yb::RedisIncrRequestPB* incr_request_;
  const ::yb::RedisPushRequestPB* push_request_;
  const ::yb::RedisInsertRequestPB* insert_request_;
  const ::yb::RedisPopRequestPB* pop_request_;
  const ::yb::RedisAddRequestPB* add_request_;
  const ::yb::RedisSetTtlRequestPB* set_ttl_request_;
  const ::yb::RedisNoOpRequestPB* no_op_request_;
} _RedisWriteRequestPB_default_instance_;
class RedisReadRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisReadRequestPB>
      _instance;
  const ::yb::RedisGetRequestPB* get_request_;
  const ::yb::RedisStrLenRequestPB* strlen_request_;
  const ::yb::RedisExistsRequestPB* exists_request_;
  const ::yb::RedisGetRangeRequestPB* get_range_request_;
  const ::yb::RedisCollectionGetRangeRequestPB* get_collection_range_request_;
  const ::yb::RedisGetTtlRequestPB* get_ttl_request_;
  const ::yb::RedisKeysRequestPB* keys_request_;
  const ::yb::RedisGetForRenameRequestPB* get_for_rename_request_;
} _RedisReadRequestPB_default_instance_;
class RedisSubKeyRangePBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisSubKeyRangePB>
      _instance;
} _RedisSubKeyRangePB_default_instance_;
class RedisIndexRangePBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisIndexRangePB>
      _instance;
} _RedisIndexRangePB_default_instance_;
class RedisIndexBoundPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisIndexBoundPB>
      _instance;
} _RedisIndexBoundPB_default_instance_;
class RedisSubKeyBoundPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisSubKeyBoundPB>
      _instance;
} _RedisSubKeyBoundPB_default_instance_;
class RedisKeyValueSubKeyPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisKeyValueSubKeyPB>
      _instance;
  ::google::protobuf::internal::ArenaStringPtr string_subkey_;
  ::google::protobuf::int64 timestamp_subkey_;
  double double_subkey_;
} _RedisKeyValueSubKeyPB_default_instance_;
class RedisKeyValuePBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisKeyValuePB>
      _instance;
} _RedisKeyValuePB_default_instance_;
class SortedSetOptionsPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<SortedSetOptionsPB>
      _instance;
} _SortedSetOptionsPB_default_instance_;
class RedisSetRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisSetRequestPB>
      _instance;
} _RedisSetRequestPB_default_instance_;
class RedisGetRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisGetRequestPB>
      _instance;
} _RedisGetRequestPB_default_instance_;
class RedisCollectionGetRangeRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisCollectionGetRangeRequestPB>
      _instance;
} _RedisCollectionGetRangeRequestPB_default_instance_;
class RedisNoOpRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisNoOpRequestPB>
      _instance;
} _RedisNoOpRequestPB_default_instance_;
class RedisSetTtlRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisSetTtlRequestPB>
      _instance;
  ::google::protobuf::int64 ttl_;
  ::google::protobuf::int64 absolute_time_;
} _RedisSetTtlRequestPB_default_instance_;
class RedisGetTtlRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisGetTtlRequestPB>
      _instance;
} _RedisGetTtlRequestPB_default_instance_;
class RedisKeysRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisKeysRequestPB>
      _instance;
} _RedisKeysRequestPB_default_instance_;
class RedisGetForRenameRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisGetForRenameRequestPB>
      _instance;
} _RedisGetForRenameRequestPB_default_instance_;
class RedisGetSetRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisGetSetRequestPB>
      _instance;
} _RedisGetSetRequestPB_default_instance_;
class RedisAppendRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisAppendRequestPB>
      _instance;
} _RedisAppendRequestPB_default_instance_;
class RedisStrLenRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisStrLenRequestPB>
      _instance;
} _RedisStrLenRequestPB_default_instance_;
class RedisDelRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisDelRequestPB>
      _instance;
} _RedisDelRequestPB_default_instance_;
class RedisExistsRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisExistsRequestPB>
      _instance;
} _RedisExistsRequestPB_default_instance_;
class RedisSetRangeRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisSetRangeRequestPB>
      _instance;
} _RedisSetRangeRequestPB_default_instance_;
class RedisGetRangeRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisGetRangeRequestPB>
      _instance;
} _RedisGetRangeRequestPB_default_instance_;
class RedisIncrRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisIncrRequestPB>
      _instance;
} _RedisIncrRequestPB_default_instance_;
class RedisPushRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisPushRequestPB>
      _instance;
} _RedisPushRequestPB_default_instance_;
class RedisInsertRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisInsertRequestPB>
      _instance;
} _RedisInsertRequestPB_default_instance_;
class RedisPopRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisPopRequestPB>
      _instance;
} _RedisPopRequestPB_default_instance_;
class RedisAddRequestPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisAddRequestPB>
      _instance;
} _RedisAddRequestPB_default_instance_;
class RedisResponsePBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisResponsePB>
      _instance;
  ::google::protobuf::int64 int_response_;
  ::google::protobuf::internal::ArenaStringPtr string_response_;
  const ::yb::RedisArrayPB* array_response_;
  ::google::protobuf::internal::ArenaStringPtr status_response_;
  ::google::protobuf::internal::ArenaStringPtr encoded_response_;
} _RedisResponsePB_default_instance_;
class RedisArrayPBDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<RedisArrayPB>
      _instance;
} _RedisArrayPB_default_instance_;
}  // namespace yb
namespace protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto {
void InitDefaultsRedisWriteRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSetRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetSetRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisAppendRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisDelRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSetRangeRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisIncrRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisPushRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisInsertRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisPopRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisAddRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSetTtlRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisNoOpRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisKeyValuePB();
  {
    void* ptr = &::yb::_RedisWriteRequestPB_default_instance_;
    new (ptr) ::yb::RedisWriteRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisWriteRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisWriteRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisWriteRequestPBImpl);
}

void InitDefaultsRedisReadRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisStrLenRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisExistsRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetRangeRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisCollectionGetRangeRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetTtlRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisKeysRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetForRenameRequestPB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisKeyValuePB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSubKeyRangePB();
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisIndexRangePB();
  {
    void* ptr = &::yb::_RedisReadRequestPB_default_instance_;
    new (ptr) ::yb::RedisReadRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisReadRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisReadRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisReadRequestPBImpl);
}

void InitDefaultsRedisSubKeyRangePBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSubKeyBoundPB();
  {
    void* ptr = &::yb::_RedisSubKeyRangePB_default_instance_;
    new (ptr) ::yb::RedisSubKeyRangePB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisSubKeyRangePB::InitAsDefaultInstance();
}

void InitDefaultsRedisSubKeyRangePB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisSubKeyRangePBImpl);
}

void InitDefaultsRedisIndexRangePBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisIndexBoundPB();
  {
    void* ptr = &::yb::_RedisIndexRangePB_default_instance_;
    new (ptr) ::yb::RedisIndexRangePB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisIndexRangePB::InitAsDefaultInstance();
}

void InitDefaultsRedisIndexRangePB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisIndexRangePBImpl);
}

void InitDefaultsRedisIndexBoundPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisIndexBoundPB_default_instance_;
    new (ptr) ::yb::RedisIndexBoundPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisIndexBoundPB::InitAsDefaultInstance();
}

void InitDefaultsRedisIndexBoundPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisIndexBoundPBImpl);
}

void InitDefaultsRedisSubKeyBoundPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisKeyValueSubKeyPB();
  {
    void* ptr = &::yb::_RedisSubKeyBoundPB_default_instance_;
    new (ptr) ::yb::RedisSubKeyBoundPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisSubKeyBoundPB::InitAsDefaultInstance();
}

void InitDefaultsRedisSubKeyBoundPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisSubKeyBoundPBImpl);
}

void InitDefaultsRedisKeyValueSubKeyPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisKeyValueSubKeyPB_default_instance_;
    new (ptr) ::yb::RedisKeyValueSubKeyPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisKeyValueSubKeyPB::InitAsDefaultInstance();
}

void InitDefaultsRedisKeyValueSubKeyPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisKeyValueSubKeyPBImpl);
}

void InitDefaultsRedisKeyValuePBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisKeyValueSubKeyPB();
  {
    void* ptr = &::yb::_RedisKeyValuePB_default_instance_;
    new (ptr) ::yb::RedisKeyValuePB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisKeyValuePB::InitAsDefaultInstance();
}

void InitDefaultsRedisKeyValuePB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisKeyValuePBImpl);
}

void InitDefaultsSortedSetOptionsPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_SortedSetOptionsPB_default_instance_;
    new (ptr) ::yb::SortedSetOptionsPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::SortedSetOptionsPB::InitAsDefaultInstance();
}

void InitDefaultsSortedSetOptionsPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSortedSetOptionsPBImpl);
}

void InitDefaultsRedisSetRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsSortedSetOptionsPB();
  {
    void* ptr = &::yb::_RedisSetRequestPB_default_instance_;
    new (ptr) ::yb::RedisSetRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisSetRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisSetRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisSetRequestPBImpl);
}

void InitDefaultsRedisGetRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisGetRequestPB_default_instance_;
    new (ptr) ::yb::RedisGetRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisGetRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisGetRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisGetRequestPBImpl);
}

void InitDefaultsRedisCollectionGetRangeRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisCollectionGetRangeRequestPB_default_instance_;
    new (ptr) ::yb::RedisCollectionGetRangeRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisCollectionGetRangeRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisCollectionGetRangeRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisCollectionGetRangeRequestPBImpl);
}

void InitDefaultsRedisNoOpRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisNoOpRequestPB_default_instance_;
    new (ptr) ::yb::RedisNoOpRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisNoOpRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisNoOpRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisNoOpRequestPBImpl);
}

void InitDefaultsRedisSetTtlRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisSetTtlRequestPB_default_instance_;
    new (ptr) ::yb::RedisSetTtlRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisSetTtlRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisSetTtlRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisSetTtlRequestPBImpl);
}

void InitDefaultsRedisGetTtlRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisGetTtlRequestPB_default_instance_;
    new (ptr) ::yb::RedisGetTtlRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisGetTtlRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisGetTtlRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisGetTtlRequestPBImpl);
}

void InitDefaultsRedisKeysRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisKeysRequestPB_default_instance_;
    new (ptr) ::yb::RedisKeysRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisKeysRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisKeysRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisKeysRequestPBImpl);
}

void InitDefaultsRedisGetForRenameRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisGetForRenameRequestPB_default_instance_;
    new (ptr) ::yb::RedisGetForRenameRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisGetForRenameRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisGetForRenameRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisGetForRenameRequestPBImpl);
}

void InitDefaultsRedisGetSetRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisGetSetRequestPB_default_instance_;
    new (ptr) ::yb::RedisGetSetRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisGetSetRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisGetSetRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisGetSetRequestPBImpl);
}

void InitDefaultsRedisAppendRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisAppendRequestPB_default_instance_;
    new (ptr) ::yb::RedisAppendRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisAppendRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisAppendRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisAppendRequestPBImpl);
}

void InitDefaultsRedisStrLenRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisStrLenRequestPB_default_instance_;
    new (ptr) ::yb::RedisStrLenRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisStrLenRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisStrLenRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisStrLenRequestPBImpl);
}

void InitDefaultsRedisDelRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisDelRequestPB_default_instance_;
    new (ptr) ::yb::RedisDelRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisDelRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisDelRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisDelRequestPBImpl);
}

void InitDefaultsRedisExistsRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisExistsRequestPB_default_instance_;
    new (ptr) ::yb::RedisExistsRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisExistsRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisExistsRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisExistsRequestPBImpl);
}

void InitDefaultsRedisSetRangeRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisSetRangeRequestPB_default_instance_;
    new (ptr) ::yb::RedisSetRangeRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisSetRangeRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisSetRangeRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisSetRangeRequestPBImpl);
}

void InitDefaultsRedisGetRangeRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisGetRangeRequestPB_default_instance_;
    new (ptr) ::yb::RedisGetRangeRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisGetRangeRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisGetRangeRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisGetRangeRequestPBImpl);
}

void InitDefaultsRedisIncrRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisIncrRequestPB_default_instance_;
    new (ptr) ::yb::RedisIncrRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisIncrRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisIncrRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisIncrRequestPBImpl);
}

void InitDefaultsRedisPushRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisPushRequestPB_default_instance_;
    new (ptr) ::yb::RedisPushRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisPushRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisPushRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisPushRequestPBImpl);
}

void InitDefaultsRedisInsertRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisInsertRequestPB_default_instance_;
    new (ptr) ::yb::RedisInsertRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisInsertRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisInsertRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisInsertRequestPBImpl);
}

void InitDefaultsRedisPopRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisPopRequestPB_default_instance_;
    new (ptr) ::yb::RedisPopRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisPopRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisPopRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisPopRequestPBImpl);
}

void InitDefaultsRedisAddRequestPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisAddRequestPB_default_instance_;
    new (ptr) ::yb::RedisAddRequestPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisAddRequestPB::InitAsDefaultInstance();
}

void InitDefaultsRedisAddRequestPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisAddRequestPBImpl);
}

void InitDefaultsRedisResponsePBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisArrayPB();
  {
    void* ptr = &::yb::_RedisResponsePB_default_instance_;
    new (ptr) ::yb::RedisResponsePB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisResponsePB::InitAsDefaultInstance();
}

void InitDefaultsRedisResponsePB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisResponsePBImpl);
}

void InitDefaultsRedisArrayPBImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
  ::google::protobuf::internal::InitProtobufDefaults();
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
  {
    void* ptr = &::yb::_RedisArrayPB_default_instance_;
    new (ptr) ::yb::RedisArrayPB();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::yb::RedisArrayPB::InitAsDefaultInstance();
}

void InitDefaultsRedisArrayPB() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRedisArrayPBImpl);
}

::google::protobuf::Metadata file_level_metadata[31];
const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[9];

const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisWriteRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisWriteRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisWriteRequestPB, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::yb::RedisWriteRequestPBDefaultTypeInternal, set_request_),
  offsetof(::yb::RedisWriteRequestPBDefaultTypeInternal, getset_request_),
  offsetof(::yb::RedisWriteRequestPBDefaultTypeInternal, append_request_),
  offsetof(::yb::RedisWriteRequestPBDefaultTypeInternal, del_request_),
  offsetof(::yb::RedisWriteRequestPBDefaultTypeInternal, set_range_request_),
  offsetof(::yb::RedisWriteRequestPBDefaultTypeInternal, incr_request_),
  offsetof(::yb::RedisWriteRequestPBDefaultTypeInternal, push_request_),
  offsetof(::yb::RedisWriteRequestPBDefaultTypeInternal, insert_request_),
  offsetof(::yb::RedisWriteRequestPBDefaultTypeInternal, pop_request_),
  offsetof(::yb::RedisWriteRequestPBDefaultTypeInternal, add_request_),
  offsetof(::yb::RedisWriteRequestPBDefaultTypeInternal, set_ttl_request_),
  offsetof(::yb::RedisWriteRequestPBDefaultTypeInternal, no_op_request_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisWriteRequestPB, key_value_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisWriteRequestPB, request_),
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisReadRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisReadRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisReadRequestPB, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::yb::RedisReadRequestPBDefaultTypeInternal, get_request_),
  offsetof(::yb::RedisReadRequestPBDefaultTypeInternal, strlen_request_),
  offsetof(::yb::RedisReadRequestPBDefaultTypeInternal, exists_request_),
  offsetof(::yb::RedisReadRequestPBDefaultTypeInternal, get_range_request_),
  offsetof(::yb::RedisReadRequestPBDefaultTypeInternal, get_collection_range_request_),
  offsetof(::yb::RedisReadRequestPBDefaultTypeInternal, get_ttl_request_),
  offsetof(::yb::RedisReadRequestPBDefaultTypeInternal, keys_request_),
  offsetof(::yb::RedisReadRequestPBDefaultTypeInternal, get_for_rename_request_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisReadRequestPB, key_value_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisReadRequestPB, subkey_range_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisReadRequestPB, index_range_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisReadRequestPB, range_request_limit_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisReadRequestPB, request_),
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  0,
  1,
  2,
  3,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSubKeyRangePB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSubKeyRangePB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSubKeyRangePB, lower_bound_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSubKeyRangePB, upper_bound_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisIndexRangePB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisIndexRangePB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisIndexRangePB, lower_bound_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisIndexRangePB, upper_bound_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisIndexBoundPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisIndexBoundPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisIndexBoundPB, index_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSubKeyBoundPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSubKeyBoundPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSubKeyBoundPB, subkey_bound_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSubKeyBoundPB, infinity_type_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSubKeyBoundPB, is_exclusive_),
  0,
  2,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeyValueSubKeyPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeyValueSubKeyPB, _internal_metadata_),
  ~0u,  // no _extensions_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeyValueSubKeyPB, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::yb::RedisKeyValueSubKeyPBDefaultTypeInternal, string_subkey_),
  offsetof(::yb::RedisKeyValueSubKeyPBDefaultTypeInternal, timestamp_subkey_),
  offsetof(::yb::RedisKeyValueSubKeyPBDefaultTypeInternal, double_subkey_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeyValueSubKeyPB, subkey_),
  ~0u,
  ~0u,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeyValuePB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeyValuePB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeyValuePB, hash_code_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeyValuePB, key_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeyValuePB, type_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeyValuePB, subkey_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeyValuePB, index_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeyValuePB, value_),
  1,
  0,
  3,
  ~0u,
  2,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::SortedSetOptionsPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::SortedSetOptionsPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::SortedSetOptionsPB, update_options_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::SortedSetOptionsPB, ch_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::SortedSetOptionsPB, incr_),
  2,
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSetRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSetRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSetRequestPB, expect_ok_response_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSetRequestPB, ttl_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSetRequestPB, mode_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSetRequestPB, sorted_set_options_),
  1,
  3,
  2,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetRequestPB, request_type_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisCollectionGetRangeRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisCollectionGetRangeRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisCollectionGetRangeRequestPB, request_type_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisCollectionGetRangeRequestPB, with_scores_),
  1,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisNoOpRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisNoOpRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSetTtlRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSetTtlRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSetTtlRequestPB, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::yb::RedisSetTtlRequestPBDefaultTypeInternal, ttl_),
  offsetof(::yb::RedisSetTtlRequestPBDefaultTypeInternal, absolute_time_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSetTtlRequestPB, expiration_),
  ~0u,
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetTtlRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetTtlRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetTtlRequestPB, return_seconds_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeysRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeysRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeysRequestPB, pattern_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisKeysRequestPB, threshold_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetForRenameRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetForRenameRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetSetRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetSetRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisAppendRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisAppendRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisStrLenRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisStrLenRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisDelRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisDelRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisExistsRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisExistsRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSetRangeRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSetRangeRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisSetRangeRequestPB, offset_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetRangeRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetRangeRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetRangeRequestPB, start_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisGetRangeRequestPB, end_),
  0,
  1,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisIncrRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisIncrRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisIncrRequestPB, increment_int_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisIncrRequestPB, increment_float_),
  1,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisPushRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisPushRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisPushRequestPB, side_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisPushRequestPB, check_existence_),
  1,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisInsertRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisInsertRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisInsertRequestPB, order_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisPopRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisPopRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisPopRequestPB, side_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisPopRequestPB, count_),
  1,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisAddRequestPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisAddRequestPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisAddRequestPB, mode_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisAddRequestPB, ch_),
  1,
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisResponsePB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisResponsePB, _internal_metadata_),
  ~0u,  // no _extensions_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisResponsePB, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisResponsePB, code_),
  offsetof(::yb::RedisResponsePBDefaultTypeInternal, int_response_),
  offsetof(::yb::RedisResponsePBDefaultTypeInternal, string_response_),
  offsetof(::yb::RedisResponsePBDefaultTypeInternal, array_response_),
  offsetof(::yb::RedisResponsePBDefaultTypeInternal, status_response_),
  offsetof(::yb::RedisResponsePBDefaultTypeInternal, encoded_response_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisResponsePB, error_message_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisResponsePB, type_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisResponsePB, response_data_),
  1,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  0,
  2,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisArrayPB, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisArrayPB, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisArrayPB, elements_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::yb::RedisArrayPB, encoded_),
  ~0u,
  0,
};
static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 19, sizeof(::yb::RedisWriteRequestPB)},
  { 32, 50, sizeof(::yb::RedisReadRequestPB)},
  { 62, 69, sizeof(::yb::RedisSubKeyRangePB)},
  { 71, 78, sizeof(::yb::RedisIndexRangePB)},
  { 80, 86, sizeof(::yb::RedisIndexBoundPB)},
  { 87, 95, sizeof(::yb::RedisSubKeyBoundPB)},
  { 98, 107, sizeof(::yb::RedisKeyValueSubKeyPB)},
  { 110, 121, sizeof(::yb::RedisKeyValuePB)},
  { 127, 135, sizeof(::yb::SortedSetOptionsPB)},
  { 138, 147, sizeof(::yb::RedisSetRequestPB)},
  { 151, 157, sizeof(::yb::RedisGetRequestPB)},
  { 158, 165, sizeof(::yb::RedisCollectionGetRangeRequestPB)},
  { 167, 172, sizeof(::yb::RedisNoOpRequestPB)},
  { 172, 180, sizeof(::yb::RedisSetTtlRequestPB)},
  { 182, 188, sizeof(::yb::RedisGetTtlRequestPB)},
  { 189, 196, sizeof(::yb::RedisKeysRequestPB)},
  { 198, 203, sizeof(::yb::RedisGetForRenameRequestPB)},
  { 203, 208, sizeof(::yb::RedisGetSetRequestPB)},
  { 208, 213, sizeof(::yb::RedisAppendRequestPB)},
  { 213, 218, sizeof(::yb::RedisStrLenRequestPB)},
  { 218, 223, sizeof(::yb::RedisDelRequestPB)},
  { 223, 228, sizeof(::yb::RedisExistsRequestPB)},
  { 228, 234, sizeof(::yb::RedisSetRangeRequestPB)},
  { 235, 242, sizeof(::yb::RedisGetRangeRequestPB)},
  { 244, 251, sizeof(::yb::RedisIncrRequestPB)},
  { 253, 260, sizeof(::yb::RedisPushRequestPB)},
  { 262, 268, sizeof(::yb::RedisInsertRequestPB)},
  { 269, 276, sizeof(::yb::RedisPopRequestPB)},
  { 278, 285, sizeof(::yb::RedisAddRequestPB)},
  { 287, 301, sizeof(::yb::RedisResponsePB)},
  { 309, 316, sizeof(::yb::RedisArrayPB)},
};

static ::google::protobuf::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisWriteRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisReadRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisSubKeyRangePB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisIndexRangePB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisIndexBoundPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisSubKeyBoundPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisKeyValueSubKeyPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisKeyValuePB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_SortedSetOptionsPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisSetRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisGetRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisCollectionGetRangeRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisNoOpRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisSetTtlRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisGetTtlRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisKeysRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisGetForRenameRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisGetSetRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisAppendRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisStrLenRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisDelRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisExistsRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisSetRangeRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisGetRangeRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisIncrRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisPushRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisInsertRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisPopRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisAddRequestPB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisResponsePB_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::yb::_RedisArrayPB_default_instance_),
};

void protobuf_AssignDescriptors() {
  AddDescriptors();
  ::google::protobuf::MessageFactory* factory = NULL;
  AssignDescriptors(
      "yb/common/redis_protocol.proto", schemas, file_default_instances, TableStruct::offsets, factory,
      file_level_metadata, file_level_enum_descriptors, NULL);
}

void protobuf_AssignDescriptorsOnce() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &protobuf_AssignDescriptors);
}

void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 31);
}

void AddDescriptorsImpl() {
  InitDefaults();
  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
      "\n\036yb/common/redis_protocol.proto\022\002yb\"\233\005\n"
      "\023RedisWriteRequestPB\022,\n\013set_request\030\002 \001("
      "\0132\025.yb.RedisSetRequestPBH\000\0222\n\016getset_req"
      "uest\030\003 \001(\0132\030.yb.RedisGetSetRequestPBH\000\0222"
      "\n\016append_request\030\004 \001(\0132\030.yb.RedisAppendR"
      "equestPBH\000\022,\n\013del_request\030\005 \001(\0132\025.yb.Red"
      "isDelRequestPBH\000\0227\n\021set_range_request\030\006 "
      "\001(\0132\032.yb.RedisSetRangeRequestPBH\000\022.\n\014inc"
      "r_request\030\007 \001(\0132\026.yb.RedisIncrRequestPBH"
      "\000\022.\n\014push_request\030\010 \001(\0132\026.yb.RedisPushRe"
      "questPBH\000\0222\n\016insert_request\030\t \001(\0132\030.yb.R"
      "edisInsertRequestPBH\000\022,\n\013pop_request\030\n \001"
      "(\0132\025.yb.RedisPopRequestPBH\000\022,\n\013add_reque"
      "st\030\013 \001(\0132\025.yb.RedisAddRequestPBH\000\0223\n\017set"
      "_ttl_request\030\014 \001(\0132\030.yb.RedisSetTtlReque"
      "stPBH\000\022/\n\rno_op_request\030\016 \001(\0132\026.yb.Redis"
      "NoOpRequestPBH\000\022&\n\tkey_value\030\r \001(\0132\023.yb."
      "RedisKeyValuePBB\t\n\007request\"\205\005\n\022RedisRead"
      "RequestPB\022,\n\013get_request\030\002 \001(\0132\025.yb.Redi"
      "sGetRequestPBH\000\0222\n\016strlen_request\030\003 \001(\0132"
      "\030.yb.RedisStrLenRequestPBH\000\0222\n\016exists_re"
      "quest\030\004 \001(\0132\030.yb.RedisExistsRequestPBH\000\022"
      "7\n\021get_range_request\030\005 \001(\0132\032.yb.RedisGet"
      "RangeRequestPBH\000\022L\n\034get_collection_range"
      "_request\030\t \001(\0132$.yb.RedisCollectionGetRa"
      "ngeRequestPBH\000\0223\n\017get_ttl_request\030\013 \001(\0132"
      "\030.yb.RedisGetTtlRequestPBH\000\022.\n\014keys_requ"
      "est\030\014 \001(\0132\026.yb.RedisKeysRequestPBH\000\022@\n\026g"
      "et_for_rename_request\030\r \001(\0132\036.yb.RedisGe"
      "tForRenameRequestPBH\000\022&\n\tkey_value\030\006 \001(\013"
      "2\023.yb.RedisKeyValuePB\022,\n\014subkey_range\030\007 "
      "\001(\0132\026.yb.RedisSubKeyRangePB\022*\n\013index_ran"
      "ge\030\010 \001(\0132\025.yb.RedisIndexRangePB\022\036\n\023range"
      "_request_limit\030\n \001(\005:\0010B\t\n\007request\"n\n\022Re"
      "disSubKeyRangePB\022+\n\013lower_bound\030\001 \001(\0132\026."
      "yb.RedisSubKeyBoundPB\022+\n\013upper_bound\030\002 \001"
      "(\0132\026.yb.RedisSubKeyBoundPB\"k\n\021RedisIndex"
      "RangePB\022*\n\013lower_bound\030\001 \001(\0132\025.yb.RedisI"
      "ndexBoundPB\022*\n\013upper_bound\030\002 \001(\0132\025.yb.Re"
      "disIndexBoundPB\"\"\n\021RedisIndexBoundPB\022\r\n\005"
      "index\030\001 \002(\003\"\312\001\n\022RedisSubKeyBoundPB\022/\n\014su"
      "bkey_bound\030\003 \001(\0132\031.yb.RedisKeyValueSubKe"
      "yPB\022:\n\rinfinity_type\030\004 \001(\0162#.yb.RedisSub"
      "KeyBoundPB.InfinityType\022\033\n\014is_exclusive\030"
      "\006 \001(\010:\005false\"*\n\014InfinityType\022\014\n\010POSITIVE"
      "\020\001\022\014\n\010NEGATIVE\020\002\"o\n\025RedisKeyValueSubKeyP"
      "B\022\027\n\rstring_subkey\030\001 \001(\014H\000\022\032\n\020timestamp_"
      "subkey\030\002 \001(\003H\000\022\027\n\rdouble_subkey\030\003 \001(\001H\000B"
      "\010\n\006subkey\"\254\001\n\017RedisKeyValuePB\022\021\n\thash_co"
      "de\030\001 \001(\r\022\013\n\003key\030\002 \001(\014\0220\n\004type\030\003 \001(\0162\021.yb"
      ".RedisDataType:\017REDIS_TYPE_NONE\022)\n\006subke"
      "y\030\004 \003(\0132\031.yb.RedisKeyValueSubKeyPB\022\r\n\005in"
      "dex\030\005 \001(\005\022\r\n\005value\030\006 \003(\014\"\253\001\n\022SortedSetOp"
      "tionsPB\022B\n\016update_options\030\004 \001(\0162$.yb.Sor"
      "tedSetOptionsPB.UpdateOptions:\004NONE\022\021\n\002c"
      "h\030\005 \001(\010:\005false\022\023\n\004incr\030\006 \001(\010:\005false\")\n\rU"
      "pdateOptions\022\006\n\002NX\020\001\022\006\n\002XX\020\002\022\010\n\004NONE\020\003\"\265"
      "\001\n\021RedisSetRequestPB\022!\n\022expect_ok_respon"
      "se\030\001 \001(\010:\005false\022\017\n\003ttl\030\002 \001(\003:\002-1\0228\n\004mode"
      "\030\003 \001(\0162\022.yb.RedisWriteMode:\026REDIS_WRITEM"
      "ODE_UPSERT\0222\n\022sorted_set_options\030\016 \001(\0132\026"
      ".yb.SortedSetOptionsPB\"\303\002\n\021RedisGetReque"
      "stPB\022\?\n\014request_type\030\001 \001(\0162$.yb.RedisGet"
      "RequestPB.GetRequestType:\003GET\"\354\001\n\016GetReq"
      "uestType\022\007\n\003GET\020\001\022\010\n\004MGET\020\003\022\010\n\004HGET\020\002\022\t\n"
      "\005HMGET\020\004\022\013\n\007HGETALL\020\005\022\t\n\005HKEYS\020\007\022\t\n\005HVAL"
      "S\020\010\022\010\n\004HLEN\020\t\022\013\n\007HEXISTS\020\n\022\013\n\007HSTRLEN\020\013\022"
      "\014\n\010SMEMBERS\020\006\022\r\n\tSISMEMBER\020\014\022\t\n\005SCARD\020\r\022"
      "\t\n\005ZCARD\020\017\022\t\n\005TSGET\020\016\022\n\n\006TSCARD\020\020\022\n\n\006ZSC"
      "ORE\020\021\022\010\n\004LLEN\020\022\022\013\n\007UNKNOWN\020c\"\230\002\n RedisCo"
      "llectionGetRangeRequestPB\022]\n\014request_typ"
      "e\030\001 \001(\01628.yb.RedisCollectionGetRangeRequ"
      "estPB.GetRangeRequestType:\rTSRANGEBYTIME"
      "\022\032\n\013with_scores\030\002 \001(\010:\005false\"y\n\023GetRange"
      "RequestType\022\021\n\rTSRANGEBYTIME\020\001\022\021\n\rZRANGE"
      "BYSCORE\020\002\022\r\n\tZREVRANGE\020\003\022\n\n\006ZRANGE\020\004\022\024\n\020"
      "TSREVRANGEBYTIME\020\005\022\013\n\007UNKNOWN\020c\"\024\n\022Redis"
      "NoOpRequestPB\"P\n\024RedisSetTtlRequestPB\022\021\n"
      "\003ttl\030\001 \001(\003:\002-1H\000\022\027\n\rabsolute_time\030\002 \001(\003H"
      "\000B\014\n\nexpiration\"5\n\024RedisGetTtlRequestPB\022"
      "\035\n\016return_seconds\030\001 \001(\010:\005false\"8\n\022RedisK"
      "eysRequestPB\022\017\n\007pattern\030\001 \001(\t\022\021\n\tthresho"
      "ld\030\002 \001(\005\"\034\n\032RedisGetForRenameRequestPB\"\026"
      "\n\024RedisGetSetRequestPB\"\026\n\024RedisAppendReq"
      "uestPB\"\026\n\024RedisStrLenRequestPB\"\023\n\021RedisD"
      "elRequestPB\"\026\n\024RedisExistsRequestPB\"(\n\026R"
      "edisSetRangeRequestPB\022\016\n\006offset\030\002 \001(\005\"4\n"
      "\026RedisGetRangeRequestPB\022\r\n\005start\030\002 \001(\005\022\013"
      "\n\003end\030\003 \001(\005\"G\n\022RedisIncrRequestPB\022\030\n\rinc"
      "rement_int\030\002 \001(\003:\0011\022\027\n\017increment_float\030\003"
      " \001(\001\"b\n\022RedisPushRequestPB\022,\n\004side\030\002 \001(\016"
      "2\r.yb.RedisSide:\017REDIS_SIDE_LEFT\022\036\n\017chec"
      "k_existence\030\003 \001(\010:\005false\"5\n\024RedisInsertR"
      "equestPB\022\035\n\005order\030\002 \001(\0162\016.yb.RedisOrder\""
      "P\n\021RedisPopRequestPB\022,\n\004side\030\002 \001(\0162\r.yb."
      "RedisSide:\017REDIS_SIDE_LEFT\022\r\n\005count\030\003 \001("
      "\005\"Y\n\021RedisAddRequestPB\0228\n\004mode\030\002 \001(\0162\022.y"
      "b.RedisWriteMode:\026REDIS_WRITEMODE_UPSERT"
      "\022\n\n\002ch\030\003 \001(\010\"\272\003\n\017RedisResponsePB\0221\n\004code"
      "\030\001 \001(\0162#.yb.RedisResponsePB.RedisStatusC"
      "ode\022\026\n\014int_response\030\002 \001(\003H\000\022\031\n\017string_re"
      "sponse\030\003 \001(\014H\000\022*\n\016array_response\030\004 \001(\0132\020"
      ".yb.RedisArrayPBH\000\022\031\n\017status_response\030\005 "
      "\001(\014H\000\022\032\n\020encoded_response\030\007 \001(\014H\000\022\025\n\rerr"
      "or_message\030\006 \001(\014\022\037\n\004type\030\010 \001(\0162\021.yb.Redi"
      "sDataType\"\224\001\n\017RedisStatusCode\022\006\n\002OK\020\001\022\007\n"
      "\003NIL\020\002\022\r\n\tNOT_FOUND\020\005\022\023\n\017UNKNOWN_COMMAND"
      "\020\003\022\016\n\nWRONG_TYPE\020\004\022\020\n\014SERVER_ERROR\020\006\022\027\n\023"
      "INDEX_OUT_OF_BOUNDS\020\007\022\021\n\rPARSING_ERROR\020\010"
      "B\017\n\rresponse_data\"1\n\014RedisArrayPB\022\020\n\010ele"
      "ments\030\001 \003(\014\022\017\n\007encoded\030\002 \001(\010*\256\001\n\rRedisDa"
      "taType\022\023\n\017REDIS_TYPE_NONE\020\001\022\025\n\021REDIS_TYP"
      "E_STRING\020\002\022\023\n\017REDIS_TYPE_LIST\020\003\022\022\n\016REDIS"
      "_TYPE_SET\020\004\022\023\n\017REDIS_TYPE_HASH\020\005\022\030\n\024REDI"
      "S_TYPE_SORTEDSET\020\006\022\031\n\025REDIS_TYPE_TIMESER"
      "IES\020\007*6\n\tRedisSide\022\023\n\017REDIS_SIDE_LEFT\020\001\022"
      "\024\n\020REDIS_SIDE_RIGHT\020\002*;\n\nRedisOrder\022\026\n\022R"
      "EDIS_ORDER_BEFORE\020\001\022\025\n\021REDIS_ORDER_AFTER"
      "\020\002*d\n\016RedisWriteMode\022\032\n\026REDIS_WRITEMODE_"
      "UPSERT\020\001\022\032\n\026REDIS_WRITEMODE_INSERT\020\002\022\032\n\026"
      "REDIS_WRITEMODE_UPDATE\020\003B\010\n\006org.yb"
  };
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
      descriptor, 4834);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "yb/common/redis_protocol.proto", &protobuf_RegisterTypes);
}

void AddDescriptors() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}
// Force AddDescriptors() to be called at dynamic initialization time.
struct StaticDescriptorInitializer {
  StaticDescriptorInitializer() {
    AddDescriptors();
  }
} static_descriptor_initializer;
}  // namespace protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto
namespace yb {
const ::google::protobuf::EnumDescriptor* RedisSubKeyBoundPB_InfinityType_descriptor() {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_enum_descriptors[0];
}
bool RedisSubKeyBoundPB_InfinityType_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const RedisSubKeyBoundPB_InfinityType RedisSubKeyBoundPB::POSITIVE;
const RedisSubKeyBoundPB_InfinityType RedisSubKeyBoundPB::NEGATIVE;
const RedisSubKeyBoundPB_InfinityType RedisSubKeyBoundPB::InfinityType_MIN;
const RedisSubKeyBoundPB_InfinityType RedisSubKeyBoundPB::InfinityType_MAX;
const int RedisSubKeyBoundPB::InfinityType_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* SortedSetOptionsPB_UpdateOptions_descriptor() {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_enum_descriptors[1];
}
bool SortedSetOptionsPB_UpdateOptions_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const SortedSetOptionsPB_UpdateOptions SortedSetOptionsPB::NX;
const SortedSetOptionsPB_UpdateOptions SortedSetOptionsPB::XX;
const SortedSetOptionsPB_UpdateOptions SortedSetOptionsPB::NONE;
const SortedSetOptionsPB_UpdateOptions SortedSetOptionsPB::UpdateOptions_MIN;
const SortedSetOptionsPB_UpdateOptions SortedSetOptionsPB::UpdateOptions_MAX;
const int SortedSetOptionsPB::UpdateOptions_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* RedisGetRequestPB_GetRequestType_descriptor() {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_enum_descriptors[2];
}
bool RedisGetRequestPB_GetRequestType_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 99:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::GET;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::MGET;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::HGET;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::HMGET;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::HGETALL;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::HKEYS;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::HVALS;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::HLEN;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::HEXISTS;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::HSTRLEN;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::SMEMBERS;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::SISMEMBER;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::SCARD;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::ZCARD;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::TSGET;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::TSCARD;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::ZSCORE;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::LLEN;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::UNKNOWN;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::GetRequestType_MIN;
const RedisGetRequestPB_GetRequestType RedisGetRequestPB::GetRequestType_MAX;
const int RedisGetRequestPB::GetRequestType_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* RedisCollectionGetRangeRequestPB_GetRangeRequestType_descriptor() {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_enum_descriptors[3];
}
bool RedisCollectionGetRangeRequestPB_GetRangeRequestType_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 99:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const RedisCollectionGetRangeRequestPB_GetRangeRequestType RedisCollectionGetRangeRequestPB::TSRANGEBYTIME;
const RedisCollectionGetRangeRequestPB_GetRangeRequestType RedisCollectionGetRangeRequestPB::ZRANGEBYSCORE;
const RedisCollectionGetRangeRequestPB_GetRangeRequestType RedisCollectionGetRangeRequestPB::ZREVRANGE;
const RedisCollectionGetRangeRequestPB_GetRangeRequestType RedisCollectionGetRangeRequestPB::ZRANGE;
const RedisCollectionGetRangeRequestPB_GetRangeRequestType RedisCollectionGetRangeRequestPB::TSREVRANGEBYTIME;
const RedisCollectionGetRangeRequestPB_GetRangeRequestType RedisCollectionGetRangeRequestPB::UNKNOWN;
const RedisCollectionGetRangeRequestPB_GetRangeRequestType RedisCollectionGetRangeRequestPB::GetRangeRequestType_MIN;
const RedisCollectionGetRangeRequestPB_GetRangeRequestType RedisCollectionGetRangeRequestPB::GetRangeRequestType_MAX;
const int RedisCollectionGetRangeRequestPB::GetRangeRequestType_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* RedisResponsePB_RedisStatusCode_descriptor() {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_enum_descriptors[4];
}
bool RedisResponsePB_RedisStatusCode_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const RedisResponsePB_RedisStatusCode RedisResponsePB::OK;
const RedisResponsePB_RedisStatusCode RedisResponsePB::NIL;
const RedisResponsePB_RedisStatusCode RedisResponsePB::NOT_FOUND;
const RedisResponsePB_RedisStatusCode RedisResponsePB::UNKNOWN_COMMAND;
const RedisResponsePB_RedisStatusCode RedisResponsePB::WRONG_TYPE;
const RedisResponsePB_RedisStatusCode RedisResponsePB::SERVER_ERROR;
const RedisResponsePB_RedisStatusCode RedisResponsePB::INDEX_OUT_OF_BOUNDS;
const RedisResponsePB_RedisStatusCode RedisResponsePB::PARSING_ERROR;
const RedisResponsePB_RedisStatusCode RedisResponsePB::RedisStatusCode_MIN;
const RedisResponsePB_RedisStatusCode RedisResponsePB::RedisStatusCode_MAX;
const int RedisResponsePB::RedisStatusCode_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* RedisDataType_descriptor() {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_enum_descriptors[5];
}
bool RedisDataType_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* RedisSide_descriptor() {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_enum_descriptors[6];
}
bool RedisSide_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* RedisOrder_descriptor() {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_enum_descriptors[7];
}
bool RedisOrder_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* RedisWriteMode_descriptor() {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_enum_descriptors[8];
}
bool RedisWriteMode_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}


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

void RedisWriteRequestPB::InitAsDefaultInstance() {
  ::yb::_RedisWriteRequestPB_default_instance_.set_request_ = const_cast< ::yb::RedisSetRequestPB*>(
      ::yb::RedisSetRequestPB::internal_default_instance());
  ::yb::_RedisWriteRequestPB_default_instance_.getset_request_ = const_cast< ::yb::RedisGetSetRequestPB*>(
      ::yb::RedisGetSetRequestPB::internal_default_instance());
  ::yb::_RedisWriteRequestPB_default_instance_.append_request_ = const_cast< ::yb::RedisAppendRequestPB*>(
      ::yb::RedisAppendRequestPB::internal_default_instance());
  ::yb::_RedisWriteRequestPB_default_instance_.del_request_ = const_cast< ::yb::RedisDelRequestPB*>(
      ::yb::RedisDelRequestPB::internal_default_instance());
  ::yb::_RedisWriteRequestPB_default_instance_.set_range_request_ = const_cast< ::yb::RedisSetRangeRequestPB*>(
      ::yb::RedisSetRangeRequestPB::internal_default_instance());
  ::yb::_RedisWriteRequestPB_default_instance_.incr_request_ = const_cast< ::yb::RedisIncrRequestPB*>(
      ::yb::RedisIncrRequestPB::internal_default_instance());
  ::yb::_RedisWriteRequestPB_default_instance_.push_request_ = const_cast< ::yb::RedisPushRequestPB*>(
      ::yb::RedisPushRequestPB::internal_default_instance());
  ::yb::_RedisWriteRequestPB_default_instance_.insert_request_ = const_cast< ::yb::RedisInsertRequestPB*>(
      ::yb::RedisInsertRequestPB::internal_default_instance());
  ::yb::_RedisWriteRequestPB_default_instance_.pop_request_ = const_cast< ::yb::RedisPopRequestPB*>(
      ::yb::RedisPopRequestPB::internal_default_instance());
  ::yb::_RedisWriteRequestPB_default_instance_.add_request_ = const_cast< ::yb::RedisAddRequestPB*>(
      ::yb::RedisAddRequestPB::internal_default_instance());
  ::yb::_RedisWriteRequestPB_default_instance_.set_ttl_request_ = const_cast< ::yb::RedisSetTtlRequestPB*>(
      ::yb::RedisSetTtlRequestPB::internal_default_instance());
  ::yb::_RedisWriteRequestPB_default_instance_.no_op_request_ = const_cast< ::yb::RedisNoOpRequestPB*>(
      ::yb::RedisNoOpRequestPB::internal_default_instance());
  ::yb::_RedisWriteRequestPB_default_instance_._instance.get_mutable()->key_value_ = const_cast< ::yb::RedisKeyValuePB*>(
      ::yb::RedisKeyValuePB::internal_default_instance());
}
void RedisWriteRequestPB::set_allocated_set_request(::yb::RedisSetRequestPB* set_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (set_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      set_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, set_request, submessage_arena);
    }
    set_has_set_request();
    request_.set_request_ = set_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisWriteRequestPB.set_request)
}
void RedisWriteRequestPB::set_allocated_getset_request(::yb::RedisGetSetRequestPB* getset_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (getset_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      getset_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, getset_request, submessage_arena);
    }
    set_has_getset_request();
    request_.getset_request_ = getset_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisWriteRequestPB.getset_request)
}
void RedisWriteRequestPB::set_allocated_append_request(::yb::RedisAppendRequestPB* append_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (append_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      append_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, append_request, submessage_arena);
    }
    set_has_append_request();
    request_.append_request_ = append_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisWriteRequestPB.append_request)
}
void RedisWriteRequestPB::set_allocated_del_request(::yb::RedisDelRequestPB* del_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (del_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      del_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, del_request, submessage_arena);
    }
    set_has_del_request();
    request_.del_request_ = del_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisWriteRequestPB.del_request)
}
void RedisWriteRequestPB::set_allocated_set_range_request(::yb::RedisSetRangeRequestPB* set_range_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (set_range_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      set_range_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, set_range_request, submessage_arena);
    }
    set_has_set_range_request();
    request_.set_range_request_ = set_range_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisWriteRequestPB.set_range_request)
}
void RedisWriteRequestPB::set_allocated_incr_request(::yb::RedisIncrRequestPB* incr_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (incr_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      incr_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, incr_request, submessage_arena);
    }
    set_has_incr_request();
    request_.incr_request_ = incr_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisWriteRequestPB.incr_request)
}
void RedisWriteRequestPB::set_allocated_push_request(::yb::RedisPushRequestPB* push_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (push_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      push_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, push_request, submessage_arena);
    }
    set_has_push_request();
    request_.push_request_ = push_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisWriteRequestPB.push_request)
}
void RedisWriteRequestPB::set_allocated_insert_request(::yb::RedisInsertRequestPB* insert_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (insert_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      insert_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, insert_request, submessage_arena);
    }
    set_has_insert_request();
    request_.insert_request_ = insert_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisWriteRequestPB.insert_request)
}
void RedisWriteRequestPB::set_allocated_pop_request(::yb::RedisPopRequestPB* pop_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (pop_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      pop_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, pop_request, submessage_arena);
    }
    set_has_pop_request();
    request_.pop_request_ = pop_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisWriteRequestPB.pop_request)
}
void RedisWriteRequestPB::set_allocated_add_request(::yb::RedisAddRequestPB* add_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (add_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      add_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, add_request, submessage_arena);
    }
    set_has_add_request();
    request_.add_request_ = add_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisWriteRequestPB.add_request)
}
void RedisWriteRequestPB::set_allocated_set_ttl_request(::yb::RedisSetTtlRequestPB* set_ttl_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (set_ttl_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      set_ttl_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, set_ttl_request, submessage_arena);
    }
    set_has_set_ttl_request();
    request_.set_ttl_request_ = set_ttl_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisWriteRequestPB.set_ttl_request)
}
void RedisWriteRequestPB::set_allocated_no_op_request(::yb::RedisNoOpRequestPB* no_op_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (no_op_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      no_op_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, no_op_request, submessage_arena);
    }
    set_has_no_op_request();
    request_.no_op_request_ = no_op_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisWriteRequestPB.no_op_request)
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisWriteRequestPB::kSetRequestFieldNumber;
const int RedisWriteRequestPB::kGetsetRequestFieldNumber;
const int RedisWriteRequestPB::kAppendRequestFieldNumber;
const int RedisWriteRequestPB::kDelRequestFieldNumber;
const int RedisWriteRequestPB::kSetRangeRequestFieldNumber;
const int RedisWriteRequestPB::kIncrRequestFieldNumber;
const int RedisWriteRequestPB::kPushRequestFieldNumber;
const int RedisWriteRequestPB::kInsertRequestFieldNumber;
const int RedisWriteRequestPB::kPopRequestFieldNumber;
const int RedisWriteRequestPB::kAddRequestFieldNumber;
const int RedisWriteRequestPB::kSetTtlRequestFieldNumber;
const int RedisWriteRequestPB::kNoOpRequestFieldNumber;
const int RedisWriteRequestPB::kKeyValueFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisWriteRequestPB::RedisWriteRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisWriteRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisWriteRequestPB)
}
RedisWriteRequestPB::RedisWriteRequestPB(const RedisWriteRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_key_value()) {
    key_value_ = new ::yb::RedisKeyValuePB(*from.key_value_);
  } else {
    key_value_ = NULL;
  }
  clear_has_request();
  switch (from.request_case()) {
    case kSetRequest: {
      mutable_set_request()->::yb::RedisSetRequestPB::MergeFrom(from.set_request());
      break;
    }
    case kGetsetRequest: {
      mutable_getset_request()->::yb::RedisGetSetRequestPB::MergeFrom(from.getset_request());
      break;
    }
    case kAppendRequest: {
      mutable_append_request()->::yb::RedisAppendRequestPB::MergeFrom(from.append_request());
      break;
    }
    case kDelRequest: {
      mutable_del_request()->::yb::RedisDelRequestPB::MergeFrom(from.del_request());
      break;
    }
    case kSetRangeRequest: {
      mutable_set_range_request()->::yb::RedisSetRangeRequestPB::MergeFrom(from.set_range_request());
      break;
    }
    case kIncrRequest: {
      mutable_incr_request()->::yb::RedisIncrRequestPB::MergeFrom(from.incr_request());
      break;
    }
    case kPushRequest: {
      mutable_push_request()->::yb::RedisPushRequestPB::MergeFrom(from.push_request());
      break;
    }
    case kInsertRequest: {
      mutable_insert_request()->::yb::RedisInsertRequestPB::MergeFrom(from.insert_request());
      break;
    }
    case kPopRequest: {
      mutable_pop_request()->::yb::RedisPopRequestPB::MergeFrom(from.pop_request());
      break;
    }
    case kAddRequest: {
      mutable_add_request()->::yb::RedisAddRequestPB::MergeFrom(from.add_request());
      break;
    }
    case kSetTtlRequest: {
      mutable_set_ttl_request()->::yb::RedisSetTtlRequestPB::MergeFrom(from.set_ttl_request());
      break;
    }
    case kNoOpRequest: {
      mutable_no_op_request()->::yb::RedisNoOpRequestPB::MergeFrom(from.no_op_request());
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:yb.RedisWriteRequestPB)
}

void RedisWriteRequestPB::SharedCtor() {
  _cached_size_ = 0;
  key_value_ = NULL;
  clear_has_request();
}

RedisWriteRequestPB::~RedisWriteRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisWriteRequestPB)
  SharedDtor();
}

void RedisWriteRequestPB::SharedDtor() {
  if (this != internal_default_instance()) delete key_value_;
  if (has_request()) {
    clear_request();
  }
}

void RedisWriteRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisWriteRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisWriteRequestPB& RedisWriteRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisWriteRequestPB();
  return *internal_default_instance();
}

RedisWriteRequestPB* RedisWriteRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisWriteRequestPB* n = new RedisWriteRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisWriteRequestPB::clear_request() {
// @@protoc_insertion_point(one_of_clear_start:yb.RedisWriteRequestPB)
  switch (request_case()) {
    case kSetRequest: {
      delete request_.set_request_;
      break;
    }
    case kGetsetRequest: {
      delete request_.getset_request_;
      break;
    }
    case kAppendRequest: {
      delete request_.append_request_;
      break;
    }
    case kDelRequest: {
      delete request_.del_request_;
      break;
    }
    case kSetRangeRequest: {
      delete request_.set_range_request_;
      break;
    }
    case kIncrRequest: {
      delete request_.incr_request_;
      break;
    }
    case kPushRequest: {
      delete request_.push_request_;
      break;
    }
    case kInsertRequest: {
      delete request_.insert_request_;
      break;
    }
    case kPopRequest: {
      delete request_.pop_request_;
      break;
    }
    case kAddRequest: {
      delete request_.add_request_;
      break;
    }
    case kSetTtlRequest: {
      delete request_.set_ttl_request_;
      break;
    }
    case kNoOpRequest: {
      delete request_.no_op_request_;
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = REQUEST_NOT_SET;
}


void RedisWriteRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisWriteRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(key_value_ != NULL);
    key_value_->Clear();
  }
  clear_request();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisWriteRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisWriteRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.RedisSetRequestPB set_request = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_set_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisGetSetRequestPB getset_request = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_getset_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisAppendRequestPB append_request = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_append_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisDelRequestPB del_request = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_del_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisSetRangeRequestPB set_range_request = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_set_range_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisIncrRequestPB incr_request = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_incr_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisPushRequestPB push_request = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_push_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisInsertRequestPB insert_request = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u /* 74 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_insert_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisPopRequestPB pop_request = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(82u /* 82 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_pop_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisAddRequestPB add_request = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(90u /* 90 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_add_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisSetTtlRequestPB set_ttl_request = 12;
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(98u /* 98 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_set_ttl_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisKeyValuePB key_value = 13;
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(106u /* 106 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_key_value()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisNoOpRequestPB no_op_request = 14;
      case 14: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(114u /* 114 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_no_op_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisWriteRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisWriteRequestPB)
  return false;
#undef DO_
}

void RedisWriteRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisWriteRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (request_case()) {
    case kSetRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        2, *request_.set_request_, output);
      break;
    case kGetsetRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        3, *request_.getset_request_, output);
      break;
    case kAppendRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        4, *request_.append_request_, output);
      break;
    case kDelRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        5, *request_.del_request_, output);
      break;
    case kSetRangeRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        6, *request_.set_range_request_, output);
      break;
    case kIncrRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        7, *request_.incr_request_, output);
      break;
    case kPushRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        8, *request_.push_request_, output);
      break;
    case kInsertRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        9, *request_.insert_request_, output);
      break;
    case kPopRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        10, *request_.pop_request_, output);
      break;
    case kAddRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        11, *request_.add_request_, output);
      break;
    case kSetTtlRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        12, *request_.set_ttl_request_, output);
      break;
    default: ;
  }
  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisKeyValuePB key_value = 13;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      13, *this->key_value_, output);
  }

  // optional .yb.RedisNoOpRequestPB no_op_request = 14;
  if (has_no_op_request()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      14, *request_.no_op_request_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisWriteRequestPB)
}

::google::protobuf::uint8* RedisWriteRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisWriteRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (request_case()) {
    case kSetRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          2, *request_.set_request_, deterministic, target);
      break;
    case kGetsetRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          3, *request_.getset_request_, deterministic, target);
      break;
    case kAppendRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          4, *request_.append_request_, deterministic, target);
      break;
    case kDelRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          5, *request_.del_request_, deterministic, target);
      break;
    case kSetRangeRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          6, *request_.set_range_request_, deterministic, target);
      break;
    case kIncrRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          7, *request_.incr_request_, deterministic, target);
      break;
    case kPushRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          8, *request_.push_request_, deterministic, target);
      break;
    case kInsertRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          9, *request_.insert_request_, deterministic, target);
      break;
    case kPopRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          10, *request_.pop_request_, deterministic, target);
      break;
    case kAddRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          11, *request_.add_request_, deterministic, target);
      break;
    case kSetTtlRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          12, *request_.set_ttl_request_, deterministic, target);
      break;
    default: ;
  }
  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisKeyValuePB key_value = 13;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        13, *this->key_value_, deterministic, target);
  }

  // optional .yb.RedisNoOpRequestPB no_op_request = 14;
  if (has_no_op_request()) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        14, *request_.no_op_request_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisWriteRequestPB)
  return target;
}

size_t RedisWriteRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisWriteRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional .yb.RedisKeyValuePB key_value = 13;
  if (has_key_value()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSize(
        *this->key_value_);
  }

  switch (request_case()) {
    // optional .yb.RedisSetRequestPB set_request = 2;
    case kSetRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.set_request_);
      break;
    }
    // optional .yb.RedisGetSetRequestPB getset_request = 3;
    case kGetsetRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.getset_request_);
      break;
    }
    // optional .yb.RedisAppendRequestPB append_request = 4;
    case kAppendRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.append_request_);
      break;
    }
    // optional .yb.RedisDelRequestPB del_request = 5;
    case kDelRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.del_request_);
      break;
    }
    // optional .yb.RedisSetRangeRequestPB set_range_request = 6;
    case kSetRangeRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.set_range_request_);
      break;
    }
    // optional .yb.RedisIncrRequestPB incr_request = 7;
    case kIncrRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.incr_request_);
      break;
    }
    // optional .yb.RedisPushRequestPB push_request = 8;
    case kPushRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.push_request_);
      break;
    }
    // optional .yb.RedisInsertRequestPB insert_request = 9;
    case kInsertRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.insert_request_);
      break;
    }
    // optional .yb.RedisPopRequestPB pop_request = 10;
    case kPopRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.pop_request_);
      break;
    }
    // optional .yb.RedisAddRequestPB add_request = 11;
    case kAddRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.add_request_);
      break;
    }
    // optional .yb.RedisSetTtlRequestPB set_ttl_request = 12;
    case kSetTtlRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.set_ttl_request_);
      break;
    }
    // optional .yb.RedisNoOpRequestPB no_op_request = 14;
    case kNoOpRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.no_op_request_);
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisWriteRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisWriteRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisWriteRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisWriteRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisWriteRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisWriteRequestPB)
    MergeFrom(*source);
  }
}

void RedisWriteRequestPB::MergeFrom(const RedisWriteRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisWriteRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_key_value()) {
    mutable_key_value()->::yb::RedisKeyValuePB::MergeFrom(from.key_value());
  }
  switch (from.request_case()) {
    case kSetRequest: {
      mutable_set_request()->::yb::RedisSetRequestPB::MergeFrom(from.set_request());
      break;
    }
    case kGetsetRequest: {
      mutable_getset_request()->::yb::RedisGetSetRequestPB::MergeFrom(from.getset_request());
      break;
    }
    case kAppendRequest: {
      mutable_append_request()->::yb::RedisAppendRequestPB::MergeFrom(from.append_request());
      break;
    }
    case kDelRequest: {
      mutable_del_request()->::yb::RedisDelRequestPB::MergeFrom(from.del_request());
      break;
    }
    case kSetRangeRequest: {
      mutable_set_range_request()->::yb::RedisSetRangeRequestPB::MergeFrom(from.set_range_request());
      break;
    }
    case kIncrRequest: {
      mutable_incr_request()->::yb::RedisIncrRequestPB::MergeFrom(from.incr_request());
      break;
    }
    case kPushRequest: {
      mutable_push_request()->::yb::RedisPushRequestPB::MergeFrom(from.push_request());
      break;
    }
    case kInsertRequest: {
      mutable_insert_request()->::yb::RedisInsertRequestPB::MergeFrom(from.insert_request());
      break;
    }
    case kPopRequest: {
      mutable_pop_request()->::yb::RedisPopRequestPB::MergeFrom(from.pop_request());
      break;
    }
    case kAddRequest: {
      mutable_add_request()->::yb::RedisAddRequestPB::MergeFrom(from.add_request());
      break;
    }
    case kSetTtlRequest: {
      mutable_set_ttl_request()->::yb::RedisSetTtlRequestPB::MergeFrom(from.set_ttl_request());
      break;
    }
    case kNoOpRequest: {
      mutable_no_op_request()->::yb::RedisNoOpRequestPB::MergeFrom(from.no_op_request());
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
}

void RedisWriteRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisWriteRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisWriteRequestPB::CopyFrom(const RedisWriteRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisWriteRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisWriteRequestPB::IsInitialized() const {
  return true;
}

void RedisWriteRequestPB::Swap(RedisWriteRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisWriteRequestPB::InternalSwap(RedisWriteRequestPB* other) {
  using std::swap;
  swap(key_value_, other->key_value_);
  swap(request_, other->request_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisWriteRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisReadRequestPB::InitAsDefaultInstance() {
  ::yb::_RedisReadRequestPB_default_instance_.get_request_ = const_cast< ::yb::RedisGetRequestPB*>(
      ::yb::RedisGetRequestPB::internal_default_instance());
  ::yb::_RedisReadRequestPB_default_instance_.strlen_request_ = const_cast< ::yb::RedisStrLenRequestPB*>(
      ::yb::RedisStrLenRequestPB::internal_default_instance());
  ::yb::_RedisReadRequestPB_default_instance_.exists_request_ = const_cast< ::yb::RedisExistsRequestPB*>(
      ::yb::RedisExistsRequestPB::internal_default_instance());
  ::yb::_RedisReadRequestPB_default_instance_.get_range_request_ = const_cast< ::yb::RedisGetRangeRequestPB*>(
      ::yb::RedisGetRangeRequestPB::internal_default_instance());
  ::yb::_RedisReadRequestPB_default_instance_.get_collection_range_request_ = const_cast< ::yb::RedisCollectionGetRangeRequestPB*>(
      ::yb::RedisCollectionGetRangeRequestPB::internal_default_instance());
  ::yb::_RedisReadRequestPB_default_instance_.get_ttl_request_ = const_cast< ::yb::RedisGetTtlRequestPB*>(
      ::yb::RedisGetTtlRequestPB::internal_default_instance());
  ::yb::_RedisReadRequestPB_default_instance_.keys_request_ = const_cast< ::yb::RedisKeysRequestPB*>(
      ::yb::RedisKeysRequestPB::internal_default_instance());
  ::yb::_RedisReadRequestPB_default_instance_.get_for_rename_request_ = const_cast< ::yb::RedisGetForRenameRequestPB*>(
      ::yb::RedisGetForRenameRequestPB::internal_default_instance());
  ::yb::_RedisReadRequestPB_default_instance_._instance.get_mutable()->key_value_ = const_cast< ::yb::RedisKeyValuePB*>(
      ::yb::RedisKeyValuePB::internal_default_instance());
  ::yb::_RedisReadRequestPB_default_instance_._instance.get_mutable()->subkey_range_ = const_cast< ::yb::RedisSubKeyRangePB*>(
      ::yb::RedisSubKeyRangePB::internal_default_instance());
  ::yb::_RedisReadRequestPB_default_instance_._instance.get_mutable()->index_range_ = const_cast< ::yb::RedisIndexRangePB*>(
      ::yb::RedisIndexRangePB::internal_default_instance());
}
void RedisReadRequestPB::set_allocated_get_request(::yb::RedisGetRequestPB* get_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (get_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      get_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, get_request, submessage_arena);
    }
    set_has_get_request();
    request_.get_request_ = get_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisReadRequestPB.get_request)
}
void RedisReadRequestPB::set_allocated_strlen_request(::yb::RedisStrLenRequestPB* strlen_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (strlen_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      strlen_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, strlen_request, submessage_arena);
    }
    set_has_strlen_request();
    request_.strlen_request_ = strlen_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisReadRequestPB.strlen_request)
}
void RedisReadRequestPB::set_allocated_exists_request(::yb::RedisExistsRequestPB* exists_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (exists_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      exists_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, exists_request, submessage_arena);
    }
    set_has_exists_request();
    request_.exists_request_ = exists_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisReadRequestPB.exists_request)
}
void RedisReadRequestPB::set_allocated_get_range_request(::yb::RedisGetRangeRequestPB* get_range_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (get_range_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      get_range_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, get_range_request, submessage_arena);
    }
    set_has_get_range_request();
    request_.get_range_request_ = get_range_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisReadRequestPB.get_range_request)
}
void RedisReadRequestPB::set_allocated_get_collection_range_request(::yb::RedisCollectionGetRangeRequestPB* get_collection_range_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (get_collection_range_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      get_collection_range_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, get_collection_range_request, submessage_arena);
    }
    set_has_get_collection_range_request();
    request_.get_collection_range_request_ = get_collection_range_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisReadRequestPB.get_collection_range_request)
}
void RedisReadRequestPB::set_allocated_get_ttl_request(::yb::RedisGetTtlRequestPB* get_ttl_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (get_ttl_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      get_ttl_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, get_ttl_request, submessage_arena);
    }
    set_has_get_ttl_request();
    request_.get_ttl_request_ = get_ttl_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisReadRequestPB.get_ttl_request)
}
void RedisReadRequestPB::set_allocated_keys_request(::yb::RedisKeysRequestPB* keys_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (keys_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      keys_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, keys_request, submessage_arena);
    }
    set_has_keys_request();
    request_.keys_request_ = keys_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisReadRequestPB.keys_request)
}
void RedisReadRequestPB::set_allocated_get_for_rename_request(::yb::RedisGetForRenameRequestPB* get_for_rename_request) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_request();
  if (get_for_rename_request) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      get_for_rename_request = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, get_for_rename_request, submessage_arena);
    }
    set_has_get_for_rename_request();
    request_.get_for_rename_request_ = get_for_rename_request;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisReadRequestPB.get_for_rename_request)
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisReadRequestPB::kGetRequestFieldNumber;
const int RedisReadRequestPB::kStrlenRequestFieldNumber;
const int RedisReadRequestPB::kExistsRequestFieldNumber;
const int RedisReadRequestPB::kGetRangeRequestFieldNumber;
const int RedisReadRequestPB::kGetCollectionRangeRequestFieldNumber;
const int RedisReadRequestPB::kGetTtlRequestFieldNumber;
const int RedisReadRequestPB::kKeysRequestFieldNumber;
const int RedisReadRequestPB::kGetForRenameRequestFieldNumber;
const int RedisReadRequestPB::kKeyValueFieldNumber;
const int RedisReadRequestPB::kSubkeyRangeFieldNumber;
const int RedisReadRequestPB::kIndexRangeFieldNumber;
const int RedisReadRequestPB::kRangeRequestLimitFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisReadRequestPB::RedisReadRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisReadRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisReadRequestPB)
}
RedisReadRequestPB::RedisReadRequestPB(const RedisReadRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_key_value()) {
    key_value_ = new ::yb::RedisKeyValuePB(*from.key_value_);
  } else {
    key_value_ = NULL;
  }
  if (from.has_subkey_range()) {
    subkey_range_ = new ::yb::RedisSubKeyRangePB(*from.subkey_range_);
  } else {
    subkey_range_ = NULL;
  }
  if (from.has_index_range()) {
    index_range_ = new ::yb::RedisIndexRangePB(*from.index_range_);
  } else {
    index_range_ = NULL;
  }
  range_request_limit_ = from.range_request_limit_;
  clear_has_request();
  switch (from.request_case()) {
    case kGetRequest: {
      mutable_get_request()->::yb::RedisGetRequestPB::MergeFrom(from.get_request());
      break;
    }
    case kStrlenRequest: {
      mutable_strlen_request()->::yb::RedisStrLenRequestPB::MergeFrom(from.strlen_request());
      break;
    }
    case kExistsRequest: {
      mutable_exists_request()->::yb::RedisExistsRequestPB::MergeFrom(from.exists_request());
      break;
    }
    case kGetRangeRequest: {
      mutable_get_range_request()->::yb::RedisGetRangeRequestPB::MergeFrom(from.get_range_request());
      break;
    }
    case kGetCollectionRangeRequest: {
      mutable_get_collection_range_request()->::yb::RedisCollectionGetRangeRequestPB::MergeFrom(from.get_collection_range_request());
      break;
    }
    case kGetTtlRequest: {
      mutable_get_ttl_request()->::yb::RedisGetTtlRequestPB::MergeFrom(from.get_ttl_request());
      break;
    }
    case kKeysRequest: {
      mutable_keys_request()->::yb::RedisKeysRequestPB::MergeFrom(from.keys_request());
      break;
    }
    case kGetForRenameRequest: {
      mutable_get_for_rename_request()->::yb::RedisGetForRenameRequestPB::MergeFrom(from.get_for_rename_request());
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:yb.RedisReadRequestPB)
}

void RedisReadRequestPB::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&key_value_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&range_request_limit_) -
      reinterpret_cast<char*>(&key_value_)) + sizeof(range_request_limit_));
  clear_has_request();
}

RedisReadRequestPB::~RedisReadRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisReadRequestPB)
  SharedDtor();
}

void RedisReadRequestPB::SharedDtor() {
  if (this != internal_default_instance()) delete key_value_;
  if (this != internal_default_instance()) delete subkey_range_;
  if (this != internal_default_instance()) delete index_range_;
  if (has_request()) {
    clear_request();
  }
}

void RedisReadRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisReadRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisReadRequestPB& RedisReadRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisReadRequestPB();
  return *internal_default_instance();
}

RedisReadRequestPB* RedisReadRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisReadRequestPB* n = new RedisReadRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisReadRequestPB::clear_request() {
// @@protoc_insertion_point(one_of_clear_start:yb.RedisReadRequestPB)
  switch (request_case()) {
    case kGetRequest: {
      delete request_.get_request_;
      break;
    }
    case kStrlenRequest: {
      delete request_.strlen_request_;
      break;
    }
    case kExistsRequest: {
      delete request_.exists_request_;
      break;
    }
    case kGetRangeRequest: {
      delete request_.get_range_request_;
      break;
    }
    case kGetCollectionRangeRequest: {
      delete request_.get_collection_range_request_;
      break;
    }
    case kGetTtlRequest: {
      delete request_.get_ttl_request_;
      break;
    }
    case kKeysRequest: {
      delete request_.keys_request_;
      break;
    }
    case kGetForRenameRequest: {
      delete request_.get_for_rename_request_;
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = REQUEST_NOT_SET;
}


void RedisReadRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisReadRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(key_value_ != NULL);
      key_value_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(subkey_range_ != NULL);
      subkey_range_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(index_range_ != NULL);
      index_range_->Clear();
    }
  }
  range_request_limit_ = 0;
  clear_request();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisReadRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisReadRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.RedisGetRequestPB get_request = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_get_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisStrLenRequestPB strlen_request = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_strlen_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisExistsRequestPB exists_request = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_exists_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisGetRangeRequestPB get_range_request = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_get_range_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisKeyValuePB key_value = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_key_value()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisSubKeyRangePB subkey_range = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_subkey_range()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisIndexRangePB index_range = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_index_range()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisCollectionGetRangeRequestPB get_collection_range_request = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u /* 74 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_get_collection_range_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 range_request_limit = 10 [default = 0];
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) {
          set_has_range_request_limit();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &range_request_limit_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisGetTtlRequestPB get_ttl_request = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(90u /* 90 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_get_ttl_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisKeysRequestPB keys_request = 12;
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(98u /* 98 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_keys_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisGetForRenameRequestPB get_for_rename_request = 13;
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(106u /* 106 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_get_for_rename_request()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisReadRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisReadRequestPB)
  return false;
#undef DO_
}

void RedisReadRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisReadRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (request_case()) {
    case kGetRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        2, *request_.get_request_, output);
      break;
    case kStrlenRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        3, *request_.strlen_request_, output);
      break;
    case kExistsRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        4, *request_.exists_request_, output);
      break;
    case kGetRangeRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        5, *request_.get_range_request_, output);
      break;
    default: ;
  }
  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisKeyValuePB key_value = 6;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, *this->key_value_, output);
  }

  // optional .yb.RedisSubKeyRangePB subkey_range = 7;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, *this->subkey_range_, output);
  }

  // optional .yb.RedisIndexRangePB index_range = 8;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      8, *this->index_range_, output);
  }

  // optional .yb.RedisCollectionGetRangeRequestPB get_collection_range_request = 9;
  if (has_get_collection_range_request()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      9, *request_.get_collection_range_request_, output);
  }

  // optional int32 range_request_limit = 10 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->range_request_limit(), output);
  }

  switch (request_case()) {
    case kGetTtlRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        11, *request_.get_ttl_request_, output);
      break;
    case kKeysRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        12, *request_.keys_request_, output);
      break;
    case kGetForRenameRequest:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        13, *request_.get_for_rename_request_, output);
      break;
    default: ;
  }
  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisReadRequestPB)
}

::google::protobuf::uint8* RedisReadRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisReadRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (request_case()) {
    case kGetRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          2, *request_.get_request_, deterministic, target);
      break;
    case kStrlenRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          3, *request_.strlen_request_, deterministic, target);
      break;
    case kExistsRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          4, *request_.exists_request_, deterministic, target);
      break;
    case kGetRangeRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          5, *request_.get_range_request_, deterministic, target);
      break;
    default: ;
  }
  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisKeyValuePB key_value = 6;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        6, *this->key_value_, deterministic, target);
  }

  // optional .yb.RedisSubKeyRangePB subkey_range = 7;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        7, *this->subkey_range_, deterministic, target);
  }

  // optional .yb.RedisIndexRangePB index_range = 8;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        8, *this->index_range_, deterministic, target);
  }

  // optional .yb.RedisCollectionGetRangeRequestPB get_collection_range_request = 9;
  if (has_get_collection_range_request()) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        9, *request_.get_collection_range_request_, deterministic, target);
  }

  // optional int32 range_request_limit = 10 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(10, this->range_request_limit(), target);
  }

  switch (request_case()) {
    case kGetTtlRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          11, *request_.get_ttl_request_, deterministic, target);
      break;
    case kKeysRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          12, *request_.keys_request_, deterministic, target);
      break;
    case kGetForRenameRequest:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          13, *request_.get_for_rename_request_, deterministic, target);
      break;
    default: ;
  }
  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisReadRequestPB)
  return target;
}

size_t RedisReadRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisReadRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 15u) {
    // optional .yb.RedisKeyValuePB key_value = 6;
    if (has_key_value()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->key_value_);
    }

    // optional .yb.RedisSubKeyRangePB subkey_range = 7;
    if (has_subkey_range()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->subkey_range_);
    }

    // optional .yb.RedisIndexRangePB index_range = 8;
    if (has_index_range()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->index_range_);
    }

    // optional int32 range_request_limit = 10 [default = 0];
    if (has_range_request_limit()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->range_request_limit());
    }

  }
  switch (request_case()) {
    // optional .yb.RedisGetRequestPB get_request = 2;
    case kGetRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.get_request_);
      break;
    }
    // optional .yb.RedisStrLenRequestPB strlen_request = 3;
    case kStrlenRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.strlen_request_);
      break;
    }
    // optional .yb.RedisExistsRequestPB exists_request = 4;
    case kExistsRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.exists_request_);
      break;
    }
    // optional .yb.RedisGetRangeRequestPB get_range_request = 5;
    case kGetRangeRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.get_range_request_);
      break;
    }
    // optional .yb.RedisCollectionGetRangeRequestPB get_collection_range_request = 9;
    case kGetCollectionRangeRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.get_collection_range_request_);
      break;
    }
    // optional .yb.RedisGetTtlRequestPB get_ttl_request = 11;
    case kGetTtlRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.get_ttl_request_);
      break;
    }
    // optional .yb.RedisKeysRequestPB keys_request = 12;
    case kKeysRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.keys_request_);
      break;
    }
    // optional .yb.RedisGetForRenameRequestPB get_for_rename_request = 13;
    case kGetForRenameRequest: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *request_.get_for_rename_request_);
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisReadRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisReadRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisReadRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisReadRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisReadRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisReadRequestPB)
    MergeFrom(*source);
  }
}

void RedisReadRequestPB::MergeFrom(const RedisReadRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisReadRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_key_value()->::yb::RedisKeyValuePB::MergeFrom(from.key_value());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_subkey_range()->::yb::RedisSubKeyRangePB::MergeFrom(from.subkey_range());
    }
    if (cached_has_bits & 0x00000004u) {
      mutable_index_range()->::yb::RedisIndexRangePB::MergeFrom(from.index_range());
    }
    if (cached_has_bits & 0x00000008u) {
      range_request_limit_ = from.range_request_limit_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  switch (from.request_case()) {
    case kGetRequest: {
      mutable_get_request()->::yb::RedisGetRequestPB::MergeFrom(from.get_request());
      break;
    }
    case kStrlenRequest: {
      mutable_strlen_request()->::yb::RedisStrLenRequestPB::MergeFrom(from.strlen_request());
      break;
    }
    case kExistsRequest: {
      mutable_exists_request()->::yb::RedisExistsRequestPB::MergeFrom(from.exists_request());
      break;
    }
    case kGetRangeRequest: {
      mutable_get_range_request()->::yb::RedisGetRangeRequestPB::MergeFrom(from.get_range_request());
      break;
    }
    case kGetCollectionRangeRequest: {
      mutable_get_collection_range_request()->::yb::RedisCollectionGetRangeRequestPB::MergeFrom(from.get_collection_range_request());
      break;
    }
    case kGetTtlRequest: {
      mutable_get_ttl_request()->::yb::RedisGetTtlRequestPB::MergeFrom(from.get_ttl_request());
      break;
    }
    case kKeysRequest: {
      mutable_keys_request()->::yb::RedisKeysRequestPB::MergeFrom(from.keys_request());
      break;
    }
    case kGetForRenameRequest: {
      mutable_get_for_rename_request()->::yb::RedisGetForRenameRequestPB::MergeFrom(from.get_for_rename_request());
      break;
    }
    case REQUEST_NOT_SET: {
      break;
    }
  }
}

void RedisReadRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisReadRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisReadRequestPB::CopyFrom(const RedisReadRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisReadRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisReadRequestPB::IsInitialized() const {
  if (has_index_range()) {
    if (!this->index_range_->IsInitialized()) return false;
  }
  return true;
}

void RedisReadRequestPB::Swap(RedisReadRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisReadRequestPB::InternalSwap(RedisReadRequestPB* other) {
  using std::swap;
  swap(key_value_, other->key_value_);
  swap(subkey_range_, other->subkey_range_);
  swap(index_range_, other->index_range_);
  swap(range_request_limit_, other->range_request_limit_);
  swap(request_, other->request_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisReadRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisSubKeyRangePB::InitAsDefaultInstance() {
  ::yb::_RedisSubKeyRangePB_default_instance_._instance.get_mutable()->lower_bound_ = const_cast< ::yb::RedisSubKeyBoundPB*>(
      ::yb::RedisSubKeyBoundPB::internal_default_instance());
  ::yb::_RedisSubKeyRangePB_default_instance_._instance.get_mutable()->upper_bound_ = const_cast< ::yb::RedisSubKeyBoundPB*>(
      ::yb::RedisSubKeyBoundPB::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisSubKeyRangePB::kLowerBoundFieldNumber;
const int RedisSubKeyRangePB::kUpperBoundFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisSubKeyRangePB::RedisSubKeyRangePB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSubKeyRangePB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisSubKeyRangePB)
}
RedisSubKeyRangePB::RedisSubKeyRangePB(const RedisSubKeyRangePB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_lower_bound()) {
    lower_bound_ = new ::yb::RedisSubKeyBoundPB(*from.lower_bound_);
  } else {
    lower_bound_ = NULL;
  }
  if (from.has_upper_bound()) {
    upper_bound_ = new ::yb::RedisSubKeyBoundPB(*from.upper_bound_);
  } else {
    upper_bound_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.RedisSubKeyRangePB)
}

void RedisSubKeyRangePB::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&lower_bound_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&upper_bound_) -
      reinterpret_cast<char*>(&lower_bound_)) + sizeof(upper_bound_));
}

RedisSubKeyRangePB::~RedisSubKeyRangePB() {
  // @@protoc_insertion_point(destructor:yb.RedisSubKeyRangePB)
  SharedDtor();
}

void RedisSubKeyRangePB::SharedDtor() {
  if (this != internal_default_instance()) delete lower_bound_;
  if (this != internal_default_instance()) delete upper_bound_;
}

void RedisSubKeyRangePB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisSubKeyRangePB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisSubKeyRangePB& RedisSubKeyRangePB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSubKeyRangePB();
  return *internal_default_instance();
}

RedisSubKeyRangePB* RedisSubKeyRangePB::New(::google::protobuf::Arena* arena) const {
  RedisSubKeyRangePB* n = new RedisSubKeyRangePB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisSubKeyRangePB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisSubKeyRangePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(lower_bound_ != NULL);
      lower_bound_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(upper_bound_ != NULL);
      upper_bound_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisSubKeyRangePB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisSubKeyRangePB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.RedisSubKeyBoundPB lower_bound = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_lower_bound()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisSubKeyBoundPB upper_bound = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_upper_bound()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisSubKeyRangePB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisSubKeyRangePB)
  return false;
#undef DO_
}

void RedisSubKeyRangePB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisSubKeyRangePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisSubKeyBoundPB lower_bound = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->lower_bound_, output);
  }

  // optional .yb.RedisSubKeyBoundPB upper_bound = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, *this->upper_bound_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisSubKeyRangePB)
}

::google::protobuf::uint8* RedisSubKeyRangePB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisSubKeyRangePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisSubKeyBoundPB lower_bound = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->lower_bound_, deterministic, target);
  }

  // optional .yb.RedisSubKeyBoundPB upper_bound = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, *this->upper_bound_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisSubKeyRangePB)
  return target;
}

size_t RedisSubKeyRangePB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisSubKeyRangePB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional .yb.RedisSubKeyBoundPB lower_bound = 1;
    if (has_lower_bound()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->lower_bound_);
    }

    // optional .yb.RedisSubKeyBoundPB upper_bound = 2;
    if (has_upper_bound()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->upper_bound_);
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisSubKeyRangePB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisSubKeyRangePB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisSubKeyRangePB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisSubKeyRangePB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisSubKeyRangePB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisSubKeyRangePB)
    MergeFrom(*source);
  }
}

void RedisSubKeyRangePB::MergeFrom(const RedisSubKeyRangePB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisSubKeyRangePB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_lower_bound()->::yb::RedisSubKeyBoundPB::MergeFrom(from.lower_bound());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_upper_bound()->::yb::RedisSubKeyBoundPB::MergeFrom(from.upper_bound());
    }
  }
}

void RedisSubKeyRangePB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisSubKeyRangePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisSubKeyRangePB::CopyFrom(const RedisSubKeyRangePB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisSubKeyRangePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisSubKeyRangePB::IsInitialized() const {
  return true;
}

void RedisSubKeyRangePB::Swap(RedisSubKeyRangePB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisSubKeyRangePB::InternalSwap(RedisSubKeyRangePB* other) {
  using std::swap;
  swap(lower_bound_, other->lower_bound_);
  swap(upper_bound_, other->upper_bound_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisSubKeyRangePB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisIndexRangePB::InitAsDefaultInstance() {
  ::yb::_RedisIndexRangePB_default_instance_._instance.get_mutable()->lower_bound_ = const_cast< ::yb::RedisIndexBoundPB*>(
      ::yb::RedisIndexBoundPB::internal_default_instance());
  ::yb::_RedisIndexRangePB_default_instance_._instance.get_mutable()->upper_bound_ = const_cast< ::yb::RedisIndexBoundPB*>(
      ::yb::RedisIndexBoundPB::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisIndexRangePB::kLowerBoundFieldNumber;
const int RedisIndexRangePB::kUpperBoundFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisIndexRangePB::RedisIndexRangePB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisIndexRangePB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisIndexRangePB)
}
RedisIndexRangePB::RedisIndexRangePB(const RedisIndexRangePB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_lower_bound()) {
    lower_bound_ = new ::yb::RedisIndexBoundPB(*from.lower_bound_);
  } else {
    lower_bound_ = NULL;
  }
  if (from.has_upper_bound()) {
    upper_bound_ = new ::yb::RedisIndexBoundPB(*from.upper_bound_);
  } else {
    upper_bound_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:yb.RedisIndexRangePB)
}

void RedisIndexRangePB::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&lower_bound_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&upper_bound_) -
      reinterpret_cast<char*>(&lower_bound_)) + sizeof(upper_bound_));
}

RedisIndexRangePB::~RedisIndexRangePB() {
  // @@protoc_insertion_point(destructor:yb.RedisIndexRangePB)
  SharedDtor();
}

void RedisIndexRangePB::SharedDtor() {
  if (this != internal_default_instance()) delete lower_bound_;
  if (this != internal_default_instance()) delete upper_bound_;
}

void RedisIndexRangePB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisIndexRangePB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisIndexRangePB& RedisIndexRangePB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisIndexRangePB();
  return *internal_default_instance();
}

RedisIndexRangePB* RedisIndexRangePB::New(::google::protobuf::Arena* arena) const {
  RedisIndexRangePB* n = new RedisIndexRangePB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisIndexRangePB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisIndexRangePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(lower_bound_ != NULL);
      lower_bound_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(upper_bound_ != NULL);
      upper_bound_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisIndexRangePB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisIndexRangePB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.RedisIndexBoundPB lower_bound = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_lower_bound()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisIndexBoundPB upper_bound = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_upper_bound()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisIndexRangePB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisIndexRangePB)
  return false;
#undef DO_
}

void RedisIndexRangePB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisIndexRangePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisIndexBoundPB lower_bound = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->lower_bound_, output);
  }

  // optional .yb.RedisIndexBoundPB upper_bound = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, *this->upper_bound_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisIndexRangePB)
}

::google::protobuf::uint8* RedisIndexRangePB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisIndexRangePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisIndexBoundPB lower_bound = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, *this->lower_bound_, deterministic, target);
  }

  // optional .yb.RedisIndexBoundPB upper_bound = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        2, *this->upper_bound_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisIndexRangePB)
  return target;
}

size_t RedisIndexRangePB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisIndexRangePB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional .yb.RedisIndexBoundPB lower_bound = 1;
    if (has_lower_bound()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->lower_bound_);
    }

    // optional .yb.RedisIndexBoundPB upper_bound = 2;
    if (has_upper_bound()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->upper_bound_);
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisIndexRangePB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisIndexRangePB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisIndexRangePB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisIndexRangePB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisIndexRangePB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisIndexRangePB)
    MergeFrom(*source);
  }
}

void RedisIndexRangePB::MergeFrom(const RedisIndexRangePB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisIndexRangePB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_lower_bound()->::yb::RedisIndexBoundPB::MergeFrom(from.lower_bound());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_upper_bound()->::yb::RedisIndexBoundPB::MergeFrom(from.upper_bound());
    }
  }
}

void RedisIndexRangePB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisIndexRangePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisIndexRangePB::CopyFrom(const RedisIndexRangePB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisIndexRangePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisIndexRangePB::IsInitialized() const {
  if (has_lower_bound()) {
    if (!this->lower_bound_->IsInitialized()) return false;
  }
  if (has_upper_bound()) {
    if (!this->upper_bound_->IsInitialized()) return false;
  }
  return true;
}

void RedisIndexRangePB::Swap(RedisIndexRangePB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisIndexRangePB::InternalSwap(RedisIndexRangePB* other) {
  using std::swap;
  swap(lower_bound_, other->lower_bound_);
  swap(upper_bound_, other->upper_bound_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisIndexRangePB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisIndexBoundPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisIndexBoundPB::kIndexFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisIndexBoundPB::RedisIndexBoundPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisIndexBoundPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisIndexBoundPB)
}
RedisIndexBoundPB::RedisIndexBoundPB(const RedisIndexBoundPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  index_ = from.index_;
  // @@protoc_insertion_point(copy_constructor:yb.RedisIndexBoundPB)
}

void RedisIndexBoundPB::SharedCtor() {
  _cached_size_ = 0;
  index_ = GOOGLE_LONGLONG(0);
}

RedisIndexBoundPB::~RedisIndexBoundPB() {
  // @@protoc_insertion_point(destructor:yb.RedisIndexBoundPB)
  SharedDtor();
}

void RedisIndexBoundPB::SharedDtor() {
}

void RedisIndexBoundPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisIndexBoundPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisIndexBoundPB& RedisIndexBoundPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisIndexBoundPB();
  return *internal_default_instance();
}

RedisIndexBoundPB* RedisIndexBoundPB::New(::google::protobuf::Arena* arena) const {
  RedisIndexBoundPB* n = new RedisIndexBoundPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisIndexBoundPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisIndexBoundPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  index_ = GOOGLE_LONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisIndexBoundPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisIndexBoundPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int64 index = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_index();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &index_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisIndexBoundPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisIndexBoundPB)
  return false;
#undef DO_
}

void RedisIndexBoundPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisIndexBoundPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required int64 index = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->index(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisIndexBoundPB)
}

::google::protobuf::uint8* RedisIndexBoundPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisIndexBoundPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required int64 index = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->index(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisIndexBoundPB)
  return target;
}

size_t RedisIndexBoundPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisIndexBoundPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // required int64 index = 1;
  if (has_index()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->index());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisIndexBoundPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisIndexBoundPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisIndexBoundPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisIndexBoundPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisIndexBoundPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisIndexBoundPB)
    MergeFrom(*source);
  }
}

void RedisIndexBoundPB::MergeFrom(const RedisIndexBoundPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisIndexBoundPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_index()) {
    set_index(from.index());
  }
}

void RedisIndexBoundPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisIndexBoundPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisIndexBoundPB::CopyFrom(const RedisIndexBoundPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisIndexBoundPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisIndexBoundPB::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  return true;
}

void RedisIndexBoundPB::Swap(RedisIndexBoundPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisIndexBoundPB::InternalSwap(RedisIndexBoundPB* other) {
  using std::swap;
  swap(index_, other->index_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisIndexBoundPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisSubKeyBoundPB::InitAsDefaultInstance() {
  ::yb::_RedisSubKeyBoundPB_default_instance_._instance.get_mutable()->subkey_bound_ = const_cast< ::yb::RedisKeyValueSubKeyPB*>(
      ::yb::RedisKeyValueSubKeyPB::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisSubKeyBoundPB::kSubkeyBoundFieldNumber;
const int RedisSubKeyBoundPB::kInfinityTypeFieldNumber;
const int RedisSubKeyBoundPB::kIsExclusiveFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisSubKeyBoundPB::RedisSubKeyBoundPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSubKeyBoundPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisSubKeyBoundPB)
}
RedisSubKeyBoundPB::RedisSubKeyBoundPB(const RedisSubKeyBoundPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_subkey_bound()) {
    subkey_bound_ = new ::yb::RedisKeyValueSubKeyPB(*from.subkey_bound_);
  } else {
    subkey_bound_ = NULL;
  }
  ::memcpy(&is_exclusive_, &from.is_exclusive_,
    static_cast<size_t>(reinterpret_cast<char*>(&infinity_type_) -
    reinterpret_cast<char*>(&is_exclusive_)) + sizeof(infinity_type_));
  // @@protoc_insertion_point(copy_constructor:yb.RedisSubKeyBoundPB)
}

void RedisSubKeyBoundPB::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&subkey_bound_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&is_exclusive_) -
      reinterpret_cast<char*>(&subkey_bound_)) + sizeof(is_exclusive_));
  infinity_type_ = 1;
}

RedisSubKeyBoundPB::~RedisSubKeyBoundPB() {
  // @@protoc_insertion_point(destructor:yb.RedisSubKeyBoundPB)
  SharedDtor();
}

void RedisSubKeyBoundPB::SharedDtor() {
  if (this != internal_default_instance()) delete subkey_bound_;
}

void RedisSubKeyBoundPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisSubKeyBoundPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisSubKeyBoundPB& RedisSubKeyBoundPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSubKeyBoundPB();
  return *internal_default_instance();
}

RedisSubKeyBoundPB* RedisSubKeyBoundPB::New(::google::protobuf::Arena* arena) const {
  RedisSubKeyBoundPB* n = new RedisSubKeyBoundPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisSubKeyBoundPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisSubKeyBoundPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(subkey_bound_ != NULL);
    subkey_bound_->Clear();
  }
  if (cached_has_bits & 6u) {
    is_exclusive_ = false;
    infinity_type_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisSubKeyBoundPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisSubKeyBoundPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.RedisKeyValueSubKeyPB subkey_bound = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_subkey_bound()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisSubKeyBoundPB.InfinityType infinity_type = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::RedisSubKeyBoundPB_InfinityType_IsValid(value)) {
            set_infinity_type(static_cast< ::yb::RedisSubKeyBoundPB_InfinityType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                4, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_exclusive = 6 [default = false];
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          set_has_is_exclusive();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_exclusive_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisSubKeyBoundPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisSubKeyBoundPB)
  return false;
#undef DO_
}

void RedisSubKeyBoundPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisSubKeyBoundPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisKeyValueSubKeyPB subkey_bound = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, *this->subkey_bound_, output);
  }

  // optional .yb.RedisSubKeyBoundPB.InfinityType infinity_type = 4;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->infinity_type(), output);
  }

  // optional bool is_exclusive = 6 [default = false];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->is_exclusive(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisSubKeyBoundPB)
}

::google::protobuf::uint8* RedisSubKeyBoundPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisSubKeyBoundPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisKeyValueSubKeyPB subkey_bound = 3;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        3, *this->subkey_bound_, deterministic, target);
  }

  // optional .yb.RedisSubKeyBoundPB.InfinityType infinity_type = 4;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      4, this->infinity_type(), target);
  }

  // optional bool is_exclusive = 6 [default = false];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->is_exclusive(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisSubKeyBoundPB)
  return target;
}

size_t RedisSubKeyBoundPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisSubKeyBoundPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional .yb.RedisKeyValueSubKeyPB subkey_bound = 3;
    if (has_subkey_bound()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->subkey_bound_);
    }

    // optional bool is_exclusive = 6 [default = false];
    if (has_is_exclusive()) {
      total_size += 1 + 1;
    }

    // optional .yb.RedisSubKeyBoundPB.InfinityType infinity_type = 4;
    if (has_infinity_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->infinity_type());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisSubKeyBoundPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisSubKeyBoundPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisSubKeyBoundPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisSubKeyBoundPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisSubKeyBoundPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisSubKeyBoundPB)
    MergeFrom(*source);
  }
}

void RedisSubKeyBoundPB::MergeFrom(const RedisSubKeyBoundPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisSubKeyBoundPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_subkey_bound()->::yb::RedisKeyValueSubKeyPB::MergeFrom(from.subkey_bound());
    }
    if (cached_has_bits & 0x00000002u) {
      is_exclusive_ = from.is_exclusive_;
    }
    if (cached_has_bits & 0x00000004u) {
      infinity_type_ = from.infinity_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RedisSubKeyBoundPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisSubKeyBoundPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisSubKeyBoundPB::CopyFrom(const RedisSubKeyBoundPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisSubKeyBoundPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisSubKeyBoundPB::IsInitialized() const {
  return true;
}

void RedisSubKeyBoundPB::Swap(RedisSubKeyBoundPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisSubKeyBoundPB::InternalSwap(RedisSubKeyBoundPB* other) {
  using std::swap;
  swap(subkey_bound_, other->subkey_bound_);
  swap(is_exclusive_, other->is_exclusive_);
  swap(infinity_type_, other->infinity_type_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisSubKeyBoundPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisKeyValueSubKeyPB::InitAsDefaultInstance() {
  ::yb::_RedisKeyValueSubKeyPB_default_instance_.string_subkey_.UnsafeSetDefault(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::yb::_RedisKeyValueSubKeyPB_default_instance_.timestamp_subkey_ = GOOGLE_LONGLONG(0);
  ::yb::_RedisKeyValueSubKeyPB_default_instance_.double_subkey_ = 0;
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisKeyValueSubKeyPB::kStringSubkeyFieldNumber;
const int RedisKeyValueSubKeyPB::kTimestampSubkeyFieldNumber;
const int RedisKeyValueSubKeyPB::kDoubleSubkeyFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisKeyValueSubKeyPB::RedisKeyValueSubKeyPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisKeyValueSubKeyPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisKeyValueSubKeyPB)
}
RedisKeyValueSubKeyPB::RedisKeyValueSubKeyPB(const RedisKeyValueSubKeyPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  clear_has_subkey();
  switch (from.subkey_case()) {
    case kStringSubkey: {
      set_string_subkey(from.string_subkey());
      break;
    }
    case kTimestampSubkey: {
      set_timestamp_subkey(from.timestamp_subkey());
      break;
    }
    case kDoubleSubkey: {
      set_double_subkey(from.double_subkey());
      break;
    }
    case SUBKEY_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:yb.RedisKeyValueSubKeyPB)
}

void RedisKeyValueSubKeyPB::SharedCtor() {
  _cached_size_ = 0;
  clear_has_subkey();
}

RedisKeyValueSubKeyPB::~RedisKeyValueSubKeyPB() {
  // @@protoc_insertion_point(destructor:yb.RedisKeyValueSubKeyPB)
  SharedDtor();
}

void RedisKeyValueSubKeyPB::SharedDtor() {
  if (has_subkey()) {
    clear_subkey();
  }
}

void RedisKeyValueSubKeyPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisKeyValueSubKeyPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisKeyValueSubKeyPB& RedisKeyValueSubKeyPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisKeyValueSubKeyPB();
  return *internal_default_instance();
}

RedisKeyValueSubKeyPB* RedisKeyValueSubKeyPB::New(::google::protobuf::Arena* arena) const {
  RedisKeyValueSubKeyPB* n = new RedisKeyValueSubKeyPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisKeyValueSubKeyPB::clear_subkey() {
// @@protoc_insertion_point(one_of_clear_start:yb.RedisKeyValueSubKeyPB)
  switch (subkey_case()) {
    case kStringSubkey: {
      subkey_.string_subkey_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case kTimestampSubkey: {
      // No need to clear
      break;
    }
    case kDoubleSubkey: {
      // No need to clear
      break;
    }
    case SUBKEY_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = SUBKEY_NOT_SET;
}


void RedisKeyValueSubKeyPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisKeyValueSubKeyPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_subkey();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisKeyValueSubKeyPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisKeyValueSubKeyPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes string_subkey = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_string_subkey()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 timestamp_subkey = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          clear_subkey();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &subkey_.timestamp_subkey_)));
          set_has_timestamp_subkey();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional double double_subkey = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(25u /* 25 & 0xFF */)) {
          clear_subkey();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &subkey_.double_subkey_)));
          set_has_double_subkey();
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisKeyValueSubKeyPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisKeyValueSubKeyPB)
  return false;
#undef DO_
}

void RedisKeyValueSubKeyPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisKeyValueSubKeyPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (subkey_case()) {
    case kStringSubkey:
      ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
        1, this->string_subkey(), output);
      break;
    case kTimestampSubkey:
      ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->timestamp_subkey(), output);
      break;
    case kDoubleSubkey:
      ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->double_subkey(), output);
      break;
    default: ;
  }
  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisKeyValueSubKeyPB)
}

::google::protobuf::uint8* RedisKeyValueSubKeyPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisKeyValueSubKeyPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (subkey_case()) {
    case kStringSubkey:
      target =
        ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
          1, this->string_subkey(), target);
      break;
    case kTimestampSubkey:
      target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->timestamp_subkey(), target);
      break;
    case kDoubleSubkey:
      target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(3, this->double_subkey(), target);
      break;
    default: ;
  }
  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisKeyValueSubKeyPB)
  return target;
}

size_t RedisKeyValueSubKeyPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisKeyValueSubKeyPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  switch (subkey_case()) {
    // optional bytes string_subkey = 1;
    case kStringSubkey: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->string_subkey());
      break;
    }
    // optional int64 timestamp_subkey = 2;
    case kTimestampSubkey: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->timestamp_subkey());
      break;
    }
    // optional double double_subkey = 3;
    case kDoubleSubkey: {
      total_size += 1 + 8;
      break;
    }
    case SUBKEY_NOT_SET: {
      break;
    }
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisKeyValueSubKeyPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisKeyValueSubKeyPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisKeyValueSubKeyPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisKeyValueSubKeyPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisKeyValueSubKeyPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisKeyValueSubKeyPB)
    MergeFrom(*source);
  }
}

void RedisKeyValueSubKeyPB::MergeFrom(const RedisKeyValueSubKeyPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisKeyValueSubKeyPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.subkey_case()) {
    case kStringSubkey: {
      set_string_subkey(from.string_subkey());
      break;
    }
    case kTimestampSubkey: {
      set_timestamp_subkey(from.timestamp_subkey());
      break;
    }
    case kDoubleSubkey: {
      set_double_subkey(from.double_subkey());
      break;
    }
    case SUBKEY_NOT_SET: {
      break;
    }
  }
}

void RedisKeyValueSubKeyPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisKeyValueSubKeyPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisKeyValueSubKeyPB::CopyFrom(const RedisKeyValueSubKeyPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisKeyValueSubKeyPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisKeyValueSubKeyPB::IsInitialized() const {
  return true;
}

void RedisKeyValueSubKeyPB::Swap(RedisKeyValueSubKeyPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisKeyValueSubKeyPB::InternalSwap(RedisKeyValueSubKeyPB* other) {
  using std::swap;
  swap(subkey_, other->subkey_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisKeyValueSubKeyPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisKeyValuePB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisKeyValuePB::kHashCodeFieldNumber;
const int RedisKeyValuePB::kKeyFieldNumber;
const int RedisKeyValuePB::kTypeFieldNumber;
const int RedisKeyValuePB::kSubkeyFieldNumber;
const int RedisKeyValuePB::kIndexFieldNumber;
const int RedisKeyValuePB::kValueFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisKeyValuePB::RedisKeyValuePB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisKeyValuePB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisKeyValuePB)
}
RedisKeyValuePB::RedisKeyValuePB(const RedisKeyValuePB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      subkey_(from.subkey_),
      value_(from.value_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_key()) {
    key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_);
  }
  ::memcpy(&hash_code_, &from.hash_code_,
    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&hash_code_)) + sizeof(type_));
  // @@protoc_insertion_point(copy_constructor:yb.RedisKeyValuePB)
}

void RedisKeyValuePB::SharedCtor() {
  _cached_size_ = 0;
  key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&hash_code_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&index_) -
      reinterpret_cast<char*>(&hash_code_)) + sizeof(index_));
  type_ = 1;
}

RedisKeyValuePB::~RedisKeyValuePB() {
  // @@protoc_insertion_point(destructor:yb.RedisKeyValuePB)
  SharedDtor();
}

void RedisKeyValuePB::SharedDtor() {
  key_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void RedisKeyValuePB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisKeyValuePB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisKeyValuePB& RedisKeyValuePB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisKeyValuePB();
  return *internal_default_instance();
}

RedisKeyValuePB* RedisKeyValuePB::New(::google::protobuf::Arena* arena) const {
  RedisKeyValuePB* n = new RedisKeyValuePB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisKeyValuePB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisKeyValuePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  subkey_.Clear();
  value_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!key_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*key_.UnsafeRawStringPointer())->clear();
  }
  if (cached_has_bits & 14u) {
    ::memset(&hash_code_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&index_) -
        reinterpret_cast<char*>(&hash_code_)) + sizeof(index_));
    type_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisKeyValuePB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisKeyValuePB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 hash_code = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_hash_code();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &hash_code_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes key = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_key()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisDataType type = 3 [default = REDIS_TYPE_NONE];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::RedisDataType_IsValid(value)) {
            set_type(static_cast< ::yb::RedisDataType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                3, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .yb.RedisKeyValueSubKeyPB subkey = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_subkey()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 index = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          set_has_index();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &index_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated bytes value = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->add_value()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisKeyValuePB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisKeyValuePB)
  return false;
#undef DO_
}

void RedisKeyValuePB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisKeyValuePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 hash_code = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->hash_code(), output);
  }

  // optional bytes key = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->key(), output);
  }

  // optional .yb.RedisDataType type = 3 [default = REDIS_TYPE_NONE];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->type(), output);
  }

  // repeated .yb.RedisKeyValueSubKeyPB subkey = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->subkey_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->subkey(static_cast<int>(i)), output);
  }

  // optional int32 index = 5;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->index(), output);
  }

  // repeated bytes value = 6;
  for (int i = 0, n = this->value_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      6, this->value(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisKeyValuePB)
}

::google::protobuf::uint8* RedisKeyValuePB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisKeyValuePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 hash_code = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->hash_code(), target);
  }

  // optional bytes key = 2;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->key(), target);
  }

  // optional .yb.RedisDataType type = 3 [default = REDIS_TYPE_NONE];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->type(), target);
  }

  // repeated .yb.RedisKeyValueSubKeyPB subkey = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->subkey_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        4, this->subkey(static_cast<int>(i)), deterministic, target);
  }

  // optional int32 index = 5;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->index(), target);
  }

  // repeated bytes value = 6;
  for (int i = 0, n = this->value_size(); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteBytesToArray(6, this->value(i), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisKeyValuePB)
  return target;
}

size_t RedisKeyValuePB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisKeyValuePB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .yb.RedisKeyValueSubKeyPB subkey = 4;
  {
    unsigned int count = static_cast<unsigned int>(this->subkey_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->subkey(static_cast<int>(i)));
    }
  }

  // repeated bytes value = 6;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->value_size());
  for (int i = 0, n = this->value_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
      this->value(i));
  }

  if (_has_bits_[0 / 32] & 15u) {
    // optional bytes key = 2;
    if (has_key()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->key());
    }

    // optional uint32 hash_code = 1;
    if (has_hash_code()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->hash_code());
    }

    // optional int32 index = 5;
    if (has_index()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->index());
    }

    // optional .yb.RedisDataType type = 3 [default = REDIS_TYPE_NONE];
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisKeyValuePB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisKeyValuePB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisKeyValuePB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisKeyValuePB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisKeyValuePB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisKeyValuePB)
    MergeFrom(*source);
  }
}

void RedisKeyValuePB::MergeFrom(const RedisKeyValuePB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisKeyValuePB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  subkey_.MergeFrom(from.subkey_);
  value_.MergeFrom(from.value_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_key();
      key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_);
    }
    if (cached_has_bits & 0x00000002u) {
      hash_code_ = from.hash_code_;
    }
    if (cached_has_bits & 0x00000004u) {
      index_ = from.index_;
    }
    if (cached_has_bits & 0x00000008u) {
      type_ = from.type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RedisKeyValuePB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisKeyValuePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisKeyValuePB::CopyFrom(const RedisKeyValuePB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisKeyValuePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisKeyValuePB::IsInitialized() const {
  return true;
}

void RedisKeyValuePB::Swap(RedisKeyValuePB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisKeyValuePB::InternalSwap(RedisKeyValuePB* other) {
  using std::swap;
  subkey_.InternalSwap(&other->subkey_);
  value_.InternalSwap(&other->value_);
  key_.Swap(&other->key_);
  swap(hash_code_, other->hash_code_);
  swap(index_, other->index_);
  swap(type_, other->type_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisKeyValuePB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void SortedSetOptionsPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SortedSetOptionsPB::kUpdateOptionsFieldNumber;
const int SortedSetOptionsPB::kChFieldNumber;
const int SortedSetOptionsPB::kIncrFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SortedSetOptionsPB::SortedSetOptionsPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsSortedSetOptionsPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.SortedSetOptionsPB)
}
SortedSetOptionsPB::SortedSetOptionsPB(const SortedSetOptionsPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&ch_, &from.ch_,
    static_cast<size_t>(reinterpret_cast<char*>(&update_options_) -
    reinterpret_cast<char*>(&ch_)) + sizeof(update_options_));
  // @@protoc_insertion_point(copy_constructor:yb.SortedSetOptionsPB)
}

void SortedSetOptionsPB::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&ch_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&incr_) -
      reinterpret_cast<char*>(&ch_)) + sizeof(incr_));
  update_options_ = 3;
}

SortedSetOptionsPB::~SortedSetOptionsPB() {
  // @@protoc_insertion_point(destructor:yb.SortedSetOptionsPB)
  SharedDtor();
}

void SortedSetOptionsPB::SharedDtor() {
}

void SortedSetOptionsPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SortedSetOptionsPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const SortedSetOptionsPB& SortedSetOptionsPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsSortedSetOptionsPB();
  return *internal_default_instance();
}

SortedSetOptionsPB* SortedSetOptionsPB::New(::google::protobuf::Arena* arena) const {
  SortedSetOptionsPB* n = new SortedSetOptionsPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void SortedSetOptionsPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.SortedSetOptionsPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&ch_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&incr_) -
      reinterpret_cast<char*>(&ch_)) + sizeof(incr_));
  update_options_ = 3;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SortedSetOptionsPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.SortedSetOptionsPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.SortedSetOptionsPB.UpdateOptions update_options = 4 [default = NONE];
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::SortedSetOptionsPB_UpdateOptions_IsValid(value)) {
            set_update_options(static_cast< ::yb::SortedSetOptionsPB_UpdateOptions >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                4, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool ch = 5 [default = false];
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
          set_has_ch();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ch_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool incr = 6 [default = false];
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          set_has_incr();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &incr_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.SortedSetOptionsPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.SortedSetOptionsPB)
  return false;
#undef DO_
}

void SortedSetOptionsPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.SortedSetOptionsPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.SortedSetOptionsPB.UpdateOptions update_options = 4 [default = NONE];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->update_options(), output);
  }

  // optional bool ch = 5 [default = false];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->ch(), output);
  }

  // optional bool incr = 6 [default = false];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->incr(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.SortedSetOptionsPB)
}

::google::protobuf::uint8* SortedSetOptionsPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.SortedSetOptionsPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.SortedSetOptionsPB.UpdateOptions update_options = 4 [default = NONE];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      4, this->update_options(), target);
  }

  // optional bool ch = 5 [default = false];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->ch(), target);
  }

  // optional bool incr = 6 [default = false];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->incr(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.SortedSetOptionsPB)
  return target;
}

size_t SortedSetOptionsPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.SortedSetOptionsPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional bool ch = 5 [default = false];
    if (has_ch()) {
      total_size += 1 + 1;
    }

    // optional bool incr = 6 [default = false];
    if (has_incr()) {
      total_size += 1 + 1;
    }

    // optional .yb.SortedSetOptionsPB.UpdateOptions update_options = 4 [default = NONE];
    if (has_update_options()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->update_options());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SortedSetOptionsPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.SortedSetOptionsPB)
  GOOGLE_DCHECK_NE(&from, this);
  const SortedSetOptionsPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const SortedSetOptionsPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.SortedSetOptionsPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.SortedSetOptionsPB)
    MergeFrom(*source);
  }
}

void SortedSetOptionsPB::MergeFrom(const SortedSetOptionsPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.SortedSetOptionsPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      ch_ = from.ch_;
    }
    if (cached_has_bits & 0x00000002u) {
      incr_ = from.incr_;
    }
    if (cached_has_bits & 0x00000004u) {
      update_options_ = from.update_options_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void SortedSetOptionsPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.SortedSetOptionsPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SortedSetOptionsPB::CopyFrom(const SortedSetOptionsPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.SortedSetOptionsPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SortedSetOptionsPB::IsInitialized() const {
  return true;
}

void SortedSetOptionsPB::Swap(SortedSetOptionsPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SortedSetOptionsPB::InternalSwap(SortedSetOptionsPB* other) {
  using std::swap;
  swap(ch_, other->ch_);
  swap(incr_, other->incr_);
  swap(update_options_, other->update_options_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata SortedSetOptionsPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisSetRequestPB::InitAsDefaultInstance() {
  ::yb::_RedisSetRequestPB_default_instance_._instance.get_mutable()->sorted_set_options_ = const_cast< ::yb::SortedSetOptionsPB*>(
      ::yb::SortedSetOptionsPB::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisSetRequestPB::kExpectOkResponseFieldNumber;
const int RedisSetRequestPB::kTtlFieldNumber;
const int RedisSetRequestPB::kModeFieldNumber;
const int RedisSetRequestPB::kSortedSetOptionsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisSetRequestPB::RedisSetRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSetRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisSetRequestPB)
}
RedisSetRequestPB::RedisSetRequestPB(const RedisSetRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_sorted_set_options()) {
    sorted_set_options_ = new ::yb::SortedSetOptionsPB(*from.sorted_set_options_);
  } else {
    sorted_set_options_ = NULL;
  }
  ::memcpy(&expect_ok_response_, &from.expect_ok_response_,
    static_cast<size_t>(reinterpret_cast<char*>(&ttl_) -
    reinterpret_cast<char*>(&expect_ok_response_)) + sizeof(ttl_));
  // @@protoc_insertion_point(copy_constructor:yb.RedisSetRequestPB)
}

void RedisSetRequestPB::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&sorted_set_options_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&expect_ok_response_) -
      reinterpret_cast<char*>(&sorted_set_options_)) + sizeof(expect_ok_response_));
  mode_ = 1;
  ttl_ = GOOGLE_LONGLONG(-1);
}

RedisSetRequestPB::~RedisSetRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisSetRequestPB)
  SharedDtor();
}

void RedisSetRequestPB::SharedDtor() {
  if (this != internal_default_instance()) delete sorted_set_options_;
}

void RedisSetRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisSetRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisSetRequestPB& RedisSetRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSetRequestPB();
  return *internal_default_instance();
}

RedisSetRequestPB* RedisSetRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisSetRequestPB* n = new RedisSetRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisSetRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisSetRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(sorted_set_options_ != NULL);
    sorted_set_options_->Clear();
  }
  if (cached_has_bits & 14u) {
    expect_ok_response_ = false;
    mode_ = 1;
    ttl_ = GOOGLE_LONGLONG(-1);
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisSetRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisSetRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool expect_ok_response = 1 [default = false];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_expect_ok_response();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &expect_ok_response_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 ttl = 2 [default = -1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_ttl();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &ttl_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisWriteMode mode = 3 [default = REDIS_WRITEMODE_UPSERT];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::RedisWriteMode_IsValid(value)) {
            set_mode(static_cast< ::yb::RedisWriteMode >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                3, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.SortedSetOptionsPB sorted_set_options = 14;
      case 14: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(114u /* 114 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_sorted_set_options()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisSetRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisSetRequestPB)
  return false;
#undef DO_
}

void RedisSetRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisSetRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool expect_ok_response = 1 [default = false];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->expect_ok_response(), output);
  }

  // optional int64 ttl = 2 [default = -1];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->ttl(), output);
  }

  // optional .yb.RedisWriteMode mode = 3 [default = REDIS_WRITEMODE_UPSERT];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->mode(), output);
  }

  // optional .yb.SortedSetOptionsPB sorted_set_options = 14;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      14, *this->sorted_set_options_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisSetRequestPB)
}

::google::protobuf::uint8* RedisSetRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisSetRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool expect_ok_response = 1 [default = false];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->expect_ok_response(), target);
  }

  // optional int64 ttl = 2 [default = -1];
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->ttl(), target);
  }

  // optional .yb.RedisWriteMode mode = 3 [default = REDIS_WRITEMODE_UPSERT];
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->mode(), target);
  }

  // optional .yb.SortedSetOptionsPB sorted_set_options = 14;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        14, *this->sorted_set_options_, deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisSetRequestPB)
  return target;
}

size_t RedisSetRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisSetRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 15u) {
    // optional .yb.SortedSetOptionsPB sorted_set_options = 14;
    if (has_sorted_set_options()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *this->sorted_set_options_);
    }

    // optional bool expect_ok_response = 1 [default = false];
    if (has_expect_ok_response()) {
      total_size += 1 + 1;
    }

    // optional .yb.RedisWriteMode mode = 3 [default = REDIS_WRITEMODE_UPSERT];
    if (has_mode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->mode());
    }

    // optional int64 ttl = 2 [default = -1];
    if (has_ttl()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->ttl());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisSetRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisSetRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisSetRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisSetRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisSetRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisSetRequestPB)
    MergeFrom(*source);
  }
}

void RedisSetRequestPB::MergeFrom(const RedisSetRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisSetRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_sorted_set_options()->::yb::SortedSetOptionsPB::MergeFrom(from.sorted_set_options());
    }
    if (cached_has_bits & 0x00000002u) {
      expect_ok_response_ = from.expect_ok_response_;
    }
    if (cached_has_bits & 0x00000004u) {
      mode_ = from.mode_;
    }
    if (cached_has_bits & 0x00000008u) {
      ttl_ = from.ttl_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RedisSetRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisSetRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisSetRequestPB::CopyFrom(const RedisSetRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisSetRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisSetRequestPB::IsInitialized() const {
  return true;
}

void RedisSetRequestPB::Swap(RedisSetRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisSetRequestPB::InternalSwap(RedisSetRequestPB* other) {
  using std::swap;
  swap(sorted_set_options_, other->sorted_set_options_);
  swap(expect_ok_response_, other->expect_ok_response_);
  swap(mode_, other->mode_);
  swap(ttl_, other->ttl_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisSetRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisGetRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisGetRequestPB::kRequestTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisGetRequestPB::RedisGetRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisGetRequestPB)
}
RedisGetRequestPB::RedisGetRequestPB(const RedisGetRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  request_type_ = from.request_type_;
  // @@protoc_insertion_point(copy_constructor:yb.RedisGetRequestPB)
}

void RedisGetRequestPB::SharedCtor() {
  _cached_size_ = 0;
  request_type_ = 1;
}

RedisGetRequestPB::~RedisGetRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisGetRequestPB)
  SharedDtor();
}

void RedisGetRequestPB::SharedDtor() {
}

void RedisGetRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisGetRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisGetRequestPB& RedisGetRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetRequestPB();
  return *internal_default_instance();
}

RedisGetRequestPB* RedisGetRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisGetRequestPB* n = new RedisGetRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisGetRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisGetRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  request_type_ = 1;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisGetRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisGetRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.RedisGetRequestPB.GetRequestType request_type = 1 [default = GET];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::RedisGetRequestPB_GetRequestType_IsValid(value)) {
            set_request_type(static_cast< ::yb::RedisGetRequestPB_GetRequestType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisGetRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisGetRequestPB)
  return false;
#undef DO_
}

void RedisGetRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisGetRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisGetRequestPB.GetRequestType request_type = 1 [default = GET];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->request_type(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisGetRequestPB)
}

::google::protobuf::uint8* RedisGetRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisGetRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisGetRequestPB.GetRequestType request_type = 1 [default = GET];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->request_type(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisGetRequestPB)
  return target;
}

size_t RedisGetRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisGetRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional .yb.RedisGetRequestPB.GetRequestType request_type = 1 [default = GET];
  if (has_request_type()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->request_type());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisGetRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisGetRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisGetRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisGetRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisGetRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisGetRequestPB)
    MergeFrom(*source);
  }
}

void RedisGetRequestPB::MergeFrom(const RedisGetRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisGetRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_request_type()) {
    set_request_type(from.request_type());
  }
}

void RedisGetRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisGetRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisGetRequestPB::CopyFrom(const RedisGetRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisGetRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisGetRequestPB::IsInitialized() const {
  return true;
}

void RedisGetRequestPB::Swap(RedisGetRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisGetRequestPB::InternalSwap(RedisGetRequestPB* other) {
  using std::swap;
  swap(request_type_, other->request_type_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisGetRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisCollectionGetRangeRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisCollectionGetRangeRequestPB::kRequestTypeFieldNumber;
const int RedisCollectionGetRangeRequestPB::kWithScoresFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisCollectionGetRangeRequestPB::RedisCollectionGetRangeRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisCollectionGetRangeRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisCollectionGetRangeRequestPB)
}
RedisCollectionGetRangeRequestPB::RedisCollectionGetRangeRequestPB(const RedisCollectionGetRangeRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&with_scores_, &from.with_scores_,
    static_cast<size_t>(reinterpret_cast<char*>(&request_type_) -
    reinterpret_cast<char*>(&with_scores_)) + sizeof(request_type_));
  // @@protoc_insertion_point(copy_constructor:yb.RedisCollectionGetRangeRequestPB)
}

void RedisCollectionGetRangeRequestPB::SharedCtor() {
  _cached_size_ = 0;
  with_scores_ = false;
  request_type_ = 1;
}

RedisCollectionGetRangeRequestPB::~RedisCollectionGetRangeRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisCollectionGetRangeRequestPB)
  SharedDtor();
}

void RedisCollectionGetRangeRequestPB::SharedDtor() {
}

void RedisCollectionGetRangeRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisCollectionGetRangeRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisCollectionGetRangeRequestPB& RedisCollectionGetRangeRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisCollectionGetRangeRequestPB();
  return *internal_default_instance();
}

RedisCollectionGetRangeRequestPB* RedisCollectionGetRangeRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisCollectionGetRangeRequestPB* n = new RedisCollectionGetRangeRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisCollectionGetRangeRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisCollectionGetRangeRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    with_scores_ = false;
    request_type_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisCollectionGetRangeRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisCollectionGetRangeRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.RedisCollectionGetRangeRequestPB.GetRangeRequestType request_type = 1 [default = TSRANGEBYTIME];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::RedisCollectionGetRangeRequestPB_GetRangeRequestType_IsValid(value)) {
            set_request_type(static_cast< ::yb::RedisCollectionGetRangeRequestPB_GetRangeRequestType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool with_scores = 2 [default = false];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_with_scores();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &with_scores_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisCollectionGetRangeRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisCollectionGetRangeRequestPB)
  return false;
#undef DO_
}

void RedisCollectionGetRangeRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisCollectionGetRangeRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisCollectionGetRangeRequestPB.GetRangeRequestType request_type = 1 [default = TSRANGEBYTIME];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->request_type(), output);
  }

  // optional bool with_scores = 2 [default = false];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->with_scores(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisCollectionGetRangeRequestPB)
}

::google::protobuf::uint8* RedisCollectionGetRangeRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisCollectionGetRangeRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisCollectionGetRangeRequestPB.GetRangeRequestType request_type = 1 [default = TSRANGEBYTIME];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->request_type(), target);
  }

  // optional bool with_scores = 2 [default = false];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->with_scores(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisCollectionGetRangeRequestPB)
  return target;
}

size_t RedisCollectionGetRangeRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisCollectionGetRangeRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional bool with_scores = 2 [default = false];
    if (has_with_scores()) {
      total_size += 1 + 1;
    }

    // optional .yb.RedisCollectionGetRangeRequestPB.GetRangeRequestType request_type = 1 [default = TSRANGEBYTIME];
    if (has_request_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->request_type());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisCollectionGetRangeRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisCollectionGetRangeRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisCollectionGetRangeRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisCollectionGetRangeRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisCollectionGetRangeRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisCollectionGetRangeRequestPB)
    MergeFrom(*source);
  }
}

void RedisCollectionGetRangeRequestPB::MergeFrom(const RedisCollectionGetRangeRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisCollectionGetRangeRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      with_scores_ = from.with_scores_;
    }
    if (cached_has_bits & 0x00000002u) {
      request_type_ = from.request_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RedisCollectionGetRangeRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisCollectionGetRangeRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisCollectionGetRangeRequestPB::CopyFrom(const RedisCollectionGetRangeRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisCollectionGetRangeRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisCollectionGetRangeRequestPB::IsInitialized() const {
  return true;
}

void RedisCollectionGetRangeRequestPB::Swap(RedisCollectionGetRangeRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisCollectionGetRangeRequestPB::InternalSwap(RedisCollectionGetRangeRequestPB* other) {
  using std::swap;
  swap(with_scores_, other->with_scores_);
  swap(request_type_, other->request_type_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisCollectionGetRangeRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisNoOpRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisNoOpRequestPB::RedisNoOpRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisNoOpRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisNoOpRequestPB)
}
RedisNoOpRequestPB::RedisNoOpRequestPB(const RedisNoOpRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:yb.RedisNoOpRequestPB)
}

void RedisNoOpRequestPB::SharedCtor() {
  _cached_size_ = 0;
}

RedisNoOpRequestPB::~RedisNoOpRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisNoOpRequestPB)
  SharedDtor();
}

void RedisNoOpRequestPB::SharedDtor() {
}

void RedisNoOpRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisNoOpRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisNoOpRequestPB& RedisNoOpRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisNoOpRequestPB();
  return *internal_default_instance();
}

RedisNoOpRequestPB* RedisNoOpRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisNoOpRequestPB* n = new RedisNoOpRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisNoOpRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisNoOpRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisNoOpRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisNoOpRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisNoOpRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisNoOpRequestPB)
  return false;
#undef DO_
}

void RedisNoOpRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisNoOpRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisNoOpRequestPB)
}

::google::protobuf::uint8* RedisNoOpRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisNoOpRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisNoOpRequestPB)
  return target;
}

size_t RedisNoOpRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisNoOpRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisNoOpRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisNoOpRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisNoOpRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisNoOpRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisNoOpRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisNoOpRequestPB)
    MergeFrom(*source);
  }
}

void RedisNoOpRequestPB::MergeFrom(const RedisNoOpRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisNoOpRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void RedisNoOpRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisNoOpRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisNoOpRequestPB::CopyFrom(const RedisNoOpRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisNoOpRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisNoOpRequestPB::IsInitialized() const {
  return true;
}

void RedisNoOpRequestPB::Swap(RedisNoOpRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisNoOpRequestPB::InternalSwap(RedisNoOpRequestPB* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisNoOpRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisSetTtlRequestPB::InitAsDefaultInstance() {
  ::yb::_RedisSetTtlRequestPB_default_instance_.ttl_ = GOOGLE_LONGLONG(-1);
  ::yb::_RedisSetTtlRequestPB_default_instance_.absolute_time_ = GOOGLE_LONGLONG(0);
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisSetTtlRequestPB::kTtlFieldNumber;
const int RedisSetTtlRequestPB::kAbsoluteTimeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisSetTtlRequestPB::RedisSetTtlRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSetTtlRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisSetTtlRequestPB)
}
RedisSetTtlRequestPB::RedisSetTtlRequestPB(const RedisSetTtlRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  clear_has_expiration();
  switch (from.expiration_case()) {
    case kTtl: {
      set_ttl(from.ttl());
      break;
    }
    case kAbsoluteTime: {
      set_absolute_time(from.absolute_time());
      break;
    }
    case EXPIRATION_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:yb.RedisSetTtlRequestPB)
}

void RedisSetTtlRequestPB::SharedCtor() {
  _cached_size_ = 0;
  clear_has_expiration();
}

RedisSetTtlRequestPB::~RedisSetTtlRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisSetTtlRequestPB)
  SharedDtor();
}

void RedisSetTtlRequestPB::SharedDtor() {
  if (has_expiration()) {
    clear_expiration();
  }
}

void RedisSetTtlRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisSetTtlRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisSetTtlRequestPB& RedisSetTtlRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSetTtlRequestPB();
  return *internal_default_instance();
}

RedisSetTtlRequestPB* RedisSetTtlRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisSetTtlRequestPB* n = new RedisSetTtlRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisSetTtlRequestPB::clear_expiration() {
// @@protoc_insertion_point(one_of_clear_start:yb.RedisSetTtlRequestPB)
  switch (expiration_case()) {
    case kTtl: {
      // No need to clear
      break;
    }
    case kAbsoluteTime: {
      // No need to clear
      break;
    }
    case EXPIRATION_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = EXPIRATION_NOT_SET;
}


void RedisSetTtlRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisSetTtlRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_expiration();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisSetTtlRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisSetTtlRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int64 ttl = 1 [default = -1];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          clear_expiration();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &expiration_.ttl_)));
          set_has_ttl();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 absolute_time = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          clear_expiration();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &expiration_.absolute_time_)));
          set_has_absolute_time();
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisSetTtlRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisSetTtlRequestPB)
  return false;
#undef DO_
}

void RedisSetTtlRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisSetTtlRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (expiration_case()) {
    case kTtl:
      ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->ttl(), output);
      break;
    case kAbsoluteTime:
      ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->absolute_time(), output);
      break;
    default: ;
  }
  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisSetTtlRequestPB)
}

::google::protobuf::uint8* RedisSetTtlRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisSetTtlRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (expiration_case()) {
    case kTtl:
      target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->ttl(), target);
      break;
    case kAbsoluteTime:
      target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->absolute_time(), target);
      break;
    default: ;
  }
  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisSetTtlRequestPB)
  return target;
}

size_t RedisSetTtlRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisSetTtlRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  switch (expiration_case()) {
    // optional int64 ttl = 1 [default = -1];
    case kTtl: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->ttl());
      break;
    }
    // optional int64 absolute_time = 2;
    case kAbsoluteTime: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->absolute_time());
      break;
    }
    case EXPIRATION_NOT_SET: {
      break;
    }
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisSetTtlRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisSetTtlRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisSetTtlRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisSetTtlRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisSetTtlRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisSetTtlRequestPB)
    MergeFrom(*source);
  }
}

void RedisSetTtlRequestPB::MergeFrom(const RedisSetTtlRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisSetTtlRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.expiration_case()) {
    case kTtl: {
      set_ttl(from.ttl());
      break;
    }
    case kAbsoluteTime: {
      set_absolute_time(from.absolute_time());
      break;
    }
    case EXPIRATION_NOT_SET: {
      break;
    }
  }
}

void RedisSetTtlRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisSetTtlRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisSetTtlRequestPB::CopyFrom(const RedisSetTtlRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisSetTtlRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisSetTtlRequestPB::IsInitialized() const {
  return true;
}

void RedisSetTtlRequestPB::Swap(RedisSetTtlRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisSetTtlRequestPB::InternalSwap(RedisSetTtlRequestPB* other) {
  using std::swap;
  swap(expiration_, other->expiration_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisSetTtlRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisGetTtlRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisGetTtlRequestPB::kReturnSecondsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisGetTtlRequestPB::RedisGetTtlRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetTtlRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisGetTtlRequestPB)
}
RedisGetTtlRequestPB::RedisGetTtlRequestPB(const RedisGetTtlRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  return_seconds_ = from.return_seconds_;
  // @@protoc_insertion_point(copy_constructor:yb.RedisGetTtlRequestPB)
}

void RedisGetTtlRequestPB::SharedCtor() {
  _cached_size_ = 0;
  return_seconds_ = false;
}

RedisGetTtlRequestPB::~RedisGetTtlRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisGetTtlRequestPB)
  SharedDtor();
}

void RedisGetTtlRequestPB::SharedDtor() {
}

void RedisGetTtlRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisGetTtlRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisGetTtlRequestPB& RedisGetTtlRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetTtlRequestPB();
  return *internal_default_instance();
}

RedisGetTtlRequestPB* RedisGetTtlRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisGetTtlRequestPB* n = new RedisGetTtlRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisGetTtlRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisGetTtlRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  return_seconds_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisGetTtlRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisGetTtlRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool return_seconds = 1 [default = false];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_return_seconds();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &return_seconds_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisGetTtlRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisGetTtlRequestPB)
  return false;
#undef DO_
}

void RedisGetTtlRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisGetTtlRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool return_seconds = 1 [default = false];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->return_seconds(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisGetTtlRequestPB)
}

::google::protobuf::uint8* RedisGetTtlRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisGetTtlRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool return_seconds = 1 [default = false];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->return_seconds(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisGetTtlRequestPB)
  return target;
}

size_t RedisGetTtlRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisGetTtlRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional bool return_seconds = 1 [default = false];
  if (has_return_seconds()) {
    total_size += 1 + 1;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisGetTtlRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisGetTtlRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisGetTtlRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisGetTtlRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisGetTtlRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisGetTtlRequestPB)
    MergeFrom(*source);
  }
}

void RedisGetTtlRequestPB::MergeFrom(const RedisGetTtlRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisGetTtlRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_return_seconds()) {
    set_return_seconds(from.return_seconds());
  }
}

void RedisGetTtlRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisGetTtlRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisGetTtlRequestPB::CopyFrom(const RedisGetTtlRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisGetTtlRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisGetTtlRequestPB::IsInitialized() const {
  return true;
}

void RedisGetTtlRequestPB::Swap(RedisGetTtlRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisGetTtlRequestPB::InternalSwap(RedisGetTtlRequestPB* other) {
  using std::swap;
  swap(return_seconds_, other->return_seconds_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisGetTtlRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisKeysRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisKeysRequestPB::kPatternFieldNumber;
const int RedisKeysRequestPB::kThresholdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisKeysRequestPB::RedisKeysRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisKeysRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisKeysRequestPB)
}
RedisKeysRequestPB::RedisKeysRequestPB(const RedisKeysRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  pattern_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_pattern()) {
    pattern_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.pattern_);
  }
  threshold_ = from.threshold_;
  // @@protoc_insertion_point(copy_constructor:yb.RedisKeysRequestPB)
}

void RedisKeysRequestPB::SharedCtor() {
  _cached_size_ = 0;
  pattern_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  threshold_ = 0;
}

RedisKeysRequestPB::~RedisKeysRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisKeysRequestPB)
  SharedDtor();
}

void RedisKeysRequestPB::SharedDtor() {
  pattern_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void RedisKeysRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisKeysRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisKeysRequestPB& RedisKeysRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisKeysRequestPB();
  return *internal_default_instance();
}

RedisKeysRequestPB* RedisKeysRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisKeysRequestPB* n = new RedisKeysRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisKeysRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisKeysRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(!pattern_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*pattern_.UnsafeRawStringPointer())->clear();
  }
  threshold_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisKeysRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisKeysRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string pattern = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_pattern()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->pattern().data(), static_cast<int>(this->pattern().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "yb.RedisKeysRequestPB.pattern");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 threshold = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_threshold();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &threshold_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisKeysRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisKeysRequestPB)
  return false;
#undef DO_
}

void RedisKeysRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisKeysRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string pattern = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->pattern().data(), static_cast<int>(this->pattern().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "yb.RedisKeysRequestPB.pattern");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->pattern(), output);
  }

  // optional int32 threshold = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->threshold(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisKeysRequestPB)
}

::google::protobuf::uint8* RedisKeysRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisKeysRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string pattern = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->pattern().data(), static_cast<int>(this->pattern().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "yb.RedisKeysRequestPB.pattern");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->pattern(), target);
  }

  // optional int32 threshold = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->threshold(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisKeysRequestPB)
  return target;
}

size_t RedisKeysRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisKeysRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional string pattern = 1;
    if (has_pattern()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->pattern());
    }

    // optional int32 threshold = 2;
    if (has_threshold()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->threshold());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisKeysRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisKeysRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisKeysRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisKeysRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisKeysRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisKeysRequestPB)
    MergeFrom(*source);
  }
}

void RedisKeysRequestPB::MergeFrom(const RedisKeysRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisKeysRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_pattern();
      pattern_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.pattern_);
    }
    if (cached_has_bits & 0x00000002u) {
      threshold_ = from.threshold_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RedisKeysRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisKeysRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisKeysRequestPB::CopyFrom(const RedisKeysRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisKeysRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisKeysRequestPB::IsInitialized() const {
  return true;
}

void RedisKeysRequestPB::Swap(RedisKeysRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisKeysRequestPB::InternalSwap(RedisKeysRequestPB* other) {
  using std::swap;
  pattern_.Swap(&other->pattern_);
  swap(threshold_, other->threshold_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisKeysRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisGetForRenameRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisGetForRenameRequestPB::RedisGetForRenameRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetForRenameRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisGetForRenameRequestPB)
}
RedisGetForRenameRequestPB::RedisGetForRenameRequestPB(const RedisGetForRenameRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:yb.RedisGetForRenameRequestPB)
}

void RedisGetForRenameRequestPB::SharedCtor() {
  _cached_size_ = 0;
}

RedisGetForRenameRequestPB::~RedisGetForRenameRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisGetForRenameRequestPB)
  SharedDtor();
}

void RedisGetForRenameRequestPB::SharedDtor() {
}

void RedisGetForRenameRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisGetForRenameRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisGetForRenameRequestPB& RedisGetForRenameRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetForRenameRequestPB();
  return *internal_default_instance();
}

RedisGetForRenameRequestPB* RedisGetForRenameRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisGetForRenameRequestPB* n = new RedisGetForRenameRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisGetForRenameRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisGetForRenameRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisGetForRenameRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisGetForRenameRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisGetForRenameRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisGetForRenameRequestPB)
  return false;
#undef DO_
}

void RedisGetForRenameRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisGetForRenameRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisGetForRenameRequestPB)
}

::google::protobuf::uint8* RedisGetForRenameRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisGetForRenameRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisGetForRenameRequestPB)
  return target;
}

size_t RedisGetForRenameRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisGetForRenameRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisGetForRenameRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisGetForRenameRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisGetForRenameRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisGetForRenameRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisGetForRenameRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisGetForRenameRequestPB)
    MergeFrom(*source);
  }
}

void RedisGetForRenameRequestPB::MergeFrom(const RedisGetForRenameRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisGetForRenameRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void RedisGetForRenameRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisGetForRenameRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisGetForRenameRequestPB::CopyFrom(const RedisGetForRenameRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisGetForRenameRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisGetForRenameRequestPB::IsInitialized() const {
  return true;
}

void RedisGetForRenameRequestPB::Swap(RedisGetForRenameRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisGetForRenameRequestPB::InternalSwap(RedisGetForRenameRequestPB* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisGetForRenameRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisGetSetRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisGetSetRequestPB::RedisGetSetRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetSetRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisGetSetRequestPB)
}
RedisGetSetRequestPB::RedisGetSetRequestPB(const RedisGetSetRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:yb.RedisGetSetRequestPB)
}

void RedisGetSetRequestPB::SharedCtor() {
  _cached_size_ = 0;
}

RedisGetSetRequestPB::~RedisGetSetRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisGetSetRequestPB)
  SharedDtor();
}

void RedisGetSetRequestPB::SharedDtor() {
}

void RedisGetSetRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisGetSetRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisGetSetRequestPB& RedisGetSetRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetSetRequestPB();
  return *internal_default_instance();
}

RedisGetSetRequestPB* RedisGetSetRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisGetSetRequestPB* n = new RedisGetSetRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisGetSetRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisGetSetRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisGetSetRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisGetSetRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisGetSetRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisGetSetRequestPB)
  return false;
#undef DO_
}

void RedisGetSetRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisGetSetRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisGetSetRequestPB)
}

::google::protobuf::uint8* RedisGetSetRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisGetSetRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisGetSetRequestPB)
  return target;
}

size_t RedisGetSetRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisGetSetRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisGetSetRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisGetSetRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisGetSetRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisGetSetRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisGetSetRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisGetSetRequestPB)
    MergeFrom(*source);
  }
}

void RedisGetSetRequestPB::MergeFrom(const RedisGetSetRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisGetSetRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void RedisGetSetRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisGetSetRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisGetSetRequestPB::CopyFrom(const RedisGetSetRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisGetSetRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisGetSetRequestPB::IsInitialized() const {
  return true;
}

void RedisGetSetRequestPB::Swap(RedisGetSetRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisGetSetRequestPB::InternalSwap(RedisGetSetRequestPB* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisGetSetRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisAppendRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisAppendRequestPB::RedisAppendRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisAppendRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisAppendRequestPB)
}
RedisAppendRequestPB::RedisAppendRequestPB(const RedisAppendRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:yb.RedisAppendRequestPB)
}

void RedisAppendRequestPB::SharedCtor() {
  _cached_size_ = 0;
}

RedisAppendRequestPB::~RedisAppendRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisAppendRequestPB)
  SharedDtor();
}

void RedisAppendRequestPB::SharedDtor() {
}

void RedisAppendRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisAppendRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisAppendRequestPB& RedisAppendRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisAppendRequestPB();
  return *internal_default_instance();
}

RedisAppendRequestPB* RedisAppendRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisAppendRequestPB* n = new RedisAppendRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisAppendRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisAppendRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisAppendRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisAppendRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisAppendRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisAppendRequestPB)
  return false;
#undef DO_
}

void RedisAppendRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisAppendRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisAppendRequestPB)
}

::google::protobuf::uint8* RedisAppendRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisAppendRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisAppendRequestPB)
  return target;
}

size_t RedisAppendRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisAppendRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisAppendRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisAppendRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisAppendRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisAppendRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisAppendRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisAppendRequestPB)
    MergeFrom(*source);
  }
}

void RedisAppendRequestPB::MergeFrom(const RedisAppendRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisAppendRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void RedisAppendRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisAppendRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisAppendRequestPB::CopyFrom(const RedisAppendRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisAppendRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisAppendRequestPB::IsInitialized() const {
  return true;
}

void RedisAppendRequestPB::Swap(RedisAppendRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisAppendRequestPB::InternalSwap(RedisAppendRequestPB* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisAppendRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisStrLenRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisStrLenRequestPB::RedisStrLenRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisStrLenRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisStrLenRequestPB)
}
RedisStrLenRequestPB::RedisStrLenRequestPB(const RedisStrLenRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:yb.RedisStrLenRequestPB)
}

void RedisStrLenRequestPB::SharedCtor() {
  _cached_size_ = 0;
}

RedisStrLenRequestPB::~RedisStrLenRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisStrLenRequestPB)
  SharedDtor();
}

void RedisStrLenRequestPB::SharedDtor() {
}

void RedisStrLenRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisStrLenRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisStrLenRequestPB& RedisStrLenRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisStrLenRequestPB();
  return *internal_default_instance();
}

RedisStrLenRequestPB* RedisStrLenRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisStrLenRequestPB* n = new RedisStrLenRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisStrLenRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisStrLenRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisStrLenRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisStrLenRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisStrLenRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisStrLenRequestPB)
  return false;
#undef DO_
}

void RedisStrLenRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisStrLenRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisStrLenRequestPB)
}

::google::protobuf::uint8* RedisStrLenRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisStrLenRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisStrLenRequestPB)
  return target;
}

size_t RedisStrLenRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisStrLenRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisStrLenRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisStrLenRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisStrLenRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisStrLenRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisStrLenRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisStrLenRequestPB)
    MergeFrom(*source);
  }
}

void RedisStrLenRequestPB::MergeFrom(const RedisStrLenRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisStrLenRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void RedisStrLenRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisStrLenRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisStrLenRequestPB::CopyFrom(const RedisStrLenRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisStrLenRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisStrLenRequestPB::IsInitialized() const {
  return true;
}

void RedisStrLenRequestPB::Swap(RedisStrLenRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisStrLenRequestPB::InternalSwap(RedisStrLenRequestPB* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisStrLenRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisDelRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisDelRequestPB::RedisDelRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisDelRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisDelRequestPB)
}
RedisDelRequestPB::RedisDelRequestPB(const RedisDelRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:yb.RedisDelRequestPB)
}

void RedisDelRequestPB::SharedCtor() {
  _cached_size_ = 0;
}

RedisDelRequestPB::~RedisDelRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisDelRequestPB)
  SharedDtor();
}

void RedisDelRequestPB::SharedDtor() {
}

void RedisDelRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisDelRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisDelRequestPB& RedisDelRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisDelRequestPB();
  return *internal_default_instance();
}

RedisDelRequestPB* RedisDelRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisDelRequestPB* n = new RedisDelRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisDelRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisDelRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisDelRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisDelRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisDelRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisDelRequestPB)
  return false;
#undef DO_
}

void RedisDelRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisDelRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisDelRequestPB)
}

::google::protobuf::uint8* RedisDelRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisDelRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisDelRequestPB)
  return target;
}

size_t RedisDelRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisDelRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisDelRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisDelRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisDelRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisDelRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisDelRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisDelRequestPB)
    MergeFrom(*source);
  }
}

void RedisDelRequestPB::MergeFrom(const RedisDelRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisDelRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void RedisDelRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisDelRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisDelRequestPB::CopyFrom(const RedisDelRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisDelRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisDelRequestPB::IsInitialized() const {
  return true;
}

void RedisDelRequestPB::Swap(RedisDelRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisDelRequestPB::InternalSwap(RedisDelRequestPB* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisDelRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisExistsRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisExistsRequestPB::RedisExistsRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisExistsRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisExistsRequestPB)
}
RedisExistsRequestPB::RedisExistsRequestPB(const RedisExistsRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:yb.RedisExistsRequestPB)
}

void RedisExistsRequestPB::SharedCtor() {
  _cached_size_ = 0;
}

RedisExistsRequestPB::~RedisExistsRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisExistsRequestPB)
  SharedDtor();
}

void RedisExistsRequestPB::SharedDtor() {
}

void RedisExistsRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisExistsRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisExistsRequestPB& RedisExistsRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisExistsRequestPB();
  return *internal_default_instance();
}

RedisExistsRequestPB* RedisExistsRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisExistsRequestPB* n = new RedisExistsRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisExistsRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisExistsRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisExistsRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisExistsRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisExistsRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisExistsRequestPB)
  return false;
#undef DO_
}

void RedisExistsRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisExistsRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisExistsRequestPB)
}

::google::protobuf::uint8* RedisExistsRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisExistsRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisExistsRequestPB)
  return target;
}

size_t RedisExistsRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisExistsRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisExistsRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisExistsRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisExistsRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisExistsRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisExistsRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisExistsRequestPB)
    MergeFrom(*source);
  }
}

void RedisExistsRequestPB::MergeFrom(const RedisExistsRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisExistsRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void RedisExistsRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisExistsRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisExistsRequestPB::CopyFrom(const RedisExistsRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisExistsRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisExistsRequestPB::IsInitialized() const {
  return true;
}

void RedisExistsRequestPB::Swap(RedisExistsRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisExistsRequestPB::InternalSwap(RedisExistsRequestPB* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisExistsRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisSetRangeRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisSetRangeRequestPB::kOffsetFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisSetRangeRequestPB::RedisSetRangeRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSetRangeRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisSetRangeRequestPB)
}
RedisSetRangeRequestPB::RedisSetRangeRequestPB(const RedisSetRangeRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  offset_ = from.offset_;
  // @@protoc_insertion_point(copy_constructor:yb.RedisSetRangeRequestPB)
}

void RedisSetRangeRequestPB::SharedCtor() {
  _cached_size_ = 0;
  offset_ = 0;
}

RedisSetRangeRequestPB::~RedisSetRangeRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisSetRangeRequestPB)
  SharedDtor();
}

void RedisSetRangeRequestPB::SharedDtor() {
}

void RedisSetRangeRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisSetRangeRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisSetRangeRequestPB& RedisSetRangeRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisSetRangeRequestPB();
  return *internal_default_instance();
}

RedisSetRangeRequestPB* RedisSetRangeRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisSetRangeRequestPB* n = new RedisSetRangeRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisSetRangeRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisSetRangeRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  offset_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisSetRangeRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisSetRangeRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 offset = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_offset();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &offset_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisSetRangeRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisSetRangeRequestPB)
  return false;
#undef DO_
}

void RedisSetRangeRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisSetRangeRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 offset = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->offset(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisSetRangeRequestPB)
}

::google::protobuf::uint8* RedisSetRangeRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisSetRangeRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 offset = 2;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->offset(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisSetRangeRequestPB)
  return target;
}

size_t RedisSetRangeRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisSetRangeRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional int32 offset = 2;
  if (has_offset()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->offset());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisSetRangeRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisSetRangeRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisSetRangeRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisSetRangeRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisSetRangeRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisSetRangeRequestPB)
    MergeFrom(*source);
  }
}

void RedisSetRangeRequestPB::MergeFrom(const RedisSetRangeRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisSetRangeRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_offset()) {
    set_offset(from.offset());
  }
}

void RedisSetRangeRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisSetRangeRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisSetRangeRequestPB::CopyFrom(const RedisSetRangeRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisSetRangeRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisSetRangeRequestPB::IsInitialized() const {
  return true;
}

void RedisSetRangeRequestPB::Swap(RedisSetRangeRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisSetRangeRequestPB::InternalSwap(RedisSetRangeRequestPB* other) {
  using std::swap;
  swap(offset_, other->offset_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisSetRangeRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisGetRangeRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisGetRangeRequestPB::kStartFieldNumber;
const int RedisGetRangeRequestPB::kEndFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisGetRangeRequestPB::RedisGetRangeRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetRangeRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisGetRangeRequestPB)
}
RedisGetRangeRequestPB::RedisGetRangeRequestPB(const RedisGetRangeRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&start_, &from.start_,
    static_cast<size_t>(reinterpret_cast<char*>(&end_) -
    reinterpret_cast<char*>(&start_)) + sizeof(end_));
  // @@protoc_insertion_point(copy_constructor:yb.RedisGetRangeRequestPB)
}

void RedisGetRangeRequestPB::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&start_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&end_) -
      reinterpret_cast<char*>(&start_)) + sizeof(end_));
}

RedisGetRangeRequestPB::~RedisGetRangeRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisGetRangeRequestPB)
  SharedDtor();
}

void RedisGetRangeRequestPB::SharedDtor() {
}

void RedisGetRangeRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisGetRangeRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisGetRangeRequestPB& RedisGetRangeRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisGetRangeRequestPB();
  return *internal_default_instance();
}

RedisGetRangeRequestPB* RedisGetRangeRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisGetRangeRequestPB* n = new RedisGetRangeRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisGetRangeRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisGetRangeRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    ::memset(&start_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&end_) -
        reinterpret_cast<char*>(&start_)) + sizeof(end_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisGetRangeRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisGetRangeRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 start = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_start();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &start_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 end = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_end();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &end_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisGetRangeRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisGetRangeRequestPB)
  return false;
#undef DO_
}

void RedisGetRangeRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisGetRangeRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 start = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->start(), output);
  }

  // optional int32 end = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->end(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisGetRangeRequestPB)
}

::google::protobuf::uint8* RedisGetRangeRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisGetRangeRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 start = 2;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->start(), target);
  }

  // optional int32 end = 3;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->end(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisGetRangeRequestPB)
  return target;
}

size_t RedisGetRangeRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisGetRangeRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 start = 2;
    if (has_start()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->start());
    }

    // optional int32 end = 3;
    if (has_end()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->end());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisGetRangeRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisGetRangeRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisGetRangeRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisGetRangeRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisGetRangeRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisGetRangeRequestPB)
    MergeFrom(*source);
  }
}

void RedisGetRangeRequestPB::MergeFrom(const RedisGetRangeRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisGetRangeRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      start_ = from.start_;
    }
    if (cached_has_bits & 0x00000002u) {
      end_ = from.end_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RedisGetRangeRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisGetRangeRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisGetRangeRequestPB::CopyFrom(const RedisGetRangeRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisGetRangeRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisGetRangeRequestPB::IsInitialized() const {
  return true;
}

void RedisGetRangeRequestPB::Swap(RedisGetRangeRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisGetRangeRequestPB::InternalSwap(RedisGetRangeRequestPB* other) {
  using std::swap;
  swap(start_, other->start_);
  swap(end_, other->end_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisGetRangeRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisIncrRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisIncrRequestPB::kIncrementIntFieldNumber;
const int RedisIncrRequestPB::kIncrementFloatFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisIncrRequestPB::RedisIncrRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisIncrRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisIncrRequestPB)
}
RedisIncrRequestPB::RedisIncrRequestPB(const RedisIncrRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&increment_float_, &from.increment_float_,
    static_cast<size_t>(reinterpret_cast<char*>(&increment_int_) -
    reinterpret_cast<char*>(&increment_float_)) + sizeof(increment_int_));
  // @@protoc_insertion_point(copy_constructor:yb.RedisIncrRequestPB)
}

void RedisIncrRequestPB::SharedCtor() {
  _cached_size_ = 0;
  increment_float_ = 0;
  increment_int_ = GOOGLE_LONGLONG(1);
}

RedisIncrRequestPB::~RedisIncrRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisIncrRequestPB)
  SharedDtor();
}

void RedisIncrRequestPB::SharedDtor() {
}

void RedisIncrRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisIncrRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisIncrRequestPB& RedisIncrRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisIncrRequestPB();
  return *internal_default_instance();
}

RedisIncrRequestPB* RedisIncrRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisIncrRequestPB* n = new RedisIncrRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisIncrRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisIncrRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    increment_float_ = 0;
    increment_int_ = GOOGLE_LONGLONG(1);
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisIncrRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisIncrRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int64 increment_int = 2 [default = 1];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_increment_int();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &increment_int_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional double increment_float = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(25u /* 25 & 0xFF */)) {
          set_has_increment_float();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &increment_float_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisIncrRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisIncrRequestPB)
  return false;
#undef DO_
}

void RedisIncrRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisIncrRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int64 increment_int = 2 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->increment_int(), output);
  }

  // optional double increment_float = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->increment_float(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisIncrRequestPB)
}

::google::protobuf::uint8* RedisIncrRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisIncrRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int64 increment_int = 2 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->increment_int(), target);
  }

  // optional double increment_float = 3;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(3, this->increment_float(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisIncrRequestPB)
  return target;
}

size_t RedisIncrRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisIncrRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional double increment_float = 3;
    if (has_increment_float()) {
      total_size += 1 + 8;
    }

    // optional int64 increment_int = 2 [default = 1];
    if (has_increment_int()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->increment_int());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisIncrRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisIncrRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisIncrRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisIncrRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisIncrRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisIncrRequestPB)
    MergeFrom(*source);
  }
}

void RedisIncrRequestPB::MergeFrom(const RedisIncrRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisIncrRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      increment_float_ = from.increment_float_;
    }
    if (cached_has_bits & 0x00000002u) {
      increment_int_ = from.increment_int_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RedisIncrRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisIncrRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisIncrRequestPB::CopyFrom(const RedisIncrRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisIncrRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisIncrRequestPB::IsInitialized() const {
  return true;
}

void RedisIncrRequestPB::Swap(RedisIncrRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisIncrRequestPB::InternalSwap(RedisIncrRequestPB* other) {
  using std::swap;
  swap(increment_float_, other->increment_float_);
  swap(increment_int_, other->increment_int_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisIncrRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisPushRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisPushRequestPB::kSideFieldNumber;
const int RedisPushRequestPB::kCheckExistenceFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisPushRequestPB::RedisPushRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisPushRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisPushRequestPB)
}
RedisPushRequestPB::RedisPushRequestPB(const RedisPushRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&check_existence_, &from.check_existence_,
    static_cast<size_t>(reinterpret_cast<char*>(&side_) -
    reinterpret_cast<char*>(&check_existence_)) + sizeof(side_));
  // @@protoc_insertion_point(copy_constructor:yb.RedisPushRequestPB)
}

void RedisPushRequestPB::SharedCtor() {
  _cached_size_ = 0;
  check_existence_ = false;
  side_ = 1;
}

RedisPushRequestPB::~RedisPushRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisPushRequestPB)
  SharedDtor();
}

void RedisPushRequestPB::SharedDtor() {
}

void RedisPushRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisPushRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisPushRequestPB& RedisPushRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisPushRequestPB();
  return *internal_default_instance();
}

RedisPushRequestPB* RedisPushRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisPushRequestPB* n = new RedisPushRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisPushRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisPushRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    check_existence_ = false;
    side_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisPushRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisPushRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.RedisSide side = 2 [default = REDIS_SIDE_LEFT];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::RedisSide_IsValid(value)) {
            set_side(static_cast< ::yb::RedisSide >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                2, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool check_existence = 3 [default = false];
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_check_existence();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &check_existence_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisPushRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisPushRequestPB)
  return false;
#undef DO_
}

void RedisPushRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisPushRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisSide side = 2 [default = REDIS_SIDE_LEFT];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->side(), output);
  }

  // optional bool check_existence = 3 [default = false];
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->check_existence(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisPushRequestPB)
}

::google::protobuf::uint8* RedisPushRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisPushRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisSide side = 2 [default = REDIS_SIDE_LEFT];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->side(), target);
  }

  // optional bool check_existence = 3 [default = false];
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->check_existence(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisPushRequestPB)
  return target;
}

size_t RedisPushRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisPushRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional bool check_existence = 3 [default = false];
    if (has_check_existence()) {
      total_size += 1 + 1;
    }

    // optional .yb.RedisSide side = 2 [default = REDIS_SIDE_LEFT];
    if (has_side()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->side());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisPushRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisPushRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisPushRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisPushRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisPushRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisPushRequestPB)
    MergeFrom(*source);
  }
}

void RedisPushRequestPB::MergeFrom(const RedisPushRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisPushRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      check_existence_ = from.check_existence_;
    }
    if (cached_has_bits & 0x00000002u) {
      side_ = from.side_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RedisPushRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisPushRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisPushRequestPB::CopyFrom(const RedisPushRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisPushRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisPushRequestPB::IsInitialized() const {
  return true;
}

void RedisPushRequestPB::Swap(RedisPushRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisPushRequestPB::InternalSwap(RedisPushRequestPB* other) {
  using std::swap;
  swap(check_existence_, other->check_existence_);
  swap(side_, other->side_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisPushRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisInsertRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisInsertRequestPB::kOrderFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisInsertRequestPB::RedisInsertRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisInsertRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisInsertRequestPB)
}
RedisInsertRequestPB::RedisInsertRequestPB(const RedisInsertRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  order_ = from.order_;
  // @@protoc_insertion_point(copy_constructor:yb.RedisInsertRequestPB)
}

void RedisInsertRequestPB::SharedCtor() {
  _cached_size_ = 0;
  order_ = 1;
}

RedisInsertRequestPB::~RedisInsertRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisInsertRequestPB)
  SharedDtor();
}

void RedisInsertRequestPB::SharedDtor() {
}

void RedisInsertRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisInsertRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisInsertRequestPB& RedisInsertRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisInsertRequestPB();
  return *internal_default_instance();
}

RedisInsertRequestPB* RedisInsertRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisInsertRequestPB* n = new RedisInsertRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisInsertRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisInsertRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  order_ = 1;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisInsertRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisInsertRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.RedisOrder order = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::RedisOrder_IsValid(value)) {
            set_order(static_cast< ::yb::RedisOrder >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                2, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisInsertRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisInsertRequestPB)
  return false;
#undef DO_
}

void RedisInsertRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisInsertRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisOrder order = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->order(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisInsertRequestPB)
}

::google::protobuf::uint8* RedisInsertRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisInsertRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisOrder order = 2;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->order(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisInsertRequestPB)
  return target;
}

size_t RedisInsertRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisInsertRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional .yb.RedisOrder order = 2;
  if (has_order()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->order());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisInsertRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisInsertRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisInsertRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisInsertRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisInsertRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisInsertRequestPB)
    MergeFrom(*source);
  }
}

void RedisInsertRequestPB::MergeFrom(const RedisInsertRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisInsertRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_order()) {
    set_order(from.order());
  }
}

void RedisInsertRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisInsertRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisInsertRequestPB::CopyFrom(const RedisInsertRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisInsertRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisInsertRequestPB::IsInitialized() const {
  return true;
}

void RedisInsertRequestPB::Swap(RedisInsertRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisInsertRequestPB::InternalSwap(RedisInsertRequestPB* other) {
  using std::swap;
  swap(order_, other->order_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisInsertRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisPopRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisPopRequestPB::kSideFieldNumber;
const int RedisPopRequestPB::kCountFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisPopRequestPB::RedisPopRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisPopRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisPopRequestPB)
}
RedisPopRequestPB::RedisPopRequestPB(const RedisPopRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&count_, &from.count_,
    static_cast<size_t>(reinterpret_cast<char*>(&side_) -
    reinterpret_cast<char*>(&count_)) + sizeof(side_));
  // @@protoc_insertion_point(copy_constructor:yb.RedisPopRequestPB)
}

void RedisPopRequestPB::SharedCtor() {
  _cached_size_ = 0;
  count_ = 0;
  side_ = 1;
}

RedisPopRequestPB::~RedisPopRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisPopRequestPB)
  SharedDtor();
}

void RedisPopRequestPB::SharedDtor() {
}

void RedisPopRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisPopRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisPopRequestPB& RedisPopRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisPopRequestPB();
  return *internal_default_instance();
}

RedisPopRequestPB* RedisPopRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisPopRequestPB* n = new RedisPopRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisPopRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisPopRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    count_ = 0;
    side_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisPopRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisPopRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.RedisSide side = 2 [default = REDIS_SIDE_LEFT];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::RedisSide_IsValid(value)) {
            set_side(static_cast< ::yb::RedisSide >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                2, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 count = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_count();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &count_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisPopRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisPopRequestPB)
  return false;
#undef DO_
}

void RedisPopRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisPopRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisSide side = 2 [default = REDIS_SIDE_LEFT];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->side(), output);
  }

  // optional int32 count = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->count(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisPopRequestPB)
}

::google::protobuf::uint8* RedisPopRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisPopRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisSide side = 2 [default = REDIS_SIDE_LEFT];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->side(), target);
  }

  // optional int32 count = 3;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->count(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisPopRequestPB)
  return target;
}

size_t RedisPopRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisPopRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 count = 3;
    if (has_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->count());
    }

    // optional .yb.RedisSide side = 2 [default = REDIS_SIDE_LEFT];
    if (has_side()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->side());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisPopRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisPopRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisPopRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisPopRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisPopRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisPopRequestPB)
    MergeFrom(*source);
  }
}

void RedisPopRequestPB::MergeFrom(const RedisPopRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisPopRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      count_ = from.count_;
    }
    if (cached_has_bits & 0x00000002u) {
      side_ = from.side_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RedisPopRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisPopRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisPopRequestPB::CopyFrom(const RedisPopRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisPopRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisPopRequestPB::IsInitialized() const {
  return true;
}

void RedisPopRequestPB::Swap(RedisPopRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisPopRequestPB::InternalSwap(RedisPopRequestPB* other) {
  using std::swap;
  swap(count_, other->count_);
  swap(side_, other->side_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisPopRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisAddRequestPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisAddRequestPB::kModeFieldNumber;
const int RedisAddRequestPB::kChFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisAddRequestPB::RedisAddRequestPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisAddRequestPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisAddRequestPB)
}
RedisAddRequestPB::RedisAddRequestPB(const RedisAddRequestPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&ch_, &from.ch_,
    static_cast<size_t>(reinterpret_cast<char*>(&mode_) -
    reinterpret_cast<char*>(&ch_)) + sizeof(mode_));
  // @@protoc_insertion_point(copy_constructor:yb.RedisAddRequestPB)
}

void RedisAddRequestPB::SharedCtor() {
  _cached_size_ = 0;
  ch_ = false;
  mode_ = 1;
}

RedisAddRequestPB::~RedisAddRequestPB() {
  // @@protoc_insertion_point(destructor:yb.RedisAddRequestPB)
  SharedDtor();
}

void RedisAddRequestPB::SharedDtor() {
}

void RedisAddRequestPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisAddRequestPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisAddRequestPB& RedisAddRequestPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisAddRequestPB();
  return *internal_default_instance();
}

RedisAddRequestPB* RedisAddRequestPB::New(::google::protobuf::Arena* arena) const {
  RedisAddRequestPB* n = new RedisAddRequestPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisAddRequestPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisAddRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 3u) {
    ch_ = false;
    mode_ = 1;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisAddRequestPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisAddRequestPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.RedisWriteMode mode = 2 [default = REDIS_WRITEMODE_UPSERT];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::RedisWriteMode_IsValid(value)) {
            set_mode(static_cast< ::yb::RedisWriteMode >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                2, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool ch = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
          set_has_ch();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &ch_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisAddRequestPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisAddRequestPB)
  return false;
#undef DO_
}

void RedisAddRequestPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisAddRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisWriteMode mode = 2 [default = REDIS_WRITEMODE_UPSERT];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->mode(), output);
  }

  // optional bool ch = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->ch(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisAddRequestPB)
}

::google::protobuf::uint8* RedisAddRequestPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisAddRequestPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisWriteMode mode = 2 [default = REDIS_WRITEMODE_UPSERT];
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->mode(), target);
  }

  // optional bool ch = 3;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->ch(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisAddRequestPB)
  return target;
}

size_t RedisAddRequestPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisAddRequestPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 3u) {
    // optional bool ch = 3;
    if (has_ch()) {
      total_size += 1 + 1;
    }

    // optional .yb.RedisWriteMode mode = 2 [default = REDIS_WRITEMODE_UPSERT];
    if (has_mode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->mode());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisAddRequestPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisAddRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisAddRequestPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisAddRequestPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisAddRequestPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisAddRequestPB)
    MergeFrom(*source);
  }
}

void RedisAddRequestPB::MergeFrom(const RedisAddRequestPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisAddRequestPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      ch_ = from.ch_;
    }
    if (cached_has_bits & 0x00000002u) {
      mode_ = from.mode_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RedisAddRequestPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisAddRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisAddRequestPB::CopyFrom(const RedisAddRequestPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisAddRequestPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisAddRequestPB::IsInitialized() const {
  return true;
}

void RedisAddRequestPB::Swap(RedisAddRequestPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisAddRequestPB::InternalSwap(RedisAddRequestPB* other) {
  using std::swap;
  swap(ch_, other->ch_);
  swap(mode_, other->mode_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisAddRequestPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisResponsePB::InitAsDefaultInstance() {
  ::yb::_RedisResponsePB_default_instance_.int_response_ = GOOGLE_LONGLONG(0);
  ::yb::_RedisResponsePB_default_instance_.string_response_.UnsafeSetDefault(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::yb::_RedisResponsePB_default_instance_.array_response_ = const_cast< ::yb::RedisArrayPB*>(
      ::yb::RedisArrayPB::internal_default_instance());
  ::yb::_RedisResponsePB_default_instance_.status_response_.UnsafeSetDefault(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::yb::_RedisResponsePB_default_instance_.encoded_response_.UnsafeSetDefault(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void RedisResponsePB::set_allocated_array_response(::yb::RedisArrayPB* array_response) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  clear_response_data();
  if (array_response) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      array_response = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, array_response, submessage_arena);
    }
    set_has_array_response();
    response_data_.array_response_ = array_response;
  }
  // @@protoc_insertion_point(field_set_allocated:yb.RedisResponsePB.array_response)
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisResponsePB::kCodeFieldNumber;
const int RedisResponsePB::kIntResponseFieldNumber;
const int RedisResponsePB::kStringResponseFieldNumber;
const int RedisResponsePB::kArrayResponseFieldNumber;
const int RedisResponsePB::kStatusResponseFieldNumber;
const int RedisResponsePB::kEncodedResponseFieldNumber;
const int RedisResponsePB::kErrorMessageFieldNumber;
const int RedisResponsePB::kTypeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisResponsePB::RedisResponsePB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisResponsePB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisResponsePB)
}
RedisResponsePB::RedisResponsePB(const RedisResponsePB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  error_message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_error_message()) {
    error_message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.error_message_);
  }
  ::memcpy(&code_, &from.code_,
    static_cast<size_t>(reinterpret_cast<char*>(&type_) -
    reinterpret_cast<char*>(&code_)) + sizeof(type_));
  clear_has_response_data();
  switch (from.response_data_case()) {
    case kIntResponse: {
      set_int_response(from.int_response());
      break;
    }
    case kStringResponse: {
      set_string_response(from.string_response());
      break;
    }
    case kArrayResponse: {
      mutable_array_response()->::yb::RedisArrayPB::MergeFrom(from.array_response());
      break;
    }
    case kStatusResponse: {
      set_status_response(from.status_response());
      break;
    }
    case kEncodedResponse: {
      set_encoded_response(from.encoded_response());
      break;
    }
    case RESPONSE_DATA_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:yb.RedisResponsePB)
}

void RedisResponsePB::SharedCtor() {
  _cached_size_ = 0;
  error_message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  code_ = 1;
  type_ = 1;
  clear_has_response_data();
}

RedisResponsePB::~RedisResponsePB() {
  // @@protoc_insertion_point(destructor:yb.RedisResponsePB)
  SharedDtor();
}

void RedisResponsePB::SharedDtor() {
  error_message_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (has_response_data()) {
    clear_response_data();
  }
}

void RedisResponsePB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisResponsePB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisResponsePB& RedisResponsePB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisResponsePB();
  return *internal_default_instance();
}

RedisResponsePB* RedisResponsePB::New(::google::protobuf::Arena* arena) const {
  RedisResponsePB* n = new RedisResponsePB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisResponsePB::clear_response_data() {
// @@protoc_insertion_point(one_of_clear_start:yb.RedisResponsePB)
  switch (response_data_case()) {
    case kIntResponse: {
      // No need to clear
      break;
    }
    case kStringResponse: {
      response_data_.string_response_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case kArrayResponse: {
      delete response_data_.array_response_;
      break;
    }
    case kStatusResponse: {
      response_data_.status_response_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case kEncodedResponse: {
      response_data_.encoded_response_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case RESPONSE_DATA_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = RESPONSE_DATA_NOT_SET;
}


void RedisResponsePB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(!error_message_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*error_message_.UnsafeRawStringPointer())->clear();
    }
    code_ = 1;
    type_ = 1;
  }
  clear_response_data();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisResponsePB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisResponsePB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .yb.RedisResponsePB.RedisStatusCode code = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::RedisResponsePB_RedisStatusCode_IsValid(value)) {
            set_code(static_cast< ::yb::RedisResponsePB_RedisStatusCode >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 int_response = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          clear_response_data();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &response_data_.int_response_)));
          set_has_int_response();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes string_response = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_string_response()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisArrayPB array_response = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_array_response()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes status_response = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_status_response()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes error_message = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_error_message()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes encoded_response = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_encoded_response()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .yb.RedisDataType type = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::yb::RedisDataType_IsValid(value)) {
            set_type(static_cast< ::yb::RedisDataType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                8, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisResponsePB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisResponsePB)
  return false;
#undef DO_
}

void RedisResponsePB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisResponsePB.RedisStatusCode code = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->code(), output);
  }

  switch (response_data_case()) {
    case kIntResponse:
      ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->int_response(), output);
      break;
    case kStringResponse:
      ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
        3, this->string_response(), output);
      break;
    case kArrayResponse:
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        4, *response_data_.array_response_, output);
      break;
    case kStatusResponse:
      ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
        5, this->status_response(), output);
      break;
    default: ;
  }
  // optional bytes error_message = 6;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      6, this->error_message(), output);
  }

  // optional bytes encoded_response = 7;
  if (has_encoded_response()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      7, this->encoded_response(), output);
  }

  // optional .yb.RedisDataType type = 8;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      8, this->type(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisResponsePB)
}

::google::protobuf::uint8* RedisResponsePB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisResponsePB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .yb.RedisResponsePB.RedisStatusCode code = 1;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->code(), target);
  }

  switch (response_data_case()) {
    case kIntResponse:
      target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->int_response(), target);
      break;
    case kStringResponse:
      target =
        ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
          3, this->string_response(), target);
      break;
    case kArrayResponse:
      target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessageToArray(
          4, *response_data_.array_response_, deterministic, target);
      break;
    case kStatusResponse:
      target =
        ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
          5, this->status_response(), target);
      break;
    default: ;
  }
  // optional bytes error_message = 6;
  if (cached_has_bits & 0x00000001u) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        6, this->error_message(), target);
  }

  // optional bytes encoded_response = 7;
  if (has_encoded_response()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        7, this->encoded_response(), target);
  }

  // optional .yb.RedisDataType type = 8;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      8, this->type(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisResponsePB)
  return target;
}

size_t RedisResponsePB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisResponsePB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional bytes error_message = 6;
    if (has_error_message()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->error_message());
    }

    // optional .yb.RedisResponsePB.RedisStatusCode code = 1;
    if (has_code()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->code());
    }

    // optional .yb.RedisDataType type = 8;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
    }

  }
  switch (response_data_case()) {
    // optional int64 int_response = 2;
    case kIntResponse: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->int_response());
      break;
    }
    // optional bytes string_response = 3;
    case kStringResponse: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->string_response());
      break;
    }
    // optional .yb.RedisArrayPB array_response = 4;
    case kArrayResponse: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *response_data_.array_response_);
      break;
    }
    // optional bytes status_response = 5;
    case kStatusResponse: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->status_response());
      break;
    }
    // optional bytes encoded_response = 7;
    case kEncodedResponse: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->encoded_response());
      break;
    }
    case RESPONSE_DATA_NOT_SET: {
      break;
    }
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisResponsePB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisResponsePB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisResponsePB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisResponsePB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisResponsePB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisResponsePB)
    MergeFrom(*source);
  }
}

void RedisResponsePB::MergeFrom(const RedisResponsePB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisResponsePB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_error_message();
      error_message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.error_message_);
    }
    if (cached_has_bits & 0x00000002u) {
      code_ = from.code_;
    }
    if (cached_has_bits & 0x00000004u) {
      type_ = from.type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  switch (from.response_data_case()) {
    case kIntResponse: {
      set_int_response(from.int_response());
      break;
    }
    case kStringResponse: {
      set_string_response(from.string_response());
      break;
    }
    case kArrayResponse: {
      mutable_array_response()->::yb::RedisArrayPB::MergeFrom(from.array_response());
      break;
    }
    case kStatusResponse: {
      set_status_response(from.status_response());
      break;
    }
    case kEncodedResponse: {
      set_encoded_response(from.encoded_response());
      break;
    }
    case RESPONSE_DATA_NOT_SET: {
      break;
    }
  }
}

void RedisResponsePB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisResponsePB::CopyFrom(const RedisResponsePB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisResponsePB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisResponsePB::IsInitialized() const {
  return true;
}

void RedisResponsePB::Swap(RedisResponsePB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisResponsePB::InternalSwap(RedisResponsePB* other) {
  using std::swap;
  error_message_.Swap(&other->error_message_);
  swap(code_, other->code_);
  swap(type_, other->type_);
  swap(response_data_, other->response_data_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisResponsePB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void RedisArrayPB::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RedisArrayPB::kElementsFieldNumber;
const int RedisArrayPB::kEncodedFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RedisArrayPB::RedisArrayPB()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisArrayPB();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:yb.RedisArrayPB)
}
RedisArrayPB::RedisArrayPB(const RedisArrayPB& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      elements_(from.elements_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  encoded_ = from.encoded_;
  // @@protoc_insertion_point(copy_constructor:yb.RedisArrayPB)
}

void RedisArrayPB::SharedCtor() {
  _cached_size_ = 0;
  encoded_ = false;
}

RedisArrayPB::~RedisArrayPB() {
  // @@protoc_insertion_point(destructor:yb.RedisArrayPB)
  SharedDtor();
}

void RedisArrayPB::SharedDtor() {
}

void RedisArrayPB::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RedisArrayPB::descriptor() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const RedisArrayPB& RedisArrayPB::default_instance() {
  ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::InitDefaultsRedisArrayPB();
  return *internal_default_instance();
}

RedisArrayPB* RedisArrayPB::New(::google::protobuf::Arena* arena) const {
  RedisArrayPB* n = new RedisArrayPB;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RedisArrayPB::Clear() {
// @@protoc_insertion_point(message_clear_start:yb.RedisArrayPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  elements_.Clear();
  encoded_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RedisArrayPB::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:yb.RedisArrayPB)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated bytes elements = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->add_elements()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool encoded = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_encoded();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &encoded_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:yb.RedisArrayPB)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:yb.RedisArrayPB)
  return false;
#undef DO_
}

void RedisArrayPB::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:yb.RedisArrayPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated bytes elements = 1;
  for (int i = 0, n = this->elements_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      1, this->elements(i), output);
  }

  cached_has_bits = _has_bits_[0];
  // optional bool encoded = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->encoded(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:yb.RedisArrayPB)
}

::google::protobuf::uint8* RedisArrayPB::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:yb.RedisArrayPB)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated bytes elements = 1;
  for (int i = 0, n = this->elements_size(); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteBytesToArray(1, this->elements(i), target);
  }

  cached_has_bits = _has_bits_[0];
  // optional bool encoded = 2;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->encoded(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:yb.RedisArrayPB)
  return target;
}

size_t RedisArrayPB::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:yb.RedisArrayPB)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated bytes elements = 1;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->elements_size());
  for (int i = 0, n = this->elements_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
      this->elements(i));
  }

  // optional bool encoded = 2;
  if (has_encoded()) {
    total_size += 1 + 1;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RedisArrayPB::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:yb.RedisArrayPB)
  GOOGLE_DCHECK_NE(&from, this);
  const RedisArrayPB* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const RedisArrayPB>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:yb.RedisArrayPB)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:yb.RedisArrayPB)
    MergeFrom(*source);
  }
}

void RedisArrayPB::MergeFrom(const RedisArrayPB& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:yb.RedisArrayPB)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  elements_.MergeFrom(from.elements_);
  if (from.has_encoded()) {
    set_encoded(from.encoded());
  }
}

void RedisArrayPB::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:yb.RedisArrayPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RedisArrayPB::CopyFrom(const RedisArrayPB& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:yb.RedisArrayPB)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RedisArrayPB::IsInitialized() const {
  return true;
}

void RedisArrayPB::Swap(RedisArrayPB* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RedisArrayPB::InternalSwap(RedisArrayPB* other) {
  using std::swap;
  elements_.InternalSwap(&other->elements_);
  swap(encoded_, other->encoded_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RedisArrayPB::GetMetadata() const {
  protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_yb_2fcommon_2fredis_5fprotocol_2eproto::file_level_metadata[kIndexInFileMessages];
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace yb

// @@protoc_insertion_point(global_scope)

YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

Coverage Report

Created: 2022-03-09 17:30