/Users/deen/code/yugabyte-db/build/debugcov-clang-dynamic-arm64-ninja/src/yb/rpc/rtest.messages.h

Source (jump to first uncovered line)
// THIS FILE IS AUTOGENERATED FROM yb/rpc/rtest.proto

#pragma once

#include "yb/rpc/lightweight_message.h"
#include "yb/util/memory/arena_list.h"
#include "yb/util/memory/mc_types.h"
#include "yb/rpc/rtest.pb.h"

#include "yb/rpc/any.messages.h"
#include "yb/rpc/rtest_diff_package.messages.h"

namespace yb {
namespace rpc_test {

class LWAddRequestPB;
class LWAddRequestPartialPB;
class LWAddResponsePB;
class LWSleepRequestPB;
class LWSleepResponsePB;
class LWSendStringsRequestPB;
class LWSendStringsResponsePB;
class LWEchoRequestPB;
class LWEchoResponsePB;
class LWWhoAmIRequestPB;
class LWWhoAmIResponsePB;
class LWCalculatorError;
class LWPanicRequestPB;
class LWPanicResponsePB;
class LWPingRequestPB;
class LWPingResponsePB;
class LWDisconnectRequestPB;
class LWDisconnectResponsePB;
class LWForwardRequestPB;
class LWForwardResponsePB;
class LWConcatRequestPB;
class LWConcatResponsePB;
class LWLightweightSubMessagePB;
class LWLightweightPairPB;
class LWLightweightRequestPB_LWMapEntry_DoNotUse;
class LWLightweightRequestPB;
class LWLightweightResponsePB_LWMapEntry_DoNotUse;
class LWLightweightResponsePB;
class LWTrivialRequestPB;
class LWTrivialErrorPB;
class LWTrivialResponsePB;

YB_DEFINE_ENUM(AddRequestPBFields,
  (kX)
  (kY)
);

class LWAddRequestPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWAddRequestPB(::yb::Arena* arena);
  LWAddRequestPB(::yb::Arena* arena, const LWAddRequestPB& rhs);

  LWAddRequestPB(::yb::Arena* arena, const AddRequestPB& rhs) 
      : LWAddRequestPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWAddRequestPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const AddRequestPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWAddRequestPB& rhs);
  void CopyFrom(const AddRequestPB& rhs);

  void ToGoogleProtobuf(AddRequestPB* out) const;

  AddRequestPB ToGoogleProtobuf() const {
    AddRequestPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  uint32_t x() const {
    return x_;
  }

  void set_x(uint32_t value) {
    has_fields_.Set(AddRequestPBFields::kX);
    x_ = value;
  }

  uint32_t* mutable_x() {
    has_fields_.Set(AddRequestPBFields::kX);
    return &x_;
  }

  bool has_x() const {
    return has_fields_.Test(AddRequestPBFields::kX);
  }

  void clear_x() {
    x_ = uint32_t();
    has_fields_.Reset(AddRequestPBFields::kX);
  }

  uint32_t y() const {
    return y_;
  }

  void set_y(uint32_t value) {
    has_fields_.Set(AddRequestPBFields::kY);
    y_ = value;
  }

  uint32_t* mutable_y() {
    has_fields_.Set(AddRequestPBFields::kY);
    return &y_;
  }

  bool has_y() const {
    return has_fields_.Test(AddRequestPBFields::kY);
  }

  void clear_y() {
    y_ = uint32_t();
    has_fields_.Reset(AddRequestPBFields::kY);
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::EnumBitSet<AddRequestPBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  uint32_t x_ = uint32_t();
  uint32_t y_ = uint32_t();
};

YB_DEFINE_ENUM(AddRequestPartialPBFields,
  (kX)
);

class LWAddRequestPartialPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWAddRequestPartialPB(::yb::Arena* arena);
  LWAddRequestPartialPB(::yb::Arena* arena, const LWAddRequestPartialPB& rhs);

  LWAddRequestPartialPB(::yb::Arena* arena, const AddRequestPartialPB& rhs) 
      : LWAddRequestPartialPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWAddRequestPartialPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const AddRequestPartialPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWAddRequestPartialPB& rhs);
  void CopyFrom(const AddRequestPartialPB& rhs);

  void ToGoogleProtobuf(AddRequestPartialPB* out) const;

  AddRequestPartialPB ToGoogleProtobuf() const {
    AddRequestPartialPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  uint32_t x() const {
    return x_;
  }

  void set_x(uint32_t value) {
    has_fields_.Set(AddRequestPartialPBFields::kX);
    x_ = value;
  }

  uint32_t* mutable_x() {
    has_fields_.Set(AddRequestPartialPBFields::kX);
    return &x_;
  }

  bool has_x() const {
    return has_fields_.Test(AddRequestPartialPBFields::kX);
  }

  void clear_x() {
    x_ = uint32_t();
    has_fields_.Reset(AddRequestPartialPBFields::kX);
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::EnumBitSet<AddRequestPartialPBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  uint32_t x_ = uint32_t();
};

YB_DEFINE_ENUM(AddResponsePBFields,
  (kResult)
);

class LWAddResponsePB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWAddResponsePB(::yb::Arena* arena);
  LWAddResponsePB(::yb::Arena* arena, const LWAddResponsePB& rhs);

  LWAddResponsePB(::yb::Arena* arena, const AddResponsePB& rhs) 
      : LWAddResponsePB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWAddResponsePB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const AddResponsePB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWAddResponsePB& rhs);
  void CopyFrom(const AddResponsePB& rhs);

  void ToGoogleProtobuf(AddResponsePB* out) const;

  AddResponsePB ToGoogleProtobuf() const {
    AddResponsePB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  uint32_t result() const {
    return result_;
  }

  void set_result(uint32_t value) {
    has_fields_.Set(AddResponsePBFields::kResult);
    result_ = value;
  }

  uint32_t* mutable_result() {
    has_fields_.Set(AddResponsePBFields::kResult);
    return &result_;
  }

  bool has_result() const {
    return has_fields_.Test(AddResponsePBFields::kResult);
  }

  void clear_result() {
    result_ = uint32_t();
    has_fields_.Reset(AddResponsePBFields::kResult);
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::EnumBitSet<AddResponsePBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  uint32_t result_ = uint32_t();
};

YB_DEFINE_ENUM(SleepRequestPBFields,
  (kSleepMicros)
  (kDeferred)
  (kReturnAppError)
  (kClientTimeoutDefined)
);

class LWSleepRequestPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWSleepRequestPB(::yb::Arena* arena);
  LWSleepRequestPB(::yb::Arena* arena, const LWSleepRequestPB& rhs);

  LWSleepRequestPB(::yb::Arena* arena, const SleepRequestPB& rhs) 
      : LWSleepRequestPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWSleepRequestPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const SleepRequestPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWSleepRequestPB& rhs);
  void CopyFrom(const SleepRequestPB& rhs);

  void ToGoogleProtobuf(SleepRequestPB* out) const;

  SleepRequestPB ToGoogleProtobuf() const {
    SleepRequestPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  uint32_t sleep_micros() const {
    return sleep_micros_;
  }

  void set_sleep_micros(uint32_t value) {
    has_fields_.Set(SleepRequestPBFields::kSleepMicros);
    sleep_micros_ = value;
  }

  uint32_t* mutable_sleep_micros() {
    has_fields_.Set(SleepRequestPBFields::kSleepMicros);
    return &sleep_micros_;
  }

  bool has_sleep_micros() const {
    return has_fields_.Test(SleepRequestPBFields::kSleepMicros);
  }

  void clear_sleep_micros() {
    sleep_micros_ = uint32_t();
    has_fields_.Reset(SleepRequestPBFields::kSleepMicros);
  }

  bool deferred() const {
    return deferred_;
  }

  void set_deferred(bool value) {
    has_fields_.Set(SleepRequestPBFields::kDeferred);
    deferred_ = value;
  }

  bool* mutable_deferred() {
    has_fields_.Set(SleepRequestPBFields::kDeferred);
    return &deferred_;
  }

  bool has_deferred() const {
    return has_fields_.Test(SleepRequestPBFields::kDeferred);
  }

  void clear_deferred() {
    deferred_ = bool();
    has_fields_.Reset(SleepRequestPBFields::kDeferred);
  }

  bool return_app_error() const {
    return return_app_error_;
  }

  void set_return_app_error(bool value) {
    has_fields_.Set(SleepRequestPBFields::kReturnAppError);
    return_app_error_ = value;
  }

  bool* mutable_return_app_error() {
    has_fields_.Set(SleepRequestPBFields::kReturnAppError);
    return &return_app_error_;
  }

  bool has_return_app_error() const {
    return has_fields_.Test(SleepRequestPBFields::kReturnAppError);
  }

  void clear_return_app_error() {
    return_app_error_ = bool();
    has_fields_.Reset(SleepRequestPBFields::kReturnAppError);
  }

  bool client_timeout_defined() const {
    return client_timeout_defined_;
  }

  void set_client_timeout_defined(bool value) {
    has_fields_.Set(SleepRequestPBFields::kClientTimeoutDefined);
    client_timeout_defined_ = value;
  }

  bool* mutable_client_timeout_defined() {
    has_fields_.Set(SleepRequestPBFields::kClientTimeoutDefined);
    return &client_timeout_defined_;
  }

  bool has_client_timeout_defined() const {
    return has_fields_.Test(SleepRequestPBFields::kClientTimeoutDefined);
  }

  void clear_client_timeout_defined() {
    client_timeout_defined_ = bool();
    has_fields_.Reset(SleepRequestPBFields::kClientTimeoutDefined);
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::EnumBitSet<SleepRequestPBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  uint32_t sleep_micros_ = uint32_t();
  bool deferred_ = bool();
  bool return_app_error_ = bool();
  bool client_timeout_defined_ = bool();
};

class LWSleepResponsePB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWSleepResponsePB(::yb::Arena* arena);
  LWSleepResponsePB(::yb::Arena* arena, const LWSleepResponsePB& rhs);

  LWSleepResponsePB(::yb::Arena* arena, const SleepResponsePB& rhs) 
      : LWSleepResponsePB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWSleepResponsePB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const SleepResponsePB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWSleepResponsePB& rhs);
  void CopyFrom(const SleepResponsePB& rhs);

  void ToGoogleProtobuf(SleepResponsePB* out) const;

  SleepResponsePB ToGoogleProtobuf() const {
    SleepResponsePB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  mutable size_t cached_size_ = 0;
};

YB_DEFINE_ENUM(SendStringsRequestPBFields,
  (kRandomSeed)
);

class LWSendStringsRequestPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWSendStringsRequestPB(::yb::Arena* arena);
  LWSendStringsRequestPB(::yb::Arena* arena, const LWSendStringsRequestPB& rhs);

  LWSendStringsRequestPB(::yb::Arena* arena, const SendStringsRequestPB& rhs) 
      : LWSendStringsRequestPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWSendStringsRequestPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const SendStringsRequestPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWSendStringsRequestPB& rhs);
  void CopyFrom(const SendStringsRequestPB& rhs);

  void ToGoogleProtobuf(SendStringsRequestPB* out) const;

  SendStringsRequestPB ToGoogleProtobuf() const {
    SendStringsRequestPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  uint32_t random_seed() const {
    return random_seed_;
  }

  void set_random_seed(uint32_t value) {
    has_fields_.Set(SendStringsRequestPBFields::kRandomSeed);
    random_seed_ = value;
  }

  uint32_t* mutable_random_seed() {
    has_fields_.Set(SendStringsRequestPBFields::kRandomSeed);
    return &random_seed_;
  }

  bool has_random_seed() const {
    return has_fields_.Test(SendStringsRequestPBFields::kRandomSeed);
  }

  void clear_random_seed() {
    random_seed_ = uint32_t();
    has_fields_.Reset(SendStringsRequestPBFields::kRandomSeed);
  }

  const ::yb::MCVector<uint64_t>& sizes() const {
    return sizes_;
  }

  ::yb::MCVector<uint64_t>* mutable_sizes() {
    return &sizes_;
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::EnumBitSet<SendStringsRequestPBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  uint32_t random_seed_ = uint32_t();
  ::yb::MCVector<uint64_t> sizes_;
};

class LWSendStringsResponsePB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWSendStringsResponsePB(::yb::Arena* arena);
  LWSendStringsResponsePB(::yb::Arena* arena, const LWSendStringsResponsePB& rhs);

  LWSendStringsResponsePB(::yb::Arena* arena, const SendStringsResponsePB& rhs) 
      : LWSendStringsResponsePB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWSendStringsResponsePB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const SendStringsResponsePB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWSendStringsResponsePB& rhs);
  void CopyFrom(const SendStringsResponsePB& rhs);

  void ToGoogleProtobuf(SendStringsResponsePB* out) const;

  SendStringsResponsePB ToGoogleProtobuf() const {
    SendStringsResponsePB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  const ::yb::MCVector<uint32_t>& sidecars() const {
    return sidecars_;
  }

  ::yb::MCVector<uint32_t>* mutable_sidecars() {
    return &sidecars_;
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  mutable size_t cached_size_ = 0;
  ::yb::MCVector<uint32_t> sidecars_;
};

YB_DEFINE_ENUM(EchoRequestPBFields,
  (kData)
);

class LWEchoRequestPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWEchoRequestPB(::yb::Arena* arena);
  LWEchoRequestPB(::yb::Arena* arena, const LWEchoRequestPB& rhs);

  LWEchoRequestPB(::yb::Arena* arena, const EchoRequestPB& rhs) 
      : LWEchoRequestPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWEchoRequestPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const EchoRequestPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWEchoRequestPB& rhs);
  void CopyFrom(const EchoRequestPB& rhs);

  void ToGoogleProtobuf(EchoRequestPB* out) const;

  EchoRequestPB ToGoogleProtobuf() const {
    EchoRequestPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  ::yb::Slice data() const {
    return data_;
  }

  void dup_data(::yb::Slice value) {
    has_fields_.Set(EchoRequestPBFields::kData);
    data_ = arena_.DupSlice(value);
  }

  void ref_data(::yb::Slice value) {
    has_fields_.Set(EchoRequestPBFields::kData);
    data_ = value;
  }

  ::yb::Slice* mutable_data() {
    has_fields_.Set(EchoRequestPBFields::kData);
    return &data_;
  }

  bool has_data() const {
    return has_fields_.Test(EchoRequestPBFields::kData);
  }

  void clear_data() {
    data_ = ::yb::Slice();
    has_fields_.Reset(EchoRequestPBFields::kData);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<EchoRequestPBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  ::yb::Slice data_ = ::yb::Slice();
};

YB_DEFINE_ENUM(EchoResponsePBFields,
  (kData)
);

class LWEchoResponsePB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWEchoResponsePB(::yb::Arena* arena);
  LWEchoResponsePB(::yb::Arena* arena, const LWEchoResponsePB& rhs);

  LWEchoResponsePB(::yb::Arena* arena, const EchoResponsePB& rhs) 
      : LWEchoResponsePB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWEchoResponsePB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const EchoResponsePB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWEchoResponsePB& rhs);
  void CopyFrom(const EchoResponsePB& rhs);

  void ToGoogleProtobuf(EchoResponsePB* out) const;

  EchoResponsePB ToGoogleProtobuf() const {
    EchoResponsePB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  ::yb::Slice data() const {
    return data_;
  }

  void dup_data(::yb::Slice value) {
    has_fields_.Set(EchoResponsePBFields::kData);
    data_ = arena_.DupSlice(value);
  }

  void ref_data(::yb::Slice value) {
    has_fields_.Set(EchoResponsePBFields::kData);
    data_ = value;
  }

  ::yb::Slice* mutable_data() {
    has_fields_.Set(EchoResponsePBFields::kData);
    return &data_;
  }

  bool has_data() const {
    return has_fields_.Test(EchoResponsePBFields::kData);
  }

  void clear_data() {
    data_ = ::yb::Slice();
    has_fields_.Reset(EchoResponsePBFields::kData);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<EchoResponsePBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  ::yb::Slice data_ = ::yb::Slice();
};

class LWWhoAmIRequestPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWWhoAmIRequestPB(::yb::Arena* arena);
  LWWhoAmIRequestPB(::yb::Arena* arena, const LWWhoAmIRequestPB& rhs);

  LWWhoAmIRequestPB(::yb::Arena* arena, const WhoAmIRequestPB& rhs) 
      : LWWhoAmIRequestPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWWhoAmIRequestPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const WhoAmIRequestPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWWhoAmIRequestPB& rhs);
  void CopyFrom(const WhoAmIRequestPB& rhs);

  void ToGoogleProtobuf(WhoAmIRequestPB* out) const;

  WhoAmIRequestPB ToGoogleProtobuf() const {
    WhoAmIRequestPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  mutable size_t cached_size_ = 0;
};

YB_DEFINE_ENUM(WhoAmIResponsePBFields,
  (kAddress)
);

class LWWhoAmIResponsePB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWWhoAmIResponsePB(::yb::Arena* arena);
  LWWhoAmIResponsePB(::yb::Arena* arena, const LWWhoAmIResponsePB& rhs);

  LWWhoAmIResponsePB(::yb::Arena* arena, const WhoAmIResponsePB& rhs) 
      : LWWhoAmIResponsePB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWWhoAmIResponsePB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const WhoAmIResponsePB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWWhoAmIResponsePB& rhs);
  void CopyFrom(const WhoAmIResponsePB& rhs);

  void ToGoogleProtobuf(WhoAmIResponsePB* out) const;

  WhoAmIResponsePB ToGoogleProtobuf() const {
    WhoAmIResponsePB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  ::yb::Slice address() const {
    return address_;
  }

  void dup_address(::yb::Slice value) {
    has_fields_.Set(WhoAmIResponsePBFields::kAddress);
    address_ = arena_.DupSlice(value);
  }

  void ref_address(::yb::Slice value) {
    has_fields_.Set(WhoAmIResponsePBFields::kAddress);
    address_ = value;
  }

  ::yb::Slice* mutable_address() {
    has_fields_.Set(WhoAmIResponsePBFields::kAddress);
    return &address_;
  }

  bool has_address() const {
    return has_fields_.Test(WhoAmIResponsePBFields::kAddress);
  }

  void clear_address() {
    address_ = ::yb::Slice();
    has_fields_.Reset(WhoAmIResponsePBFields::kAddress);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<WhoAmIResponsePBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  ::yb::Slice address_ = ::yb::Slice();
};

YB_DEFINE_ENUM(CalculatorErrorFields,
  (kExtraErrorData)
);

class LWCalculatorError : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWCalculatorError(::yb::Arena* arena);
  LWCalculatorError(::yb::Arena* arena, const LWCalculatorError& rhs);

  LWCalculatorError(::yb::Arena* arena, const CalculatorError& rhs) 
      : LWCalculatorError(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWCalculatorError& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const CalculatorError& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWCalculatorError& rhs);
  void CopyFrom(const CalculatorError& rhs);

  void ToGoogleProtobuf(CalculatorError* out) const;

  CalculatorError ToGoogleProtobuf() const {
    CalculatorError result;
    ToGoogleProtobuf(&result);
    return result;
  }

  ::yb::Slice extra_error_data() const {
    return extra_error_data_;
  }

  void dup_extra_error_data(::yb::Slice value) {
    has_fields_.Set(CalculatorErrorFields::kExtraErrorData);
    extra_error_data_ = arena_.DupSlice(value);
  }

  void ref_extra_error_data(::yb::Slice value) {
    has_fields_.Set(CalculatorErrorFields::kExtraErrorData);
    extra_error_data_ = value;
  }

  ::yb::Slice* mutable_extra_error_data() {
    has_fields_.Set(CalculatorErrorFields::kExtraErrorData);
    return &extra_error_data_;
  }

  bool has_extra_error_data() const {
    return has_fields_.Test(CalculatorErrorFields::kExtraErrorData);
  }

  void clear_extra_error_data() {
    extra_error_data_ = ::yb::Slice();
    has_fields_.Reset(CalculatorErrorFields::kExtraErrorData);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<CalculatorErrorFields> has_fields_;
  mutable size_t cached_size_ = 0;
  ::yb::Slice extra_error_data_ = ::yb::Slice();
};

class LWPanicRequestPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWPanicRequestPB(::yb::Arena* arena);
  LWPanicRequestPB(::yb::Arena* arena, const LWPanicRequestPB& rhs);

  LWPanicRequestPB(::yb::Arena* arena, const PanicRequestPB& rhs) 
      : LWPanicRequestPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWPanicRequestPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const PanicRequestPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWPanicRequestPB& rhs);
  void CopyFrom(const PanicRequestPB& rhs);

  void ToGoogleProtobuf(PanicRequestPB* out) const;

  PanicRequestPB ToGoogleProtobuf() const {
    PanicRequestPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  mutable size_t cached_size_ = 0;
};

class LWPanicResponsePB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWPanicResponsePB(::yb::Arena* arena);
  LWPanicResponsePB(::yb::Arena* arena, const LWPanicResponsePB& rhs);

  LWPanicResponsePB(::yb::Arena* arena, const PanicResponsePB& rhs) 
      : LWPanicResponsePB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWPanicResponsePB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const PanicResponsePB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWPanicResponsePB& rhs);
  void CopyFrom(const PanicResponsePB& rhs);

  void ToGoogleProtobuf(PanicResponsePB* out) const;

  PanicResponsePB ToGoogleProtobuf() const {
    PanicResponsePB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  mutable size_t cached_size_ = 0;
};

YB_DEFINE_ENUM(PingRequestPBFields,
  (kId)
);

class LWPingRequestPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWPingRequestPB(::yb::Arena* arena);
  LWPingRequestPB(::yb::Arena* arena, const LWPingRequestPB& rhs);

  LWPingRequestPB(::yb::Arena* arena, const PingRequestPB& rhs) 
      : LWPingRequestPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWPingRequestPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const PingRequestPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWPingRequestPB& rhs);
  void CopyFrom(const PingRequestPB& rhs);

  void ToGoogleProtobuf(PingRequestPB* out) const;

  PingRequestPB ToGoogleProtobuf() const {
    PingRequestPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  uint64_t id() const {
    return id_;
  }

  void set_id(uint64_t value) {
    has_fields_.Set(PingRequestPBFields::kId);
    id_ = value;
  }

  uint64_t* mutable_id() {
    has_fields_.Set(PingRequestPBFields::kId);
    return &id_;
  }

  bool has_id() const {
    return has_fields_.Test(PingRequestPBFields::kId);
  }

  void clear_id() {
    id_ = uint64_t();
    has_fields_.Reset(PingRequestPBFields::kId);
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::EnumBitSet<PingRequestPBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  uint64_t id_ = uint64_t();
};

YB_DEFINE_ENUM(PingResponsePBFields,
  (kTime)
);

class LWPingResponsePB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWPingResponsePB(::yb::Arena* arena);
  LWPingResponsePB(::yb::Arena* arena, const LWPingResponsePB& rhs);

  LWPingResponsePB(::yb::Arena* arena, const PingResponsePB& rhs) 
      : LWPingResponsePB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWPingResponsePB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const PingResponsePB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWPingResponsePB& rhs);
  void CopyFrom(const PingResponsePB& rhs);

  void ToGoogleProtobuf(PingResponsePB* out) const;

  PingResponsePB ToGoogleProtobuf() const {
    PingResponsePB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  uint64_t time() const {
    return time_;
  }

  void set_time(uint64_t value) {
    has_fields_.Set(PingResponsePBFields::kTime);
    time_ = value;
  }

  uint64_t* mutable_time() {
    has_fields_.Set(PingResponsePBFields::kTime);
    return &time_;
  }

  bool has_time() const {
    return has_fields_.Test(PingResponsePBFields::kTime);
  }

  void clear_time() {
    time_ = uint64_t();
    has_fields_.Reset(PingResponsePBFields::kTime);
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::EnumBitSet<PingResponsePBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  uint64_t time_ = uint64_t();
};

class LWDisconnectRequestPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWDisconnectRequestPB(::yb::Arena* arena);
  LWDisconnectRequestPB(::yb::Arena* arena, const LWDisconnectRequestPB& rhs);

  LWDisconnectRequestPB(::yb::Arena* arena, const DisconnectRequestPB& rhs) 
      : LWDisconnectRequestPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWDisconnectRequestPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const DisconnectRequestPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWDisconnectRequestPB& rhs);
  void CopyFrom(const DisconnectRequestPB& rhs);

  void ToGoogleProtobuf(DisconnectRequestPB* out) const;

  DisconnectRequestPB ToGoogleProtobuf() const {
    DisconnectRequestPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  mutable size_t cached_size_ = 0;
};

class LWDisconnectResponsePB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWDisconnectResponsePB(::yb::Arena* arena);
  LWDisconnectResponsePB(::yb::Arena* arena, const LWDisconnectResponsePB& rhs);

  LWDisconnectResponsePB(::yb::Arena* arena, const DisconnectResponsePB& rhs) 
      : LWDisconnectResponsePB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWDisconnectResponsePB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const DisconnectResponsePB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWDisconnectResponsePB& rhs);
  void CopyFrom(const DisconnectResponsePB& rhs);

  void ToGoogleProtobuf(DisconnectResponsePB* out) const;

  DisconnectResponsePB ToGoogleProtobuf() const {
    DisconnectResponsePB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  mutable size_t cached_size_ = 0;
};

YB_DEFINE_ENUM(ForwardRequestPBFields,
  (kHost)
  (kPort)
);

class LWForwardRequestPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWForwardRequestPB(::yb::Arena* arena);
  LWForwardRequestPB(::yb::Arena* arena, const LWForwardRequestPB& rhs);

  LWForwardRequestPB(::yb::Arena* arena, const ForwardRequestPB& rhs) 
      : LWForwardRequestPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWForwardRequestPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const ForwardRequestPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWForwardRequestPB& rhs);
  void CopyFrom(const ForwardRequestPB& rhs);

  void ToGoogleProtobuf(ForwardRequestPB* out) const;

  ForwardRequestPB ToGoogleProtobuf() const {
    ForwardRequestPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  ::yb::Slice host() const {
    return host_;
  }

  void dup_host(::yb::Slice value) {
    has_fields_.Set(ForwardRequestPBFields::kHost);
    host_ = arena_.DupSlice(value);
  }

  void ref_host(::yb::Slice value) {
    has_fields_.Set(ForwardRequestPBFields::kHost);
    host_ = value;
  }

  ::yb::Slice* mutable_host() {
    has_fields_.Set(ForwardRequestPBFields::kHost);
    return &host_;
  }

  bool has_host() const {
    return has_fields_.Test(ForwardRequestPBFields::kHost);
  }

  void clear_host() {
    host_ = ::yb::Slice();
    has_fields_.Reset(ForwardRequestPBFields::kHost);
  }

  uint32_t port() const {
    return port_;
  }

  void set_port(uint32_t value) {
    has_fields_.Set(ForwardRequestPBFields::kPort);
    port_ = value;
  }

  uint32_t* mutable_port() {
    has_fields_.Set(ForwardRequestPBFields::kPort);
    return &port_;
  }

  bool has_port() const {
    return has_fields_.Test(ForwardRequestPBFields::kPort);
  }

  void clear_port() {
    port_ = uint32_t();
    has_fields_.Reset(ForwardRequestPBFields::kPort);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<ForwardRequestPBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  ::yb::Slice host_ = ::yb::Slice();
  uint32_t port_ = uint32_t();
};

YB_DEFINE_ENUM(ForwardResponsePBFields,
  (kName)
);

class LWForwardResponsePB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWForwardResponsePB(::yb::Arena* arena);
  LWForwardResponsePB(::yb::Arena* arena, const LWForwardResponsePB& rhs);

  LWForwardResponsePB(::yb::Arena* arena, const ForwardResponsePB& rhs) 
      : LWForwardResponsePB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWForwardResponsePB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const ForwardResponsePB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWForwardResponsePB& rhs);
  void CopyFrom(const ForwardResponsePB& rhs);

  void ToGoogleProtobuf(ForwardResponsePB* out) const;

  ForwardResponsePB ToGoogleProtobuf() const {
    ForwardResponsePB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  ::yb::Slice name() const {
    return name_;
  }

  void dup_name(::yb::Slice value) {
    has_fields_.Set(ForwardResponsePBFields::kName);
    name_ = arena_.DupSlice(value);
  }

  void ref_name(::yb::Slice value) {
    has_fields_.Set(ForwardResponsePBFields::kName);
    name_ = value;
  }

  ::yb::Slice* mutable_name() {
    has_fields_.Set(ForwardResponsePBFields::kName);
    return &name_;
  }

  bool has_name() const {
    return has_fields_.Test(ForwardResponsePBFields::kName);
  }

  void clear_name() {
    name_ = ::yb::Slice();
    has_fields_.Reset(ForwardResponsePBFields::kName);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<ForwardResponsePBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  ::yb::Slice name_ = ::yb::Slice();
};

YB_DEFINE_ENUM(ConcatRequestPBFields,
  (kLhs)
  (kRhs)
);

class LWConcatRequestPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWConcatRequestPB(::yb::Arena* arena);
  LWConcatRequestPB(::yb::Arena* arena, const LWConcatRequestPB& rhs);

  LWConcatRequestPB(::yb::Arena* arena, const ConcatRequestPB& rhs) 
      : LWConcatRequestPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWConcatRequestPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const ConcatRequestPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWConcatRequestPB& rhs);
  void CopyFrom(const ConcatRequestPB& rhs);

  void ToGoogleProtobuf(ConcatRequestPB* out) const;

  ConcatRequestPB ToGoogleProtobuf() const {
    ConcatRequestPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  ::yb::Slice lhs() const {
    return lhs_;
  }

  void dup_lhs(::yb::Slice value) {
    has_fields_.Set(ConcatRequestPBFields::kLhs);
    lhs_ = arena_.DupSlice(value);
  }

  void ref_lhs(::yb::Slice value) {
    has_fields_.Set(ConcatRequestPBFields::kLhs);
    lhs_ = value;
  }

  ::yb::Slice* mutable_lhs() {
    has_fields_.Set(ConcatRequestPBFields::kLhs);
    return &lhs_;
  }

  bool has_lhs() const {
    return has_fields_.Test(ConcatRequestPBFields::kLhs);
  }

  void clear_lhs() {
    lhs_ = ::yb::Slice();
    has_fields_.Reset(ConcatRequestPBFields::kLhs);
  }

  ::yb::Slice rhs() const {
    return rhs_;
  }

  void dup_rhs(::yb::Slice value) {
    has_fields_.Set(ConcatRequestPBFields::kRhs);
    rhs_ = arena_.DupSlice(value);
  }

  void ref_rhs(::yb::Slice value) {
    has_fields_.Set(ConcatRequestPBFields::kRhs);
    rhs_ = value;
  }

  ::yb::Slice* mutable_rhs() {
    has_fields_.Set(ConcatRequestPBFields::kRhs);
    return &rhs_;
  }

  bool has_rhs() const {
    return has_fields_.Test(ConcatRequestPBFields::kRhs);
  }

  void clear_rhs() {
    rhs_ = ::yb::Slice();
    has_fields_.Reset(ConcatRequestPBFields::kRhs);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<ConcatRequestPBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  ::yb::Slice lhs_ = ::yb::Slice();
  ::yb::Slice rhs_ = ::yb::Slice();
};

YB_DEFINE_ENUM(ConcatResponsePBFields,
  (kResult)
);

class LWConcatResponsePB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWConcatResponsePB(::yb::Arena* arena);
  LWConcatResponsePB(::yb::Arena* arena, const LWConcatResponsePB& rhs);

  LWConcatResponsePB(::yb::Arena* arena, const ConcatResponsePB& rhs) 
      : LWConcatResponsePB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWConcatResponsePB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const ConcatResponsePB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWConcatResponsePB& rhs);
  void CopyFrom(const ConcatResponsePB& rhs);

  void ToGoogleProtobuf(ConcatResponsePB* out) const;

  ConcatResponsePB ToGoogleProtobuf() const {
    ConcatResponsePB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  ::yb::Slice result() const {
    return result_;
  }

  void dup_result(::yb::Slice value) {
    has_fields_.Set(ConcatResponsePBFields::kResult);
    result_ = arena_.DupSlice(value);
  }

  void ref_result(::yb::Slice value) {
    has_fields_.Set(ConcatResponsePBFields::kResult);
    result_ = value;
  }

  ::yb::Slice* mutable_result() {
    has_fields_.Set(ConcatResponsePBFields::kResult);
    return &result_;
  }

  bool has_result() const {
    return has_fields_.Test(ConcatResponsePBFields::kResult);
  }

  void clear_result() {
    result_ = ::yb::Slice();
    has_fields_.Reset(ConcatResponsePBFields::kResult);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<ConcatResponsePBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  ::yb::Slice result_ = ::yb::Slice();
};

// CYCLE LightweightSubMessagePB
YB_DEFINE_ENUM(LightweightSubMessagePBFields,
  (kSf32)
  (kStr)
);

class LWLightweightSubMessagePB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWLightweightSubMessagePB(::yb::Arena* arena);
  LWLightweightSubMessagePB(::yb::Arena* arena, const LWLightweightSubMessagePB& rhs);

  LWLightweightSubMessagePB(::yb::Arena* arena, const LightweightSubMessagePB& rhs) 
      : LWLightweightSubMessagePB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWLightweightSubMessagePB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const LightweightSubMessagePB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWLightweightSubMessagePB& rhs);
  void CopyFrom(const LightweightSubMessagePB& rhs);

  void ToGoogleProtobuf(LightweightSubMessagePB* out) const;

  LightweightSubMessagePB ToGoogleProtobuf() const {
    LightweightSubMessagePB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  int32_t sf32() const {
    return sf32_;
  }

  void set_sf32(int32_t value) {
    has_fields_.Set(LightweightSubMessagePBFields::kSf32);
    sf32_ = value;
  }

  int32_t* mutable_sf32() {
    has_fields_.Set(LightweightSubMessagePBFields::kSf32);
    return &sf32_;
  }

  bool has_sf32() const {
    return has_fields_.Test(LightweightSubMessagePBFields::kSf32);
  }

  void clear_sf32() {
    sf32_ = int32_t();
    has_fields_.Reset(LightweightSubMessagePBFields::kSf32);
  }

  const ::yb::MCVector<int32_t>& rsi32() const {
    return rsi32_;
  }

  ::yb::MCVector<int32_t>* mutable_rsi32() {
    return &rsi32_;
  }

  ::yb::Slice str() const {
    return str_;
  }

  void dup_str(::yb::Slice value) {
    has_fields_.Set(LightweightSubMessagePBFields::kStr);
    str_ = arena_.DupSlice(value);
  }

  void ref_str(::yb::Slice value) {
    has_fields_.Set(LightweightSubMessagePBFields::kStr);
    str_ = value;
  }

  ::yb::Slice* mutable_str() {
    has_fields_.Set(LightweightSubMessagePBFields::kStr);
    return &str_;
  }

  bool has_str() const {
    return has_fields_.Test(LightweightSubMessagePBFields::kStr);
  }

  void clear_str() {
    str_ = ::yb::Slice();
    has_fields_.Reset(LightweightSubMessagePBFields::kStr);
  }

  const ::yb::MCVector<::yb::Slice>& rbytes() const {
    return rbytes_;
  }

  ::yb::MCVector<::yb::Slice>* mutable_rbytes() {
    return &rbytes_;
  }

  const ::yb::rpc_test::LWLightweightSubMessagePB& cycle() const {
    return cycle_ ? *cycle_ : ::yb::rpc::empty_message<::yb::rpc_test::LWLightweightSubMessagePB>()0;
  }

  ::yb::rpc_test::LWLightweightSubMessagePB& ref_cycle(::yb::rpc_test::LWLightweightSubMessagePB* value) {
    cycle_ = value;
    return *cycle_;
  }

  ::yb::rpc_test::LWLightweightSubMessagePB* mutable_cycle() {
    if (!cycle_) {
      cycle_ = arena_.NewObject<::yb::rpc_test::LWLightweightSubMessagePB>(&arena_);
    }
    return cycle_;
  }

  bool has_cycle() const {
    return cycle_ != nullptr;
  }

  void clear_cycle() {
    cycle_ = nullptr;
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<LightweightSubMessagePBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  int32_t sf32_ = int32_t();
  ::yb::MCVector<int32_t> rsi32_;
  ::yb::Slice str_ = ::yb::Slice();
  ::yb::MCVector<::yb::Slice> rbytes_;
  ::yb::rpc_test::LWLightweightSubMessagePB* cycle_ = nullptr;
};

YB_DEFINE_ENUM(LightweightPairPBFields,
  (kS1)
  (kS2)
);

class LWLightweightPairPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWLightweightPairPB(::yb::Arena* arena);
  LWLightweightPairPB(::yb::Arena* arena, const LWLightweightPairPB& rhs);

  LWLightweightPairPB(::yb::Arena* arena, const LightweightPairPB& rhs) 
      : LWLightweightPairPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWLightweightPairPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const LightweightPairPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWLightweightPairPB& rhs);
  void CopyFrom(const LightweightPairPB& rhs);

  void ToGoogleProtobuf(LightweightPairPB* out) const;

  LightweightPairPB ToGoogleProtobuf() const {
    LightweightPairPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  ::yb::Slice s1() const {
    return s1_;
  }

  void dup_s1(::yb::Slice value) {
    has_fields_.Set(LightweightPairPBFields::kS1);
    s1_ = arena_.DupSlice(value);
  }

  void ref_s1(::yb::Slice value) {
    has_fields_.Set(LightweightPairPBFields::kS1);
    s1_ = value;
  }

  ::yb::Slice* mutable_s1() {
    has_fields_.Set(LightweightPairPBFields::kS1);
    return &s1_;
  }

  bool has_s1() const {
    return has_fields_.Test(LightweightPairPBFields::kS1);
  }

  void clear_s1() {
    s1_ = ::yb::Slice();
    has_fields_.Reset(LightweightPairPBFields::kS1);
  }

  ::yb::Slice s2() const {
    return s2_;
  }

  void dup_s2(::yb::Slice value) {
    has_fields_.Set(LightweightPairPBFields::kS2);
    s2_ = arena_.DupSlice(value);
  }

  void ref_s2(::yb::Slice value) {
    has_fields_.Set(LightweightPairPBFields::kS2);
    s2_ = value;
  }

  ::yb::Slice* mutable_s2() {
    has_fields_.Set(LightweightPairPBFields::kS2);
    return &s2_;
  }

  bool has_s2() const {
    return has_fields_.Test(LightweightPairPBFields::kS2);
  }

  void clear_s2() {
    s2_ = ::yb::Slice();
    has_fields_.Reset(LightweightPairPBFields::kS2);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<LightweightPairPBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  ::yb::Slice s1_ = ::yb::Slice();
  ::yb::Slice s2_ = ::yb::Slice();
};

YB_DEFINE_ENUM(LightweightRequestPB_MapEntry_DoNotUseFields,
  (kKey)
  (kValue)
);

class LWLightweightRequestPB_LWMapEntry_DoNotUse : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWLightweightRequestPB_LWMapEntry_DoNotUse(::yb::Arena* arena);
  LWLightweightRequestPB_LWMapEntry_DoNotUse(::yb::Arena* arena, const LWLightweightRequestPB_LWMapEntry_DoNotUse& rhs);

  LWLightweightRequestPB_LWMapEntry_DoNotUse(::yb::Arena* arena, const ::google::protobuf::MapPair<std::string, int64_t>& rhs) 
      : LWLightweightRequestPB_LWMapEntry_DoNotUse(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWLightweightRequestPB_LWMapEntry_DoNotUse& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const ::google::protobuf::MapPair<std::string, int64_t>& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWLightweightRequestPB_LWMapEntry_DoNotUse& rhs);
  void CopyFrom(const ::google::protobuf::MapPair<std::string, int64_t>& rhs);

  ::yb::Slice key() const {
    return key_;
  }

  void dup_key(::yb::Slice value) {
    has_fields_.Set(LightweightRequestPB_MapEntry_DoNotUseFields::kKey);
    key_ = arena_.DupSlice(value);
  }

  void ref_key(::yb::Slice value) {
    has_fields_.Set(LightweightRequestPB_MapEntry_DoNotUseFields::kKey);
    key_ = value;
  }

  ::yb::Slice* mutable_key() {
    has_fields_.Set(LightweightRequestPB_MapEntry_DoNotUseFields::kKey);
    return &key_;
  }

  bool has_key() const {
    return has_fields_.Test(LightweightRequestPB_MapEntry_DoNotUseFields::kKey);
  }

  void clear_key() {
    key_ = ::yb::Slice();
    has_fields_.Reset(LightweightRequestPB_MapEntry_DoNotUseFields::kKey);
  }

  int64_t value() const {
    return value_;
  }

  void set_value(int64_t value) {
    has_fields_.Set(LightweightRequestPB_MapEntry_DoNotUseFields::kValue);
    value_ = value;
  }

  int64_t* mutable_value() {
    has_fields_.Set(LightweightRequestPB_MapEntry_DoNotUseFields::kValue);
    return &value_;
  }

  bool has_value() const {
    return has_fields_.Test(LightweightRequestPB_MapEntry_DoNotUseFields::kValue);
  }

  void clear_value() {
    value_ = int64_t();
    has_fields_.Reset(LightweightRequestPB_MapEntry_DoNotUseFields::kValue);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<LightweightRequestPB_MapEntry_DoNotUseFields> has_fields_;
  mutable size_t cached_size_ = 0;
  ::yb::Slice key_ = ::yb::Slice();
  int64_t value_ = int64_t();
};

YB_DEFINE_ENUM(LightweightRequestPBFields,
  (kI32)
  (kI64)
  (kF32)
  (kF64)
  (kU32)
  (kU64)
  (kR32)
  (kR64)
  (kStr)
  (kBytes)
  (kEn)
  (kSf32)
  (kSf64)
  (kSi32)
  (kSi64)
  (kMessage)
  (kExtraData)
);

class LWLightweightRequestPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWLightweightRequestPB(::yb::Arena* arena);
  LWLightweightRequestPB(::yb::Arena* arena, const LWLightweightRequestPB& rhs);

  LWLightweightRequestPB(::yb::Arena* arena, const LightweightRequestPB& rhs) 
      : LWLightweightRequestPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWLightweightRequestPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const LightweightRequestPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWLightweightRequestPB& rhs);
  void CopyFrom(const LightweightRequestPB& rhs);

  void ToGoogleProtobuf(LightweightRequestPB* out) const;

  LightweightRequestPB ToGoogleProtobuf() const {
    LightweightRequestPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  using LWMapEntry = ::yb::rpc_test::LWLightweightRequestPB_LWMapEntry_DoNotUse;

  int32_t i32() const {
    return i32_;
  }

  void set_i32(int32_t value) {
    has_fields_.Set(LightweightRequestPBFields::kI32);
    i32_ = value;
  }

  int32_t* mutable_i32() {
    has_fields_.Set(LightweightRequestPBFields::kI32);
    return &i32_;
  }

  bool has_i32() const {
    return has_fields_.Test(LightweightRequestPBFields::kI32);
  }

  void clear_i32() {
    i32_ = int32_t();
    has_fields_.Reset(LightweightRequestPBFields::kI32);
  }

  int64_t i64() const {
    return i64_;
  }

  void set_i64(int64_t value) {
    has_fields_.Set(LightweightRequestPBFields::kI64);
    i64_ = value;
  }

  int64_t* mutable_i64() {
    has_fields_.Set(LightweightRequestPBFields::kI64);
    return &i64_;
  }

  bool has_i64() const {
    return has_fields_.Test(LightweightRequestPBFields::kI64);
  }

  void clear_i64() {
    i64_ = int64_t();
    has_fields_.Reset(LightweightRequestPBFields::kI64);
  }

  uint32_t f32() const {
    return f32_;
  }

  void set_f32(uint32_t value) {
    has_fields_.Set(LightweightRequestPBFields::kF32);
    f32_ = value;
  }

  uint32_t* mutable_f32() {
    has_fields_.Set(LightweightRequestPBFields::kF32);
    return &f32_;
  }

  bool has_f32() const {
    return has_fields_.Test(LightweightRequestPBFields::kF32);
  }

  void clear_f32() {
    f32_ = uint32_t();
    has_fields_.Reset(LightweightRequestPBFields::kF32);
  }

  uint64_t f64() const {
    return f64_;
  }

  void set_f64(uint64_t value) {
    has_fields_.Set(LightweightRequestPBFields::kF64);
    f64_ = value;
  }

  uint64_t* mutable_f64() {
    has_fields_.Set(LightweightRequestPBFields::kF64);
    return &f64_;
  }

  bool has_f64() const {
    return has_fields_.Test(LightweightRequestPBFields::kF64);
  }

  void clear_f64() {
    f64_ = uint64_t();
    has_fields_.Reset(LightweightRequestPBFields::kF64);
  }

  uint32_t u32() const {
    return u32_;
  }

  void set_u32(uint32_t value) {
    has_fields_.Set(LightweightRequestPBFields::kU32);
    u32_ = value;
  }

  uint32_t* mutable_u32() {
    has_fields_.Set(LightweightRequestPBFields::kU32);
    return &u32_;
  }

  bool has_u32() const {
    return has_fields_.Test(LightweightRequestPBFields::kU32);
  }

  void clear_u32() {
    u32_ = uint32_t();
    has_fields_.Reset(LightweightRequestPBFields::kU32);
  }

  uint64_t u64() const {
    return u64_;
  }

  void set_u64(uint64_t value) {
    has_fields_.Set(LightweightRequestPBFields::kU64);
    u64_ = value;
  }

  uint64_t* mutable_u64() {
    has_fields_.Set(LightweightRequestPBFields::kU64);
    return &u64_;
  }

  bool has_u64() const {
    return has_fields_.Test(LightweightRequestPBFields::kU64);
  }

  void clear_u64() {
    u64_ = uint64_t();
    has_fields_.Reset(LightweightRequestPBFields::kU64);
  }

  float r32() const {
    return r32_;
  }

  void set_r32(float value) {
    has_fields_.Set(LightweightRequestPBFields::kR32);
    r32_ = value;
  }

  float* mutable_r32() {
    has_fields_.Set(LightweightRequestPBFields::kR32);
    return &r32_;
  }

  bool has_r32() const {
    return has_fields_.Test(LightweightRequestPBFields::kR32);
  }

  void clear_r32() {
    r32_ = float();
    has_fields_.Reset(LightweightRequestPBFields::kR32);
  }

  double r64() const {
    return r64_;
  }

  void set_r64(double value) {
    has_fields_.Set(LightweightRequestPBFields::kR64);
    r64_ = value;
  }

  double* mutable_r64() {
    has_fields_.Set(LightweightRequestPBFields::kR64);
    return &r64_;
  }

  bool has_r64() const {
    return has_fields_.Test(LightweightRequestPBFields::kR64);
  }

  void clear_r64() {
    r64_ = double();
    has_fields_.Reset(LightweightRequestPBFields::kR64);
  }

  ::yb::Slice str() const {
    return str_;
  }

  void dup_str(::yb::Slice value) {
    has_fields_.Set(LightweightRequestPBFields::kStr);
    str_ = arena_.DupSlice(value);
  }

  void ref_str(::yb::Slice value) {
    has_fields_.Set(LightweightRequestPBFields::kStr);
    str_ = value;
  }

  ::yb::Slice* mutable_str() {
    has_fields_.Set(LightweightRequestPBFields::kStr);
    return &str_;
  }

  bool has_str() const {
    return has_fields_.Test(LightweightRequestPBFields::kStr);
  }

  void clear_str() {
    str_ = ::yb::Slice();
    has_fields_.Reset(LightweightRequestPBFields::kStr);
  }

  ::yb::Slice bytes() const {
    return bytes_;
  }

  void dup_bytes(::yb::Slice value) {
    has_fields_.Set(LightweightRequestPBFields::kBytes);
    bytes_ = arena_.DupSlice(value);
  }

  void ref_bytes(::yb::Slice value) {
    has_fields_.Set(LightweightRequestPBFields::kBytes);
    bytes_ = value;
  }

  ::yb::Slice* mutable_bytes() {
    has_fields_.Set(LightweightRequestPBFields::kBytes);
    return &bytes_;
  }

  bool has_bytes() const {
    return has_fields_.Test(LightweightRequestPBFields::kBytes);
  }

  void clear_bytes() {
    bytes_ = ::yb::Slice();
    has_fields_.Reset(LightweightRequestPBFields::kBytes);
  }

  ::yb::rpc_test::LightweightEnum en() const {
    return en_;
  }

  void set_en(::yb::rpc_test::LightweightEnum value) {
    has_fields_.Set(LightweightRequestPBFields::kEn);
    en_ = value;
  }

  ::yb::rpc_test::LightweightEnum* mutable_en() {
    has_fields_.Set(LightweightRequestPBFields::kEn);
    return &en_;
  }

  bool has_en() const {
    return has_fields_.Test(LightweightRequestPBFields::kEn);
  }

  void clear_en() {
    en_ = ::yb::rpc_test::LightweightEnum();
    has_fields_.Reset(LightweightRequestPBFields::kEn);
  }

  int32_t sf32() const {
    return sf32_;
  }

  void set_sf32(int32_t value) {
    has_fields_.Set(LightweightRequestPBFields::kSf32);
    sf32_ = value;
  }

  int32_t* mutable_sf32() {
    has_fields_.Set(LightweightRequestPBFields::kSf32);
    return &sf32_;
  }

  bool has_sf32() const {
    return has_fields_.Test(LightweightRequestPBFields::kSf32);
  }

  void clear_sf32() {
    sf32_ = int32_t();
    has_fields_.Reset(LightweightRequestPBFields::kSf32);
  }

  int64_t sf64() const {
    return sf64_;
  }

  void set_sf64(int64_t value) {
    has_fields_.Set(LightweightRequestPBFields::kSf64);
    sf64_ = value;
  }

  int64_t* mutable_sf64() {
    has_fields_.Set(LightweightRequestPBFields::kSf64);
    return &sf64_;
  }

  bool has_sf64() const {
    return has_fields_.Test(LightweightRequestPBFields::kSf64);
  }

  void clear_sf64() {
    sf64_ = int64_t();
    has_fields_.Reset(LightweightRequestPBFields::kSf64);
  }

  int32_t si32() const {
    return si32_;
  }

  void set_si32(int32_t value) {
    has_fields_.Set(LightweightRequestPBFields::kSi32);
    si32_ = value;
  }

  int32_t* mutable_si32() {
    has_fields_.Set(LightweightRequestPBFields::kSi32);
    return &si32_;
  }

  bool has_si32() const {
    return has_fields_.Test(LightweightRequestPBFields::kSi32);
  }

  void clear_si32() {
    si32_ = int32_t();
    has_fields_.Reset(LightweightRequestPBFields::kSi32);
  }

  int64_t si64() const {
    return si64_;
  }

  void set_si64(int64_t value) {
    has_fields_.Set(LightweightRequestPBFields::kSi64);
    si64_ = value;
  }

  int64_t* mutable_si64() {
    has_fields_.Set(LightweightRequestPBFields::kSi64);
    return &si64_;
  }

  bool has_si64() const {
    return has_fields_.Test(LightweightRequestPBFields::kSi64);
  }

  void clear_si64() {
    si64_ = int64_t();
    has_fields_.Reset(LightweightRequestPBFields::kSi64);
  }

  const ::yb::MCVector<uint32_t>& ru32() const {
    return ru32_;
  }

  ::yb::MCVector<uint32_t>* mutable_ru32() {
    return &ru32_;
  }

  const ::yb::MCVector<uint32_t>& rf32() const {
    return rf32_;
  }

  ::yb::MCVector<uint32_t>* mutable_rf32() {
    return &rf32_;
  }

  const ::yb::MCVector<::yb::Slice>& rstr() const {
    return rstr_;
  }

  ::yb::MCVector<::yb::Slice>* mutable_rstr() {
    return &rstr_;
  }

  const ::yb::rpc_test::LWLightweightSubMessagePB& message() const {
    return message_;
  }

  ::yb::rpc_test::LWLightweightSubMessagePB* mutable_message() {
    has_fields_.Set(LightweightRequestPBFields::kMessage);
    return &message_;
  }

  bool has_message() const {
    return has_fields_.Test(LightweightRequestPBFields::kMessage);
  }

  void clear_message() {
    message_.Clear();
    has_fields_.Reset(LightweightRequestPBFields::kMessage);
  }

  const ::yb::ArenaList<::yb::rpc_test::LWLightweightSubMessagePB>& repeated_messages() const {
    return repeated_messages_;
  }

  ::yb::ArenaList<::yb::rpc_test::LWLightweightSubMessagePB>* mutable_repeated_messages() {
    return &repeated_messages_;
  }

  ::yb::rpc_test::LWLightweightSubMessagePB* add_repeated_messages() {
    return &repeated_messages_.emplace_back();
  }

  const ::yb::MCVector<uint64_t>& packed_u64() const {
    return packed_u64_;
  }

  ::yb::MCVector<uint64_t>* mutable_packed_u64() {
    return &packed_u64_;
  }

  const ::yb::MCVector<uint32_t>& packed_f32() const {
    return packed_f32_;
  }

  ::yb::MCVector<uint32_t>* mutable_packed_f32() {
    return &packed_f32_;
  }

  const ::yb::ArenaList<::yb::rpc_test::LWLightweightPairPB>& pairs() const {
    return pairs_;
  }

  ::yb::ArenaList<::yb::rpc_test::LWLightweightPairPB>* mutable_pairs() {
    return &pairs_;
  }

  ::yb::rpc_test::LWLightweightPairPB* add_pairs() {
    return &pairs_.emplace_back();
  }

  const ::yb::rpc_test::LWLightweightSubMessagePB& ptr_message() const {
    return ptr_message_ ? *ptr_message_ : ::yb::rpc::empty_message<::yb::rpc_test::LWLightweightSubMessagePB>()0;
  }

  ::yb::rpc_test::LWLightweightSubMessagePB& ref_ptr_message(::yb::rpc_test::LWLightweightSubMessagePB* value) {
    ptr_message_ = value;
    return *ptr_message_;
  }

  ::yb::rpc_test::LWLightweightSubMessagePB* mutable_ptr_message() {
    if (!ptr_message_) {
      ptr_message_ = arena_.NewObject<::yb::rpc_test::LWLightweightSubMessagePB>(&arena_);
    }
    return ptr_message_;
  }

  bool has_ptr_message() const {
    return ptr_message_ != nullptr;
  }

  void clear_ptr_message() {
    ptr_message_ = nullptr;
  }

  const ::yb::ArenaList<::yb::rpc_test::LWLightweightRequestPB_LWMapEntry_DoNotUse>& map() const {
    return map_;
  }

  ::yb::ArenaList<::yb::rpc_test::LWLightweightRequestPB_LWMapEntry_DoNotUse>* mutable_map() {
    return &map_;
  }

  ::yb::rpc_test::LWLightweightRequestPB_LWMapEntry_DoNotUse* add_map() {
    return &map_.emplace_back();
  }

  const ::yb::rpc::LWAny& extra_data() const {
    return extra_data_;
  }

  ::yb::rpc::LWAny* mutable_extra_data() {
    has_fields_.Set(LightweightRequestPBFields::kExtraData);
    return &extra_data_;
  }

  bool has_extra_data() const {
    return has_fields_.Test(LightweightRequestPBFields::kExtraData);
  }

  void clear_extra_data() {
    extra_data_.Clear();
    has_fields_.Reset(LightweightRequestPBFields::kExtraData);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<LightweightRequestPBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  int32_t i32_ = int32_t();
  int64_t i64_ = int64_t();
  uint32_t f32_ = uint32_t();
  uint64_t f64_ = uint64_t();
  uint32_t u32_ = uint32_t();
  uint64_t u64_ = uint64_t();
  float r32_ = float();
  double r64_ = double();
  ::yb::Slice str_ = ::yb::Slice();
  ::yb::Slice bytes_ = ::yb::Slice();
  ::yb::rpc_test::LightweightEnum en_ = ::yb::rpc_test::LightweightEnum();
  int32_t sf32_ = int32_t();
  int64_t sf64_ = int64_t();
  int32_t si32_ = int32_t();
  int64_t si64_ = int64_t();
  ::yb::MCVector<uint32_t> ru32_;
  ::yb::MCVector<uint32_t> rf32_;
  ::yb::MCVector<::yb::Slice> rstr_;
  ::yb::rpc_test::LWLightweightSubMessagePB message_;
  ::yb::ArenaList<::yb::rpc_test::LWLightweightSubMessagePB> repeated_messages_;
  ::yb::MCVector<uint64_t> packed_u64_;
  mutable size_t packed_u64_cached_size_ = 0;
  ::yb::MCVector<uint32_t> packed_f32_;
  ::yb::ArenaList<::yb::rpc_test::LWLightweightPairPB> pairs_;
  ::yb::rpc_test::LWLightweightSubMessagePB* ptr_message_ = nullptr;
  ::yb::ArenaList<::yb::rpc_test::LWLightweightRequestPB_LWMapEntry_DoNotUse> map_;
  ::yb::rpc::LWAny extra_data_;
};

YB_DEFINE_ENUM(LightweightResponsePB_MapEntry_DoNotUseFields,
  (kKey)
  (kValue)
);

class LWLightweightResponsePB_LWMapEntry_DoNotUse : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWLightweightResponsePB_LWMapEntry_DoNotUse(::yb::Arena* arena);
  LWLightweightResponsePB_LWMapEntry_DoNotUse(::yb::Arena* arena, const LWLightweightResponsePB_LWMapEntry_DoNotUse& rhs);

  LWLightweightResponsePB_LWMapEntry_DoNotUse(::yb::Arena* arena, const ::google::protobuf::MapPair<std::string, int64_t>& rhs) 
      : LWLightweightResponsePB_LWMapEntry_DoNotUse(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWLightweightResponsePB_LWMapEntry_DoNotUse& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const ::google::protobuf::MapPair<std::string, int64_t>& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWLightweightResponsePB_LWMapEntry_DoNotUse& rhs);
  void CopyFrom(const ::google::protobuf::MapPair<std::string, int64_t>& rhs);

  ::yb::Slice key() const {
    return key_;
  }

  void dup_key(::yb::Slice value) {
    has_fields_.Set(LightweightResponsePB_MapEntry_DoNotUseFields::kKey);
    key_ = arena_.DupSlice(value);
  }

  void ref_key(::yb::Slice value) {
    has_fields_.Set(LightweightResponsePB_MapEntry_DoNotUseFields::kKey);
    key_ = value;
  }

  ::yb::Slice* mutable_key() {
    has_fields_.Set(LightweightResponsePB_MapEntry_DoNotUseFields::kKey);
    return &key_;
  }

  bool has_key() const {
    return has_fields_.Test(LightweightResponsePB_MapEntry_DoNotUseFields::kKey);
  }

  void clear_key() {
    key_ = ::yb::Slice();
    has_fields_.Reset(LightweightResponsePB_MapEntry_DoNotUseFields::kKey);
  }

  int64_t value() const {
    return value_;
  }

  void set_value(int64_t value) {
    has_fields_.Set(LightweightResponsePB_MapEntry_DoNotUseFields::kValue);
    value_ = value;
  }

  int64_t* mutable_value() {
    has_fields_.Set(LightweightResponsePB_MapEntry_DoNotUseFields::kValue);
    return &value_;
  }

  bool has_value() const {
    return has_fields_.Test(LightweightResponsePB_MapEntry_DoNotUseFields::kValue);
  }

  void clear_value() {
    value_ = int64_t();
    has_fields_.Reset(LightweightResponsePB_MapEntry_DoNotUseFields::kValue);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<LightweightResponsePB_MapEntry_DoNotUseFields> has_fields_;
  mutable size_t cached_size_ = 0;
  ::yb::Slice key_ = ::yb::Slice();
  int64_t value_ = int64_t();
};

YB_DEFINE_ENUM(LightweightResponsePBFields,
  (kI32)
  (kI64)
  (kF32)
  (kF64)
  (kU32)
  (kU64)
  (kR32)
  (kR64)
  (kStr)
  (kBytes)
  (kEn)
  (kSf32)
  (kSf64)
  (kSi32)
  (kSi64)
  (kMessage)
  (kShortDebugString)
);

class LWLightweightResponsePB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWLightweightResponsePB(::yb::Arena* arena);
  LWLightweightResponsePB(::yb::Arena* arena, const LWLightweightResponsePB& rhs);

  LWLightweightResponsePB(::yb::Arena* arena, const LightweightResponsePB& rhs) 
      : LWLightweightResponsePB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWLightweightResponsePB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const LightweightResponsePB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWLightweightResponsePB& rhs);
  void CopyFrom(const LightweightResponsePB& rhs);

  void ToGoogleProtobuf(LightweightResponsePB* out) const;

  LightweightResponsePB ToGoogleProtobuf() const {
    LightweightResponsePB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  using LWMapEntry = ::yb::rpc_test::LWLightweightResponsePB_LWMapEntry_DoNotUse;

  int32_t i32() const {
    return i32_;
  }

  void set_i32(int32_t value) {
    has_fields_.Set(LightweightResponsePBFields::kI32);
    i32_ = value;
  }

  int32_t* mutable_i32() {
    has_fields_.Set(LightweightResponsePBFields::kI32);
    return &i32_;
  }

  bool has_i32() const {
    return has_fields_.Test(LightweightResponsePBFields::kI32);
  }

  void clear_i32() {
    i32_ = int32_t();
    has_fields_.Reset(LightweightResponsePBFields::kI32);
  }

  int64_t i64() const {
    return i64_;
  }

  void set_i64(int64_t value) {
    has_fields_.Set(LightweightResponsePBFields::kI64);
    i64_ = value;
  }

  int64_t* mutable_i64() {
    has_fields_.Set(LightweightResponsePBFields::kI64);
    return &i64_;
  }

  bool has_i64() const {
    return has_fields_.Test(LightweightResponsePBFields::kI64);
  }

  void clear_i64() {
    i64_ = int64_t();
    has_fields_.Reset(LightweightResponsePBFields::kI64);
  }

  uint32_t f32() const {
    return f32_;
  }

  void set_f32(uint32_t value) {
    has_fields_.Set(LightweightResponsePBFields::kF32);
    f32_ = value;
  }

  uint32_t* mutable_f32() {
    has_fields_.Set(LightweightResponsePBFields::kF32);
    return &f32_;
  }

  bool has_f32() const {
    return has_fields_.Test(LightweightResponsePBFields::kF32);
  }

  void clear_f32() {
    f32_ = uint32_t();
    has_fields_.Reset(LightweightResponsePBFields::kF32);
  }

  uint64_t f64() const {
    return f64_;
  }

  void set_f64(uint64_t value) {
    has_fields_.Set(LightweightResponsePBFields::kF64);
    f64_ = value;
  }

  uint64_t* mutable_f64() {
    has_fields_.Set(LightweightResponsePBFields::kF64);
    return &f64_;
  }

  bool has_f64() const {
    return has_fields_.Test(LightweightResponsePBFields::kF64);
  }

  void clear_f64() {
    f64_ = uint64_t();
    has_fields_.Reset(LightweightResponsePBFields::kF64);
  }

  uint32_t u32() const {
    return u32_;
  }

  void set_u32(uint32_t value) {
    has_fields_.Set(LightweightResponsePBFields::kU32);
    u32_ = value;
  }

  uint32_t* mutable_u32() {
    has_fields_.Set(LightweightResponsePBFields::kU32);
    return &u32_;
  }

  bool has_u32() const {
    return has_fields_.Test(LightweightResponsePBFields::kU32);
  }

  void clear_u32() {
    u32_ = uint32_t();
    has_fields_.Reset(LightweightResponsePBFields::kU32);
  }

  uint64_t u64() const {
    return u64_;
  }

  void set_u64(uint64_t value) {
    has_fields_.Set(LightweightResponsePBFields::kU64);
    u64_ = value;
  }

  uint64_t* mutable_u64() {
    has_fields_.Set(LightweightResponsePBFields::kU64);
    return &u64_;
  }

  bool has_u64() const {
    return has_fields_.Test(LightweightResponsePBFields::kU64);
  }

  void clear_u64() {
    u64_ = uint64_t();
    has_fields_.Reset(LightweightResponsePBFields::kU64);
  }

  float r32() const {
    return r32_;
  }

  void set_r32(float value) {
    has_fields_.Set(LightweightResponsePBFields::kR32);
    r32_ = value;
  }

  float* mutable_r32() {
    has_fields_.Set(LightweightResponsePBFields::kR32);
    return &r32_;
  }

  bool has_r32() const {
    return has_fields_.Test(LightweightResponsePBFields::kR32);
  }

  void clear_r32() {
    r32_ = float();
    has_fields_.Reset(LightweightResponsePBFields::kR32);
  }

  double r64() const {
    return r64_;
  }

  void set_r64(double value) {
    has_fields_.Set(LightweightResponsePBFields::kR64);
    r64_ = value;
  }

  double* mutable_r64() {
    has_fields_.Set(LightweightResponsePBFields::kR64);
    return &r64_;
  }

  bool has_r64() const {
    return has_fields_.Test(LightweightResponsePBFields::kR64);
  }

  void clear_r64() {
    r64_ = double();
    has_fields_.Reset(LightweightResponsePBFields::kR64);
  }

  ::yb::Slice str() const {
    return str_;
  }

  void dup_str(::yb::Slice value) {
    has_fields_.Set(LightweightResponsePBFields::kStr);
    str_ = arena_.DupSlice(value);
  }

  void ref_str(::yb::Slice value) {
    has_fields_.Set(LightweightResponsePBFields::kStr);
    str_ = value;
  }

  ::yb::Slice* mutable_str() {
    has_fields_.Set(LightweightResponsePBFields::kStr);
    return &str_;
  }

  bool has_str() const {
    return has_fields_.Test(LightweightResponsePBFields::kStr);
  }

  void clear_str() {
    str_ = ::yb::Slice();
    has_fields_.Reset(LightweightResponsePBFields::kStr);
  }

  ::yb::Slice bytes() const {
    return bytes_;
  }

  void dup_bytes(::yb::Slice value) {
    has_fields_.Set(LightweightResponsePBFields::kBytes);
    bytes_ = arena_.DupSlice(value);
  }

  void ref_bytes(::yb::Slice value) {
    has_fields_.Set(LightweightResponsePBFields::kBytes);
    bytes_ = value;
  }

  ::yb::Slice* mutable_bytes() {
    has_fields_.Set(LightweightResponsePBFields::kBytes);
    return &bytes_;
  }

  bool has_bytes() const {
    return has_fields_.Test(LightweightResponsePBFields::kBytes);
  }

  void clear_bytes() {
    bytes_ = ::yb::Slice();
    has_fields_.Reset(LightweightResponsePBFields::kBytes);
  }

  ::yb::rpc_test::LightweightEnum en() const {
    return en_;
  }

  void set_en(::yb::rpc_test::LightweightEnum value) {
    has_fields_.Set(LightweightResponsePBFields::kEn);
    en_ = value;
  }

  ::yb::rpc_test::LightweightEnum* mutable_en() {
    has_fields_.Set(LightweightResponsePBFields::kEn);
    return &en_;
  }

  bool has_en() const {
    return has_fields_.Test(LightweightResponsePBFields::kEn);
  }

  void clear_en() {
    en_ = ::yb::rpc_test::LightweightEnum();
    has_fields_.Reset(LightweightResponsePBFields::kEn);
  }

  int32_t sf32() const {
    return sf32_;
  }

  void set_sf32(int32_t value) {
    has_fields_.Set(LightweightResponsePBFields::kSf32);
    sf32_ = value;
  }

  int32_t* mutable_sf32() {
    has_fields_.Set(LightweightResponsePBFields::kSf32);
    return &sf32_;
  }

  bool has_sf32() const {
    return has_fields_.Test(LightweightResponsePBFields::kSf32);
  }

  void clear_sf32() {
    sf32_ = int32_t();
    has_fields_.Reset(LightweightResponsePBFields::kSf32);
  }

  int64_t sf64() const {
    return sf64_;
  }

  void set_sf64(int64_t value) {
    has_fields_.Set(LightweightResponsePBFields::kSf64);
    sf64_ = value;
  }

  int64_t* mutable_sf64() {
    has_fields_.Set(LightweightResponsePBFields::kSf64);
    return &sf64_;
  }

  bool has_sf64() const {
    return has_fields_.Test(LightweightResponsePBFields::kSf64);
  }

  void clear_sf64() {
    sf64_ = int64_t();
    has_fields_.Reset(LightweightResponsePBFields::kSf64);
  }

  int32_t si32() const {
    return si32_;
  }

  void set_si32(int32_t value) {
    has_fields_.Set(LightweightResponsePBFields::kSi32);
    si32_ = value;
  }

  int32_t* mutable_si32() {
    has_fields_.Set(LightweightResponsePBFields::kSi32);
    return &si32_;
  }

  bool has_si32() const {
    return has_fields_.Test(LightweightResponsePBFields::kSi32);
  }

  void clear_si32() {
    si32_ = int32_t();
    has_fields_.Reset(LightweightResponsePBFields::kSi32);
  }

  int64_t si64() const {
    return si64_;
  }

  void set_si64(int64_t value) {
    has_fields_.Set(LightweightResponsePBFields::kSi64);
    si64_ = value;
  }

  int64_t* mutable_si64() {
    has_fields_.Set(LightweightResponsePBFields::kSi64);
    return &si64_;
  }

  bool has_si64() const {
    return has_fields_.Test(LightweightResponsePBFields::kSi64);
  }

  void clear_si64() {
    si64_ = int64_t();
    has_fields_.Reset(LightweightResponsePBFields::kSi64);
  }

  const ::yb::MCVector<uint32_t>& ru32() const {
    return ru32_;
  }

  ::yb::MCVector<uint32_t>* mutable_ru32() {
    return &ru32_;
  }

  const ::yb::MCVector<uint32_t>& rf32() const {
    return rf32_;
  }

  ::yb::MCVector<uint32_t>* mutable_rf32() {
    return &rf32_;
  }

  const ::yb::MCVector<::yb::Slice>& rstr() const {
    return rstr_;
  }

  ::yb::MCVector<::yb::Slice>* mutable_rstr() {
    return &rstr_;
  }

  const ::yb::rpc_test::LWLightweightSubMessagePB& message() const {
    return message_;
  }

  ::yb::rpc_test::LWLightweightSubMessagePB* mutable_message() {
    has_fields_.Set(LightweightResponsePBFields::kMessage);
    return &message_;
  }

  bool has_message() const {
    return has_fields_.Test(LightweightResponsePBFields::kMessage);
  }

  void clear_message() {
    message_.Clear();
    has_fields_.Reset(LightweightResponsePBFields::kMessage);
  }

  const ::yb::ArenaList<::yb::rpc_test::LWLightweightSubMessagePB>& repeated_messages() const {
    return repeated_messages_;
  }

  ::yb::ArenaList<::yb::rpc_test::LWLightweightSubMessagePB>* mutable_repeated_messages() {
    return &repeated_messages_;
  }

  ::yb::rpc_test::LWLightweightSubMessagePB* add_repeated_messages() {
    return &repeated_messages_.emplace_back();
  }

  const ::yb::ArenaList<::yb::rpc_test::LWLightweightSubMessagePB>& repeated_messages_copy() const {
    return repeated_messages_copy_;
  }

  ::yb::ArenaList<::yb::rpc_test::LWLightweightSubMessagePB>* mutable_repeated_messages_copy() {
    return &repeated_messages_copy_;
  }

  ::yb::rpc_test::LWLightweightSubMessagePB* add_repeated_messages_copy() {
    return &repeated_messages_copy_.emplace_back();
  }

  const ::yb::MCVector<uint64_t>& packed_u64() const {
    return packed_u64_;
  }

  ::yb::MCVector<uint64_t>* mutable_packed_u64() {
    return &packed_u64_;
  }

  const ::yb::MCVector<uint32_t>& packed_f32() const {
    return packed_f32_;
  }

  ::yb::MCVector<uint32_t>* mutable_packed_f32() {
    return &packed_f32_;
  }

  const ::yb::ArenaList<::yb::rpc_test::LWLightweightPairPB>& pairs() const {
    return pairs_;
  }

  ::yb::ArenaList<::yb::rpc_test::LWLightweightPairPB>* mutable_pairs() {
    return &pairs_;
  }

  ::yb::rpc_test::LWLightweightPairPB* add_pairs() {
    return &pairs_.emplace_back();
  }

  const ::yb::rpc_test::LWLightweightSubMessagePB& ptr_message() const {
    return ptr_message_ ? *ptr_message_ : ::yb::rpc::empty_message<::yb::rpc_test::LWLightweightSubMessagePB>()0;
  }

  ::yb::rpc_test::LWLightweightSubMessagePB& ref_ptr_message(::yb::rpc_test::LWLightweightSubMessagePB* value) {
    ptr_message_ = value;
    return *ptr_message_;
  }

  ::yb::rpc_test::LWLightweightSubMessagePB* mutable_ptr_message() {
    if (!ptr_message_) {
      ptr_message_ = arena_.NewObject<::yb::rpc_test::LWLightweightSubMessagePB>(&arena_);
    }
    return ptr_message_;
  }

  bool has_ptr_message() const {
    return ptr_message_ != nullptr;
  }

  void clear_ptr_message() {
    ptr_message_ = nullptr;
  }

  const ::yb::ArenaList<::yb::rpc_test::LWLightweightResponsePB_LWMapEntry_DoNotUse>& map() const {
    return map_;
  }

  ::yb::ArenaList<::yb::rpc_test::LWLightweightResponsePB_LWMapEntry_DoNotUse>* mutable_map() {
    return &map_;
  }

  ::yb::rpc_test::LWLightweightResponsePB_LWMapEntry_DoNotUse* add_map() {
    return &map_.emplace_back();
  }

  ::yb::Slice short_debug_string() const {
    return short_debug_string_;
  }

  void dup_short_debug_string(::yb::Slice value) {
    has_fields_.Set(LightweightResponsePBFields::kShortDebugString);
    short_debug_string_ = arena_.DupSlice(value);
  }

  void ref_short_debug_string(::yb::Slice value) {
    has_fields_.Set(LightweightResponsePBFields::kShortDebugString);
    short_debug_string_ = value;
  }

  ::yb::Slice* mutable_short_debug_string() {
    has_fields_.Set(LightweightResponsePBFields::kShortDebugString);
    return &short_debug_string_;
  }

  bool has_short_debug_string() const {
    return has_fields_.Test(LightweightResponsePBFields::kShortDebugString);
  }

  void clear_short_debug_string() {
    short_debug_string_ = ::yb::Slice();
    has_fields_.Reset(LightweightResponsePBFields::kShortDebugString);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<LightweightResponsePBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  int32_t i32_ = int32_t();
  int64_t i64_ = int64_t();
  uint32_t f32_ = uint32_t();
  uint64_t f64_ = uint64_t();
  uint32_t u32_ = uint32_t();
  uint64_t u64_ = uint64_t();
  float r32_ = float();
  double r64_ = double();
  ::yb::Slice str_ = ::yb::Slice();
  ::yb::Slice bytes_ = ::yb::Slice();
  ::yb::rpc_test::LightweightEnum en_ = ::yb::rpc_test::LightweightEnum();
  int32_t sf32_ = int32_t();
  int64_t sf64_ = int64_t();
  int32_t si32_ = int32_t();
  int64_t si64_ = int64_t();
  ::yb::MCVector<uint32_t> ru32_;
  ::yb::MCVector<uint32_t> rf32_;
  ::yb::MCVector<::yb::Slice> rstr_;
  ::yb::rpc_test::LWLightweightSubMessagePB message_;
  ::yb::ArenaList<::yb::rpc_test::LWLightweightSubMessagePB> repeated_messages_;
  ::yb::ArenaList<::yb::rpc_test::LWLightweightSubMessagePB> repeated_messages_copy_;
  ::yb::MCVector<uint64_t> packed_u64_;
  mutable size_t packed_u64_cached_size_ = 0;
  ::yb::MCVector<uint32_t> packed_f32_;
  ::yb::ArenaList<::yb::rpc_test::LWLightweightPairPB> pairs_;
  ::yb::rpc_test::LWLightweightSubMessagePB* ptr_message_ = nullptr;
  ::yb::ArenaList<::yb::rpc_test::LWLightweightResponsePB_LWMapEntry_DoNotUse> map_;
  ::yb::Slice short_debug_string_ = ::yb::Slice();
};

YB_DEFINE_ENUM(TrivialRequestPBFields,
  (kValue)
);

class LWTrivialRequestPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWTrivialRequestPB(::yb::Arena* arena);
  LWTrivialRequestPB(::yb::Arena* arena, const LWTrivialRequestPB& rhs);

  LWTrivialRequestPB(::yb::Arena* arena, const TrivialRequestPB& rhs) 
      : LWTrivialRequestPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWTrivialRequestPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const TrivialRequestPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWTrivialRequestPB& rhs);
  void CopyFrom(const TrivialRequestPB& rhs);

  void ToGoogleProtobuf(TrivialRequestPB* out) const;

  TrivialRequestPB ToGoogleProtobuf() const {
    TrivialRequestPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  int32_t value() const {
    return value_;
  }

  void set_value(int32_t value) {
    has_fields_.Set(TrivialRequestPBFields::kValue);
    value_ = value;
  }

  int32_t* mutable_value() {
    has_fields_.Set(TrivialRequestPBFields::kValue);
    return &value_;
  }

  bool has_value() const {
    return has_fields_.Test(TrivialRequestPBFields::kValue);
  }

  void clear_value() {
    value_ = int32_t();
    has_fields_.Reset(TrivialRequestPBFields::kValue);
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::EnumBitSet<TrivialRequestPBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  int32_t value_ = int32_t();
};

YB_DEFINE_ENUM(TrivialErrorPBFields,
  (kCode)
);

class LWTrivialErrorPB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWTrivialErrorPB(::yb::Arena* arena);
  LWTrivialErrorPB(::yb::Arena* arena, const LWTrivialErrorPB& rhs);

  LWTrivialErrorPB(::yb::Arena* arena, const TrivialErrorPB& rhs) 
      : LWTrivialErrorPB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWTrivialErrorPB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const TrivialErrorPB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWTrivialErrorPB& rhs);
  void CopyFrom(const TrivialErrorPB& rhs);

  void ToGoogleProtobuf(TrivialErrorPB* out) const;

  TrivialErrorPB ToGoogleProtobuf() const {
    TrivialErrorPB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  int32_t code() const {
    return code_;
  }

  void set_code(int32_t value) {
    has_fields_.Set(TrivialErrorPBFields::kCode);
    code_ = value;
  }

  int32_t* mutable_code() {
    has_fields_.Set(TrivialErrorPBFields::kCode);
    return &code_;
  }

  bool has_code() const {
    return has_fields_.Test(TrivialErrorPBFields::kCode);
  }

  void clear_code() {
    code_ = int32_t();
    has_fields_.Reset(TrivialErrorPBFields::kCode);
  }

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::EnumBitSet<TrivialErrorPBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  int32_t code_ = int32_t();
};

YB_DEFINE_ENUM(TrivialResponsePBFields,
  (kError)
  (kValue)
);

class LWTrivialResponsePB : public ::yb::rpc::LightweightMessage {
 public:
  explicit LWTrivialResponsePB(::yb::Arena* arena);
  LWTrivialResponsePB(::yb::Arena* arena, const LWTrivialResponsePB& rhs);

  LWTrivialResponsePB(::yb::Arena* arena, const TrivialResponsePB& rhs) 
      : LWTrivialResponsePB(arena) {
    CopyFrom(rhs);
  }

  void operator=(const LWTrivialResponsePB& rhs) {
    CopyFrom(rhs);
  }

  void operator=(const TrivialResponsePB& rhs) {
    CopyFrom(rhs);
  }

  CHECKED_STATUS ParseFromCodedStream(google::protobuf::io::CodedInputStream* cis) override;
  size_t SerializedSize() const override;
  uint8_t* SerializeToArray(uint8_t* out) const override;
  void AppendToDebugString(std::string* out) const override;

  void Clear() override;
  void CopyFrom(const LWTrivialResponsePB& rhs);
  void CopyFrom(const TrivialResponsePB& rhs);

  void ToGoogleProtobuf(TrivialResponsePB* out) const;

  TrivialResponsePB ToGoogleProtobuf() const {
    TrivialResponsePB result;
    ToGoogleProtobuf(&result);
    return result;
  }

  const ::yb::rpc_test::LWTrivialErrorPB& error() const {
    return error_;
  }

  ::yb::rpc_test::LWTrivialErrorPB* mutable_error() {
    has_fields_.Set(TrivialResponsePBFields::kError);
    return &error_;
  }

  bool has_error() const {
    return has_fields_.Test(TrivialResponsePBFields::kError);
  }

  void clear_error() {
    error_.Clear();
    has_fields_.Reset(TrivialResponsePBFields::kError);
  }

  int32_t value() const {
    return value_;
  }

  void set_value(int32_t value) {
    has_fields_.Set(TrivialResponsePBFields::kValue);
    value_ = value;
  }

  int32_t* mutable_value() {
    has_fields_.Set(TrivialResponsePBFields::kValue);
    return &value_;
  }

  bool has_value() const {
    return has_fields_.Test(TrivialResponsePBFields::kValue);
  }

  void clear_value() {
    value_ = int32_t();
    has_fields_.Reset(TrivialResponsePBFields::kValue);
  }

  ::yb::Arena& arena() const {
    return arena_;}

  size_t cached_size() const {
    return cached_size_;
  }

 private:
  ::yb::Arena& arena_;
  ::yb::EnumBitSet<TrivialResponsePBFields> has_fields_;
  mutable size_t cached_size_ = 0;
  ::yb::rpc_test::LWTrivialErrorPB error_;
  int32_t value_ = int32_t();
};

} // namespace rpc_test
} // namespace yb

YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

Coverage Report

Created: 2022-03-22 16:43