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

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

#include "yb/rpc/rtest.messages.h"

#include "yb/gutil/strings/numbers.h"

namespace yb {
namespace rpc_test {

LWAddRequestPB::LWAddRequestPB(::yb::Arena* arena) {
}

LWAddRequestPB::LWAddRequestPB(::yb::Arena* arena, const LWAddRequestPB& rhs)
    : has_fields_(rhs.has_fields_),
      x_(rhs.x_),
      y_(rhs.y_) {
}

void LWAddRequestPB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_x()) {
    ::yb::rpc::AppendFieldTitle("x", ": ", &first, out);
    *out += std::to_string(x());
  }
  if (has_y()) {
    ::yb::rpc::AppendFieldTitle("y", ": ", &first, out);
    *out += std::to_string(y());
  }
}

void LWAddRequestPB::Clear() {
  clear_x();
  clear_y();
}

void LWAddRequestPB::CopyFrom(const LWAddRequestPB& rhs) {
  if (rhs.has_x()) {
    x_ = rhs.x_;
  } else {
    clear_x();
  }
  if (rhs.has_y()) {
    y_ = rhs.y_;
  } else {
    clear_y();
  }
  has_fields_ = rhs.has_fields_;
}

void LWAddRequestPB::CopyFrom(const AddRequestPB& rhs) {
  if (rhs.has_x()) {
    x_ = rhs.x();
    has_fields_.Set(AddRequestPBFields::kX);
  } else {
    clear_x();
  }
  if (rhs.has_y()) {
    y_ = rhs.y();
    has_fields_.Set(AddRequestPBFields::kY);
  } else {
    clear_y();
  }
}

Status LWAddRequestPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(31);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // x
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, mutable_x())) {
          return ::yb::rpc::ParseFailed("x");
        }
        break;
      }
      case 2: { // y
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, mutable_y())) {
          return ::yb::rpc::ParseFailed("y");
        }
        break;
      }
    }
  }
}

uint8_t* LWAddRequestPB::SerializeToArray(uint8_t* out) const {
  if (has_x()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 8>(x_, out);
  }
  if (has_y()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 16>(y_, out);
  }
  return out;
}

size_t LWAddRequestPB::SerializedSize() const {
  size_t result = 0;
  if (has_x()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 1>(x_);
  }
  if (has_y()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 1>(y_);
  }
  cached_size_ = result;
  return result;
}

void LWAddRequestPB::ToGoogleProtobuf(AddRequestPB* out) const {
  if (has_x()) {
    out->set_x(x_);
  } else {
    out->clear_x();
  }
  if (has_y()) {
    out->set_y(y_);
  } else {
    out->clear_y();
  }
}

LWAddRequestPartialPB::LWAddRequestPartialPB(::yb::Arena* arena) {
}

LWAddRequestPartialPB::LWAddRequestPartialPB(::yb::Arena* arena, const LWAddRequestPartialPB& rhs)
    : has_fields_(rhs.has_fields_),
      x_(rhs.x_) {
}

void LWAddRequestPartialPB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_x()) {
    ::yb::rpc::AppendFieldTitle("x", ": ", &first, out);
    *out += std::to_string(x());
  }
}

void LWAddRequestPartialPB::Clear() {
  clear_x();
}

void LWAddRequestPartialPB::CopyFrom(const LWAddRequestPartialPB& rhs) {
  if (rhs.has_x()) {
    x_ = rhs.x_;
  } else {
    clear_x();
  }
  has_fields_ = rhs.has_fields_;
}

void LWAddRequestPartialPB::CopyFrom(const AddRequestPartialPB& rhs) {
  if (rhs.has_x()) {
    x_ = rhs.x();
    has_fields_.Set(AddRequestPartialPBFields::kX);
  } else {
    clear_x();
  }
}

Status LWAddRequestPartialPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(15);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // x
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, mutable_x())) {
          return ::yb::rpc::ParseFailed("x");
        }
        break;
      }
    }
  }
}

uint8_t* LWAddRequestPartialPB::SerializeToArray(uint8_t* out) const {
  if (has_x()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 8>(x_, out);
  }
  return out;
}

size_t LWAddRequestPartialPB::SerializedSize() const {
  size_t result = 0;
  if (has_x()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 1>(x_);
  }
  cached_size_ = result;
  return result;
}

void LWAddRequestPartialPB::ToGoogleProtobuf(AddRequestPartialPB* out) const {
  if (has_x()) {
    out->set_x(x_);
  } else {
    out->clear_x();
  }
}

LWAddResponsePB::LWAddResponsePB(::yb::Arena* arena) {
}

LWAddResponsePB::LWAddResponsePB(::yb::Arena* arena, const LWAddResponsePB& rhs)
    : has_fields_(rhs.has_fields_),
      result_(rhs.result_) {
}

void LWAddResponsePB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_result()) {
    ::yb::rpc::AppendFieldTitle("result", ": ", &first, out);
    *out += std::to_string(result());
  }
}

void LWAddResponsePB::Clear() {
  clear_result();
}

void LWAddResponsePB::CopyFrom(const LWAddResponsePB& rhs) {
  if (rhs.has_result()) {
    result_ = rhs.result_;
  } else {
    clear_result();
  }
  has_fields_ = rhs.has_fields_;
}

void LWAddResponsePB::CopyFrom(const AddResponsePB& rhs) {
  if (rhs.has_result()) {
    result_ = rhs.result();
    has_fields_.Set(AddResponsePBFields::kResult);
  } else {
    clear_result();
  }
}

Status LWAddResponsePB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(15);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // result
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, mutable_result())) {
          return ::yb::rpc::ParseFailed("result");
        }
        break;
      }
    }
  }
}

uint8_t* LWAddResponsePB::SerializeToArray(uint8_t* out) const {
  if (has_result()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 8>(result_, out);
  }
  return out;
}

size_t LWAddResponsePB::SerializedSize() const {
  size_t result = 0;
  if (has_result()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 1>(result_);
  }
  cached_size_ = result;
  return result;
}

void LWAddResponsePB::ToGoogleProtobuf(AddResponsePB* out) const {
  if (has_result()) {
    out->set_result(result_);
  } else {
    out->clear_result();
  }
}

LWSleepRequestPB::LWSleepRequestPB(::yb::Arena* arena) {
}

LWSleepRequestPB::LWSleepRequestPB(::yb::Arena* arena, const LWSleepRequestPB& rhs)
    : has_fields_(rhs.has_fields_),
      sleep_micros_(rhs.sleep_micros_),
      deferred_(rhs.deferred_),
      return_app_error_(rhs.return_app_error_),
      client_timeout_defined_(rhs.client_timeout_defined_) {
}

void LWSleepRequestPB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_sleep_micros()) {
    ::yb::rpc::AppendFieldTitle("sleep_micros", ": ", &first, out);
    *out += std::to_string(sleep_micros());
  }
  if (has_deferred()) {
    ::yb::rpc::AppendFieldTitle("deferred", ": ", &first, out);
    *out += std::to_string(deferred());
  }
  if (has_return_app_error()) {
    ::yb::rpc::AppendFieldTitle("return_app_error", ": ", &first, out);
    *out += std::to_string(return_app_error());
  }
  if (has_client_timeout_defined()) {
    ::yb::rpc::AppendFieldTitle("client_timeout_defined", ": ", &first, out);
    *out += std::to_string(client_timeout_defined());
  }
}

void LWSleepRequestPB::Clear() {
  clear_sleep_micros();
  clear_deferred();
  clear_return_app_error();
  clear_client_timeout_defined();
}

void LWSleepRequestPB::CopyFrom(const LWSleepRequestPB& rhs) {
  if (rhs.has_sleep_micros()) {
    sleep_micros_ = rhs.sleep_micros_;
  } else {
    clear_sleep_micros();
  }
  if (rhs.has_deferred()) {
    deferred_ = rhs.deferred_;
  } else {
    clear_deferred();
  }
  if (rhs.has_return_app_error()) {
    return_app_error_ = rhs.return_app_error_;
  } else {
    clear_return_app_error();
  }
  if (rhs.has_client_timeout_defined()) {
    client_timeout_defined_ = rhs.client_timeout_defined_;
  } else {
    clear_client_timeout_defined();
  }
  has_fields_ = rhs.has_fields_;
}

void LWSleepRequestPB::CopyFrom(const SleepRequestPB& rhs) {
  if (rhs.has_sleep_micros()) {
    sleep_micros_ = rhs.sleep_micros();
    has_fields_.Set(SleepRequestPBFields::kSleepMicros);
  } else {
    clear_sleep_micros();
  }
  if (rhs.has_deferred()) {
    deferred_ = rhs.deferred();
    has_fields_.Set(SleepRequestPBFields::kDeferred);
  } else {
    clear_deferred();
  }
  if (rhs.has_return_app_error()) {
    return_app_error_ = rhs.return_app_error();
    has_fields_.Set(SleepRequestPBFields::kReturnAppError);
  } else {
    clear_return_app_error();
  }
  if (rhs.has_client_timeout_defined()) {
    client_timeout_defined_ = rhs.client_timeout_defined();
    has_fields_.Set(SleepRequestPBFields::kClientTimeoutDefined);
  } else {
    clear_client_timeout_defined();
  }
}

Status LWSleepRequestPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(63);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // sleep_micros
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, mutable_sleep_micros())) {
          return ::yb::rpc::ParseFailed("sleep_micros");
        }
        break;
      }
      case 2: { // deferred
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BOOL, bool>::Read(input, mutable_deferred())) {
          return ::yb::rpc::ParseFailed("deferred");
        }
        break;
      }
      case 3: { // return_app_error
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BOOL, bool>::Read(input, mutable_return_app_error())) {
          return ::yb::rpc::ParseFailed("return_app_error");
        }
        break;
      }
      case 4: { // client_timeout_defined
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BOOL, bool>::Read(input, mutable_client_timeout_defined())) {
          return ::yb::rpc::ParseFailed("client_timeout_defined");
        }
        break;
      }
    }
  }
}

uint8_t* LWSleepRequestPB::SerializeToArray(uint8_t* out) const {
  if (has_sleep_micros()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 8>(sleep_micros_, out);
  }
  if (has_deferred()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BOOL, bool>, 16>(deferred_, out);
  }
  if (has_return_app_error()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BOOL, bool>, 24>(return_app_error_, out);
  }
  if (has_client_timeout_defined()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BOOL, bool>, 32>(client_timeout_defined_, out);
  }
  return out;
}

size_t LWSleepRequestPB::SerializedSize() const {
  size_t result = 0;
  if (has_sleep_micros()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 1>(sleep_micros_);
  }
  if (has_deferred()) {
    result += 2;
  }
  if (has_return_app_error()) {
    result += 2;
  }
  if (has_client_timeout_defined()) {
    result += 2;
  }
  cached_size_ = result;
  return result;
}

void LWSleepRequestPB::ToGoogleProtobuf(SleepRequestPB* out) const {
  if (has_sleep_micros()) {
    out->set_sleep_micros(sleep_micros_);
  } else {
    out->clear_sleep_micros();
  }
  if (has_deferred()) {
    out->set_deferred(deferred_);
  } else {
    out->clear_deferred();
  }
  if (has_return_app_error()) {
    out->set_return_app_error(return_app_error_);
  } else {
    out->clear_return_app_error();
  }
  if (has_client_timeout_defined()) {
    out->set_client_timeout_defined(client_timeout_defined_);
  } else {
    out->clear_client_timeout_defined();
  }
}

LWSleepResponsePB::LWSleepResponsePB(::yb::Arena* arena) {
}

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

void LWSleepResponsePB::AppendToDebugString(std::string* out) const {
}

void LWSleepResponsePB::Clear() {
}

void LWSleepResponsePB::CopyFrom(const LWSleepResponsePB& rhs) {
}

void LWSleepResponsePB::CopyFrom(const SleepResponsePB& rhs) {
}

Status LWSleepResponsePB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(1);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
    }
  }
}

uint8_t* LWSleepResponsePB::SerializeToArray(uint8_t* out) const {
  return out;
}

size_t LWSleepResponsePB::SerializedSize() const {
  size_t result = 0;
  cached_size_ = result;
  return result;
}

void LWSleepResponsePB::ToGoogleProtobuf(SleepResponsePB* out) const {
}

LWSendStringsRequestPB::LWSendStringsRequestPB(::yb::Arena* arena)
    : sizes_(arena) {
}

LWSendStringsRequestPB::LWSendStringsRequestPB(::yb::Arena* arena, const LWSendStringsRequestPB& rhs)
    : has_fields_(rhs.has_fields_),
      random_seed_(rhs.random_seed_),
      sizes_(rhs.sizes_.begin(), rhs.sizes_.end(), arena) {
}

void LWSendStringsRequestPB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_random_seed()) {
    ::yb::rpc::AppendFieldTitle("random_seed", ": ", &first, out);
    *out += std::to_string(random_seed());
  }
  for (const auto& entry : sizes_) {
    ::yb::rpc::AppendFieldTitle("sizes", ": ", &first, out);
    *out += std::to_string(entry);
  }
}

void LWSendStringsRequestPB::Clear() {
  clear_random_seed();
  sizes_.clear();
}

void LWSendStringsRequestPB::CopyFrom(const LWSendStringsRequestPB& rhs) {
  if (rhs.has_random_seed()) {
    random_seed_ = rhs.random_seed_;
  } else {
    clear_random_seed();
  }
  sizes_ = rhs.sizes_;
  has_fields_ = rhs.has_fields_;
}

void LWSendStringsRequestPB::CopyFrom(const SendStringsRequestPB& rhs) {
  if (rhs.has_random_seed()) {
    random_seed_ = rhs.random_seed();
    has_fields_.Set(SendStringsRequestPBFields::kRandomSeed);
  } else {
    clear_random_seed();
  }
  sizes_.assign(rhs.sizes().begin(), rhs.sizes().end());
}

Status LWSendStringsRequestPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(31);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // random_seed
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, mutable_random_seed())) {
          return ::yb::rpc::ParseFailed("random_seed");
        }
        break;
      }
      case 2: { // sizes
        if (p.first == 18) {
          int length;
          if (!input->ReadVarintSizeAsInt(&length)) {
            return ::yb::rpc::ParseFailed("sizes");
          }
          auto old_limit = input->PushLimit(length);
          while (input->BytesUntilLimit() > 0) {
            sizes_.emplace_back();
            if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>::Read(input, &sizes_.back())) {
              return ::yb::rpc::ParseFailed("sizes");
            }
          }

          input->PopLimit(old_limit);
        } else {
          sizes_.emplace_back();
          if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>::Read(input, &sizes_.back())) {
            return ::yb::rpc::ParseFailed("sizes");
          }
        }
        break;
      }
    }
  }
}

uint8_t* LWSendStringsRequestPB::SerializeToArray(uint8_t* out) const {
  if (has_random_seed()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 8>(random_seed_, out);
  }
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 16>(sizes_, out);
  return out;
}

size_t LWSendStringsRequestPB::SerializedSize() const {
  size_t result = 0;
  if (has_random_seed()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 1>(random_seed_);
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 1>(sizes_);
  }
  cached_size_ = result;
  return result;
}

void LWSendStringsRequestPB::ToGoogleProtobuf(SendStringsRequestPB* out) const {
  if (has_random_seed()) {
    out->set_random_seed(random_seed_);
  } else {
    out->clear_random_seed();
  }
  {
    auto& repeated = *out->mutable_sizes();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(sizes_.size()));
    for (const auto& entry : sizes_) {
      repeated.Add(entry);
    }
  }
}

LWSendStringsResponsePB::LWSendStringsResponsePB(::yb::Arena* arena)
    : sidecars_(arena) {
}

LWSendStringsResponsePB::LWSendStringsResponsePB(::yb::Arena* arena, const LWSendStringsResponsePB& rhs)
    : sidecars_(rhs.sidecars_.begin(), rhs.sidecars_.end(), arena) {
}

void LWSendStringsResponsePB::AppendToDebugString(std::string* out) const {
  bool first = true;for (const auto& entry : sidecars_) {
    ::yb::rpc::AppendFieldTitle("sidecars", ": ", &first, out);
    *out += std::to_string(entry);
  }
}

void LWSendStringsResponsePB::Clear() {
  sidecars_.clear();
}

void LWSendStringsResponsePB::CopyFrom(const LWSendStringsResponsePB& rhs) {
  sidecars_ = rhs.sidecars_;
}

void LWSendStringsResponsePB::CopyFrom(const SendStringsResponsePB& rhs) {
  sidecars_.assign(rhs.sidecars().begin(), rhs.sidecars().end());
}

Status LWSendStringsResponsePB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(15);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // sidecars
        if (p.first == 10) {
          int length;
          if (!input->ReadVarintSizeAsInt(&length)) {
            return ::yb::rpc::ParseFailed("sidecars");
          }
          auto old_limit = input->PushLimit(length);
          while (input->BytesUntilLimit() > 0) {
            sidecars_.emplace_back();
            if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, &sidecars_.back())) {
              return ::yb::rpc::ParseFailed("sidecars");
            }
          }

          input->PopLimit(old_limit);
        } else {
          sidecars_.emplace_back();
          if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, &sidecars_.back())) {
            return ::yb::rpc::ParseFailed("sidecars");
          }
        }
        break;
      }
    }
  }
}

uint8_t* LWSendStringsResponsePB::SerializeToArray(uint8_t* out) const {
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 8>(sidecars_, out);
  return out;
}

size_t LWSendStringsResponsePB::SerializedSize() const {
  size_t result = 0;
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 1>(sidecars_);
  }
  cached_size_ = result;
  return result;
}

void LWSendStringsResponsePB::ToGoogleProtobuf(SendStringsResponsePB* out) const {
  {
    auto& repeated = *out->mutable_sidecars();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(sidecars_.size()));
    for (const auto& entry : sidecars_) {
      repeated.Add(entry);
    }
  }
}

LWEchoRequestPB::LWEchoRequestPB(::yb::Arena* arena)
    : arena_(*arena) {
}

LWEchoRequestPB::LWEchoRequestPB(::yb::Arena* arena, const LWEchoRequestPB& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      data_(arena->DupSlice(rhs.data_)) {
}

void LWEchoRequestPB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_data()) {
    ::yb::rpc::AppendFieldTitle("data", ": \"", &first, out);
    *out += data().ToBuffer();
    *out += '"';
  }
}

void LWEchoRequestPB::Clear() {
  clear_data();
}

void LWEchoRequestPB::CopyFrom(const LWEchoRequestPB& rhs) {
  if (rhs.has_data()) {
    data_ = arena_.DupSlice(rhs.data_);
  } else {
    clear_data();
  }
  has_fields_ = rhs.has_fields_;
}

void LWEchoRequestPB::CopyFrom(const EchoRequestPB& rhs) {
  if (rhs.has_data()) {
    data_ = arena_.DupSlice(rhs.data());
    has_fields_.Set(EchoRequestPBFields::kData);
  } else {
    clear_data();
  }
}

Status LWEchoRequestPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(15);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // data
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_data())) {
          return ::yb::rpc::ParseFailed("data");
        }
        break;
      }
    }
  }
}

uint8_t* LWEchoRequestPB::SerializeToArray(uint8_t* out) const {
  if (has_data()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 10>(data_, out);
  }
  return out;
}

size_t LWEchoRequestPB::SerializedSize() const {
  size_t result = 0;
  if (has_data()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(data_);
  }
  cached_size_ = result;
  return result;
}

void LWEchoRequestPB::ToGoogleProtobuf(EchoRequestPB* out) const {
  if (has_data()) {
    out->set_data(data_.cdata(), data_.size());
  } else {
    out->clear_data();
  }
}

LWEchoResponsePB::LWEchoResponsePB(::yb::Arena* arena)
    : arena_(*arena) {
}

LWEchoResponsePB::LWEchoResponsePB(::yb::Arena* arena, const LWEchoResponsePB& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      data_(arena->DupSlice(rhs.data_)) {
}

void LWEchoResponsePB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_data()) {
    ::yb::rpc::AppendFieldTitle("data", ": \"", &first, out);
    *out += data().ToBuffer();
    *out += '"';
  }
}

void LWEchoResponsePB::Clear() {
  clear_data();
}

void LWEchoResponsePB::CopyFrom(const LWEchoResponsePB& rhs) {
  if (rhs.has_data()) {
    data_ = arena_.DupSlice(rhs.data_);
  } else {
    clear_data();
  }
  has_fields_ = rhs.has_fields_;
}

void LWEchoResponsePB::CopyFrom(const EchoResponsePB& rhs) {
  if (rhs.has_data()) {
    data_ = arena_.DupSlice(rhs.data());
    has_fields_.Set(EchoResponsePBFields::kData);
  } else {
    clear_data();
  }
}

Status LWEchoResponsePB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(15);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // data
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_data())) {
          return ::yb::rpc::ParseFailed("data");
        }
        break;
      }
    }
  }
}

uint8_t* LWEchoResponsePB::SerializeToArray(uint8_t* out) const {
  if (has_data()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 10>(data_, out);
  }
  return out;
}

size_t LWEchoResponsePB::SerializedSize() const {
  size_t result = 0;
  if (has_data()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(data_);
  }
  cached_size_ = result;
  return result;
}

void LWEchoResponsePB::ToGoogleProtobuf(EchoResponsePB* out) const {
  if (has_data()) {
    out->set_data(data_.cdata(), data_.size());
  } else {
    out->clear_data();
  }
}

LWWhoAmIRequestPB::LWWhoAmIRequestPB(::yb::Arena* arena) {
}

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

void LWWhoAmIRequestPB::AppendToDebugString(std::string* out) const {
}

void LWWhoAmIRequestPB::Clear() {
}

void LWWhoAmIRequestPB::CopyFrom(const LWWhoAmIRequestPB& rhs) {
}

void LWWhoAmIRequestPB::CopyFrom(const WhoAmIRequestPB& rhs) {
}

Status LWWhoAmIRequestPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(1);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
    }
  }
}

uint8_t* LWWhoAmIRequestPB::SerializeToArray(uint8_t* out) const {
  return out;
}

size_t LWWhoAmIRequestPB::SerializedSize() const {
  size_t result = 0;
  cached_size_ = result;
  return result;
}

void LWWhoAmIRequestPB::ToGoogleProtobuf(WhoAmIRequestPB* out) const {
}

LWWhoAmIResponsePB::LWWhoAmIResponsePB(::yb::Arena* arena)
    : arena_(*arena) {
}

LWWhoAmIResponsePB::LWWhoAmIResponsePB(::yb::Arena* arena, const LWWhoAmIResponsePB& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      address_(arena->DupSlice(rhs.address_)) {
}

void LWWhoAmIResponsePB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_address()) {
    ::yb::rpc::AppendFieldTitle("address", ": \"", &first, out);
    *out += address().ToBuffer();
    *out += '"';
  }
}

void LWWhoAmIResponsePB::Clear() {
  clear_address();
}

void LWWhoAmIResponsePB::CopyFrom(const LWWhoAmIResponsePB& rhs) {
  if (rhs.has_address()) {
    address_ = arena_.DupSlice(rhs.address_);
  } else {
    clear_address();
  }
  has_fields_ = rhs.has_fields_;
}

void LWWhoAmIResponsePB::CopyFrom(const WhoAmIResponsePB& rhs) {
  if (rhs.has_address()) {
    address_ = arena_.DupSlice(rhs.address());
    has_fields_.Set(WhoAmIResponsePBFields::kAddress);
  } else {
    clear_address();
  }
}

Status LWWhoAmIResponsePB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(31);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 2: { // address
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_address())) {
          return ::yb::rpc::ParseFailed("address");
        }
        break;
      }
    }
  }
}

uint8_t* LWWhoAmIResponsePB::SerializeToArray(uint8_t* out) const {
  if (has_address()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 18>(address_, out);
  }
  return out;
}

size_t LWWhoAmIResponsePB::SerializedSize() const {
  size_t result = 0;
  if (has_address()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(address_);
  }
  cached_size_ = result;
  return result;
}

void LWWhoAmIResponsePB::ToGoogleProtobuf(WhoAmIResponsePB* out) const {
  if (has_address()) {
    out->set_address(address_.cdata(), address_.size());
  } else {
    out->clear_address();
  }
}

LWCalculatorError::LWCalculatorError(::yb::Arena* arena)
    : arena_(*arena) {
}

LWCalculatorError::LWCalculatorError(::yb::Arena* arena, const LWCalculatorError& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      extra_error_data_(arena->DupSlice(rhs.extra_error_data_)) {
}

void LWCalculatorError::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_extra_error_data()) {
    ::yb::rpc::AppendFieldTitle("extra_error_data", ": \"", &first, out);
    *out += extra_error_data().ToBuffer();
    *out += '"';
  }
}

void LWCalculatorError::Clear() {
  clear_extra_error_data();
}

void LWCalculatorError::CopyFrom(const LWCalculatorError& rhs) {
  if (rhs.has_extra_error_data()) {
    extra_error_data_ = arena_.DupSlice(rhs.extra_error_data_);
  } else {
    clear_extra_error_data();
  }
  has_fields_ = rhs.has_fields_;
}

void LWCalculatorError::CopyFrom(const CalculatorError& rhs) {
  if (rhs.has_extra_error_data()) {
    extra_error_data_ = arena_.DupSlice(rhs.extra_error_data());
    has_fields_.Set(CalculatorErrorFields::kExtraErrorData);
  } else {
    clear_extra_error_data();
  }
}

Status LWCalculatorError::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(15);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // extra_error_data
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_extra_error_data())) {
          return ::yb::rpc::ParseFailed("extra_error_data");
        }
        break;
      }
    }
  }
}

uint8_t* LWCalculatorError::SerializeToArray(uint8_t* out) const {
  if (has_extra_error_data()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 10>(extra_error_data_, out);
  }
  return out;
}

size_t LWCalculatorError::SerializedSize() const {
  size_t result = 0;
  if (has_extra_error_data()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(extra_error_data_);
  }
  cached_size_ = result;
  return result;
}

void LWCalculatorError::ToGoogleProtobuf(CalculatorError* out) const {
  if (has_extra_error_data()) {
    out->set_extra_error_data(extra_error_data_.cdata(), extra_error_data_.size());
  } else {
    out->clear_extra_error_data();
  }
}

LWPanicRequestPB::LWPanicRequestPB(::yb::Arena* arena) {
}

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

void LWPanicRequestPB::AppendToDebugString(std::string* out) const {
}

void LWPanicRequestPB::Clear() {
}

void LWPanicRequestPB::CopyFrom(const LWPanicRequestPB& rhs) {
}

void LWPanicRequestPB::CopyFrom(const PanicRequestPB& rhs) {
}

Status LWPanicRequestPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(1);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
    }
  }
}

uint8_t* LWPanicRequestPB::SerializeToArray(uint8_t* out) const {
  return out;
}

size_t LWPanicRequestPB::SerializedSize() const {
  size_t result = 0;
  cached_size_ = result;
  return result;
}

void LWPanicRequestPB::ToGoogleProtobuf(PanicRequestPB* out) const {
}

LWPanicResponsePB::LWPanicResponsePB(::yb::Arena* arena) {
}

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

void LWPanicResponsePB::AppendToDebugString(std::string* out) const {
}

void LWPanicResponsePB::Clear() {
}

void LWPanicResponsePB::CopyFrom(const LWPanicResponsePB& rhs) {
}

void LWPanicResponsePB::CopyFrom(const PanicResponsePB& rhs) {
}

Status LWPanicResponsePB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(1);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
    }
  }
}

uint8_t* LWPanicResponsePB::SerializeToArray(uint8_t* out) const {
  return out;
}

size_t LWPanicResponsePB::SerializedSize() const {
  size_t result = 0;
  cached_size_ = result;
  return result;
}

void LWPanicResponsePB::ToGoogleProtobuf(PanicResponsePB* out) const {
}

LWPingRequestPB::LWPingRequestPB(::yb::Arena* arena) {
}

LWPingRequestPB::LWPingRequestPB(::yb::Arena* arena, const LWPingRequestPB& rhs)
    : has_fields_(rhs.has_fields_),
      id_(rhs.id_) {
}

void LWPingRequestPB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_id()) {
    ::yb::rpc::AppendFieldTitle("id", ": ", &first, out);
    *out += std::to_string(id());
  }
}

void LWPingRequestPB::Clear() {
  clear_id();
}

void LWPingRequestPB::CopyFrom(const LWPingRequestPB& rhs) {
  if (rhs.has_id()) {
    id_ = rhs.id_;
  } else {
    clear_id();
  }
  has_fields_ = rhs.has_fields_;
}

void LWPingRequestPB::CopyFrom(const PingRequestPB& rhs) {
  if (rhs.has_id()) {
    id_ = rhs.id();
    has_fields_.Set(PingRequestPBFields::kId);
  } else {
    clear_id();
  }
}

Status LWPingRequestPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(15);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // id
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>::Read(input, mutable_id())) {
          return ::yb::rpc::ParseFailed("id");
        }
        break;
      }
    }
  }
}

uint8_t* LWPingRequestPB::SerializeToArray(uint8_t* out) const {
  if (has_id()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 8>(id_, out);
  }
  return out;
}

size_t LWPingRequestPB::SerializedSize() const {
  size_t result = 0;
  if (has_id()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 1>(id_);
  }
  cached_size_ = result;
  return result;
}

void LWPingRequestPB::ToGoogleProtobuf(PingRequestPB* out) const {
  if (has_id()) {
    out->set_id(id_);
  } else {
    out->clear_id();
  }
}

LWPingResponsePB::LWPingResponsePB(::yb::Arena* arena) {
}

LWPingResponsePB::LWPingResponsePB(::yb::Arena* arena, const LWPingResponsePB& rhs)
    : has_fields_(rhs.has_fields_),
      time_(rhs.time_) {
}

void LWPingResponsePB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_time()) {
    ::yb::rpc::AppendFieldTitle("time", ": ", &first, out);
    *out += std::to_string(time());
  }
}

void LWPingResponsePB::Clear() {
  clear_time();
}

void LWPingResponsePB::CopyFrom(const LWPingResponsePB& rhs) {
  if (rhs.has_time()) {
    time_ = rhs.time_;
  } else {
    clear_time();
  }
  has_fields_ = rhs.has_fields_;
}

void LWPingResponsePB::CopyFrom(const PingResponsePB& rhs) {
  if (rhs.has_time()) {
    time_ = rhs.time();
    has_fields_.Set(PingResponsePBFields::kTime);
  } else {
    clear_time();
  }
}

Status LWPingResponsePB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(15);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // time
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>::Read(input, mutable_time())) {
          return ::yb::rpc::ParseFailed("time");
        }
        break;
      }
    }
  }
}

uint8_t* LWPingResponsePB::SerializeToArray(uint8_t* out) const {
  if (has_time()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 8>(time_, out);
  }
  return out;
}

size_t LWPingResponsePB::SerializedSize() const {
  size_t result = 0;
  if (has_time()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 1>(time_);
  }
  cached_size_ = result;
  return result;
}

void LWPingResponsePB::ToGoogleProtobuf(PingResponsePB* out) const {
  if (has_time()) {
    out->set_time(time_);
  } else {
    out->clear_time();
  }
}

LWDisconnectRequestPB::LWDisconnectRequestPB(::yb::Arena* arena) {
}

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

void LWDisconnectRequestPB::AppendToDebugString(std::string* out) const {
}

void LWDisconnectRequestPB::Clear() {
}

void LWDisconnectRequestPB::CopyFrom(const LWDisconnectRequestPB& rhs) {
}

void LWDisconnectRequestPB::CopyFrom(const DisconnectRequestPB& rhs) {
}

Status LWDisconnectRequestPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(1);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
    }
  }
}

uint8_t* LWDisconnectRequestPB::SerializeToArray(uint8_t* out) const {
  return out;
}

size_t LWDisconnectRequestPB::SerializedSize() const {
  size_t result = 0;
  cached_size_ = result;
  return result;
}

void LWDisconnectRequestPB::ToGoogleProtobuf(DisconnectRequestPB* out) const {
}

LWDisconnectResponsePB::LWDisconnectResponsePB(::yb::Arena* arena) {
}

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

void LWDisconnectResponsePB::AppendToDebugString(std::string* out) const {
}

void LWDisconnectResponsePB::Clear() {
}

void LWDisconnectResponsePB::CopyFrom(const LWDisconnectResponsePB& rhs) {
}

void LWDisconnectResponsePB::CopyFrom(const DisconnectResponsePB& rhs) {
}

Status LWDisconnectResponsePB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(1);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
    }
  }
}

uint8_t* LWDisconnectResponsePB::SerializeToArray(uint8_t* out) const {
  return out;
}

size_t LWDisconnectResponsePB::SerializedSize() const {
  size_t result = 0;
  cached_size_ = result;
  return result;
}

void LWDisconnectResponsePB::ToGoogleProtobuf(DisconnectResponsePB* out) const {
}

LWForwardRequestPB::LWForwardRequestPB(::yb::Arena* arena)
    : arena_(*arena) {
}

LWForwardRequestPB::LWForwardRequestPB(::yb::Arena* arena, const LWForwardRequestPB& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      host_(arena->DupSlice(rhs.host_)),
      port_(rhs.port_) {
}

void LWForwardRequestPB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_host()) {
    ::yb::rpc::AppendFieldTitle("host", ": \"", &first, out);
    *out += host().ToBuffer();
    *out += '"';
  }
  if (has_port()) {
    ::yb::rpc::AppendFieldTitle("port", ": ", &first, out);
    *out += std::to_string(port());
  }
}

void LWForwardRequestPB::Clear() {
  clear_host();
  clear_port();
}

void LWForwardRequestPB::CopyFrom(const LWForwardRequestPB& rhs) {
  if (rhs.has_host()) {
    host_ = arena_.DupSlice(rhs.host_);
  } else {
    clear_host();
  }
  if (rhs.has_port()) {
    port_ = rhs.port_;
  } else {
    clear_port();
  }
  has_fields_ = rhs.has_fields_;
}

void LWForwardRequestPB::CopyFrom(const ForwardRequestPB& rhs) {
  if (rhs.has_host()) {
    host_ = arena_.DupSlice(rhs.host());
    has_fields_.Set(ForwardRequestPBFields::kHost);
  } else {
    clear_host();
  }
  if (rhs.has_port()) {
    port_ = rhs.port();
    has_fields_.Set(ForwardRequestPBFields::kPort);
  } else {
    clear_port();
  }
}

Status LWForwardRequestPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(31);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // host
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_host())) {
          return ::yb::rpc::ParseFailed("host");
        }
        break;
      }
      case 2: { // port
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, mutable_port())) {
          return ::yb::rpc::ParseFailed("port");
        }
        break;
      }
    }
  }
}

uint8_t* LWForwardRequestPB::SerializeToArray(uint8_t* out) const {
  if (has_host()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 10>(host_, out);
  }
  if (has_port()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 16>(port_, out);
  }
  return out;
}

size_t LWForwardRequestPB::SerializedSize() const {
  size_t result = 0;
  if (has_host()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(host_);
  }
  if (has_port()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 1>(port_);
  }
  cached_size_ = result;
  return result;
}

void LWForwardRequestPB::ToGoogleProtobuf(ForwardRequestPB* out) const {
  if (has_host()) {
    out->set_host(host_.cdata(), host_.size());
  } else {
    out->clear_host();
  }
  if (has_port()) {
    out->set_port(port_);
  } else {
    out->clear_port();
  }
}

LWForwardResponsePB::LWForwardResponsePB(::yb::Arena* arena)
    : arena_(*arena) {
}

LWForwardResponsePB::LWForwardResponsePB(::yb::Arena* arena, const LWForwardResponsePB& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      name_(arena->DupSlice(rhs.name_)) {
}

void LWForwardResponsePB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_name()) {
    ::yb::rpc::AppendFieldTitle("name", ": \"", &first, out);
    *out += name().ToBuffer();
    *out += '"';
  }
}

void LWForwardResponsePB::Clear() {
  clear_name();
}

void LWForwardResponsePB::CopyFrom(const LWForwardResponsePB& rhs) {
  if (rhs.has_name()) {
    name_ = arena_.DupSlice(rhs.name_);
  } else {
    clear_name();
  }
  has_fields_ = rhs.has_fields_;
}

void LWForwardResponsePB::CopyFrom(const ForwardResponsePB& rhs) {
  if (rhs.has_name()) {
    name_ = arena_.DupSlice(rhs.name());
    has_fields_.Set(ForwardResponsePBFields::kName);
  } else {
    clear_name();
  }
}

Status LWForwardResponsePB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(15);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // name
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_name())) {
          return ::yb::rpc::ParseFailed("name");
        }
        break;
      }
    }
  }
}

uint8_t* LWForwardResponsePB::SerializeToArray(uint8_t* out) const {
  if (has_name()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 10>(name_, out);
  }
  return out;
}

size_t LWForwardResponsePB::SerializedSize() const {
  size_t result = 0;
  if (has_name()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(name_);
  }
  cached_size_ = result;
  return result;
}

void LWForwardResponsePB::ToGoogleProtobuf(ForwardResponsePB* out) const {
  if (has_name()) {
    out->set_name(name_.cdata(), name_.size());
  } else {
    out->clear_name();
  }
}

LWConcatRequestPB::LWConcatRequestPB(::yb::Arena* arena)
    : arena_(*arena) {
}

LWConcatRequestPB::LWConcatRequestPB(::yb::Arena* arena, const LWConcatRequestPB& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      lhs_(arena->DupSlice(rhs.lhs_)),
      rhs_(arena->DupSlice(rhs.rhs_)) {
}

void LWConcatRequestPB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_lhs()) {
    ::yb::rpc::AppendFieldTitle("lhs", ": \"", &first, out);
    *out += lhs().ToBuffer();
    *out += '"';
  }
  if (has_rhs()) {
    ::yb::rpc::AppendFieldTitle("rhs", ": \"", &first, out);
    *out += rhs().ToBuffer();
    *out += '"';
  }
}

void LWConcatRequestPB::Clear() {
  clear_lhs();
  clear_rhs();
}

void LWConcatRequestPB::CopyFrom(const LWConcatRequestPB& rhs) {
  if (rhs.has_lhs()) {
    lhs_ = arena_.DupSlice(rhs.lhs_);
  } else {
    clear_lhs();
  }
  if (rhs.has_rhs()) {
    rhs_ = arena_.DupSlice(rhs.rhs_);
  } else {
    clear_rhs();
  }
  has_fields_ = rhs.has_fields_;
}

void LWConcatRequestPB::CopyFrom(const ConcatRequestPB& rhs) {
  if (rhs.has_lhs()) {
    lhs_ = arena_.DupSlice(rhs.lhs());
    has_fields_.Set(ConcatRequestPBFields::kLhs);
  } else {
    clear_lhs();
  }
  if (rhs.has_rhs()) {
    rhs_ = arena_.DupSlice(rhs.rhs());
    has_fields_.Set(ConcatRequestPBFields::kRhs);
  } else {
    clear_rhs();
  }
}

Status LWConcatRequestPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(31);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // lhs
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_lhs())) {
          return ::yb::rpc::ParseFailed("lhs");
        }
        break;
      }
      case 2: { // rhs
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_rhs())) {
          return ::yb::rpc::ParseFailed("rhs");
        }
        break;
      }
    }
  }
}

uint8_t* LWConcatRequestPB::SerializeToArray(uint8_t* out) const {
  if (has_lhs()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 10>(lhs_, out);
  }
  if (has_rhs()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 18>(rhs_, out);
  }
  return out;
}

size_t LWConcatRequestPB::SerializedSize() const {
  size_t result = 0;
  if (has_lhs()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(lhs_);
  }
  if (has_rhs()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(rhs_);
  }
  cached_size_ = result;
  return result;
}

void LWConcatRequestPB::ToGoogleProtobuf(ConcatRequestPB* out) const {
  if (has_lhs()) {
    out->set_lhs(lhs_.cdata(), lhs_.size());
  } else {
    out->clear_lhs();
  }
  if (has_rhs()) {
    out->set_rhs(rhs_.cdata(), rhs_.size());
  } else {
    out->clear_rhs();
  }
}

LWConcatResponsePB::LWConcatResponsePB(::yb::Arena* arena)
    : arena_(*arena) {
}

LWConcatResponsePB::LWConcatResponsePB(::yb::Arena* arena, const LWConcatResponsePB& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      result_(arena->DupSlice(rhs.result_)) {
}

void LWConcatResponsePB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_result()) {
    ::yb::rpc::AppendFieldTitle("result", ": \"", &first, out);
    *out += result().ToBuffer();
    *out += '"';
  }
}

void LWConcatResponsePB::Clear() {
  clear_result();
}

void LWConcatResponsePB::CopyFrom(const LWConcatResponsePB& rhs) {
  if (rhs.has_result()) {
    result_ = arena_.DupSlice(rhs.result_);
  } else {
    clear_result();
  }
  has_fields_ = rhs.has_fields_;
}

void LWConcatResponsePB::CopyFrom(const ConcatResponsePB& rhs) {
  if (rhs.has_result()) {
    result_ = arena_.DupSlice(rhs.result());
    has_fields_.Set(ConcatResponsePBFields::kResult);
  } else {
    clear_result();
  }
}

Status LWConcatResponsePB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(15);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // result
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_result())) {
          return ::yb::rpc::ParseFailed("result");
        }
        break;
      }
    }
  }
}

uint8_t* LWConcatResponsePB::SerializeToArray(uint8_t* out) const {
  if (has_result()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 10>(result_, out);
  }
  return out;
}

size_t LWConcatResponsePB::SerializedSize() const {
  size_t result = 0;
  if (has_result()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(result_);
  }
  cached_size_ = result;
  return result;
}

void LWConcatResponsePB::ToGoogleProtobuf(ConcatResponsePB* out) const {
  if (has_result()) {
    out->set_result(result_.cdata(), result_.size());
  } else {
    out->clear_result();
  }
}

LWLightweightSubMessagePB::LWLightweightSubMessagePB(::yb::Arena* arena)
    : arena_(*arena),
      rsi32_(arena),
      rbytes_(arena) {
}

LWLightweightSubMessagePB::LWLightweightSubMessagePB(::yb::Arena* arena, const LWLightweightSubMessagePB& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      sf32_(rhs.sf32_),
      rsi32_(rhs.rsi32_.begin(), rhs.rsi32_.end(), arena),
      str_(arena->DupSlice(rhs.str_)),
      rbytes_(arena),
      cycle_(rhs.cycle_ ? arena->NewObject<::yb::rpc_test::LWLightweightSubMessagePB>(arena, *rhs.cycle_) : nullptr) {
  rbytes_.reserve(rhs.rbytes_.size());
  for (const auto& entry : rhs.rbytes_) {
    rbytes_.push_back(arena->DupSlice(entry));
  }
}

void LWLightweightSubMessagePB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_sf32()) {
    ::yb::rpc::AppendFieldTitle("sf32", ": ", &first, out);
    *out += std::to_string(sf32());
  }
  for (const auto& entry : rsi32_) {
    ::yb::rpc::AppendFieldTitle("rsi32", ": ", &first, out);
    *out += std::to_string(entry);
  }
  if (has_str()) {
    ::yb::rpc::AppendFieldTitle("str", ": \"", &first, out);
    *out += str().ToBuffer();
    *out += '"';
  }
  for (const auto& entry : rbytes_) {
    ::yb::rpc::AppendFieldTitle("rbytes", ": \"", &first, out);
    *out += entry.ToBuffer();
    *out += '"';
  }
  if (has_cycle()) {
    ::yb::rpc::AppendFieldTitle("cycle", " { ", &first, out);
    cycle().AppendToDebugString(out);
    *out += " }";
  }
}

void LWLightweightSubMessagePB::Clear() {
  clear_sf32();
  rsi32_.clear();
  clear_str();
  rbytes_.clear();
  clear_cycle();
}

void LWLightweightSubMessagePB::CopyFrom(const LWLightweightSubMessagePB& rhs) {
  if (rhs.has_sf32()) {
    sf32_ = rhs.sf32_;
  } else {
    clear_sf32();
  }
  rsi32_ = rhs.rsi32_;
  if (rhs.has_str()) {
    str_ = arena_.DupSlice(rhs.str_);
  } else {
    clear_str();
  }
  rbytes_.reserve(rhs.rbytes_.size());
  for (const auto& entry : rhs.rbytes_) {
    rbytes_.push_back(arena_.DupSlice(entry));
  }
  if (rhs.cycle_) {
    mutable_cycle()->CopyFrom(*rhs.cycle_);
  } else {
    clear_cycle();
  }
  has_fields_ = rhs.has_fields_;
}

void LWLightweightSubMessagePB::CopyFrom(const LightweightSubMessagePB& rhs) {
  if (rhs.has_sf32()) {
    sf32_ = rhs.sf32();
    has_fields_.Set(LightweightSubMessagePBFields::kSf32);
  } else {
    clear_sf32();
  }
  rsi32_.assign(rhs.rsi32().begin(), rhs.rsi32().end());
  if (rhs.has_str()) {
    str_ = arena_.DupSlice(rhs.str());
    has_fields_.Set(LightweightSubMessagePBFields::kStr);
  } else {
    clear_str();
  }
  rbytes_.reserve(rhs.rbytes().size());
  for (const auto& entry : rhs.rbytes()) {
    rbytes_.push_back(arena_.DupSlice(entry));
  }
  if (rhs.has_cycle()) {
    mutable_cycle()->CopyFrom(rhs.cycle());
  } else {
    clear_cycle();
  }
}

Status LWLightweightSubMessagePB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(63);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // sf32
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SFIXED32, int32_t>::Read(input, mutable_sf32())) {
          return ::yb::rpc::ParseFailed("sf32");
        }
        break;
      }
      case 2: { // rsi32
        if (p.first == 18) {
          int length;
          if (!input->ReadVarintSizeAsInt(&length)) {
            return ::yb::rpc::ParseFailed("rsi32");
          }
          auto old_limit = input->PushLimit(length);
          while (input->BytesUntilLimit() > 0) {
            rsi32_.emplace_back();
            if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT32, int32_t>::Read(input, &rsi32_.back())) {
              return ::yb::rpc::ParseFailed("rsi32");
            }
          }

          input->PopLimit(old_limit);
        } else {
          rsi32_.emplace_back();
          if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT32, int32_t>::Read(input, &rsi32_.back())) {
            return ::yb::rpc::ParseFailed("rsi32");
          }
        }
        break;
      }
      case 3: { // str
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_str())) {
          return ::yb::rpc::ParseFailed("str");
        }
        break;
      }
      case 4: { // rbytes
        rbytes_.emplace_back();
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BYTES, ::yb::Slice>::Read(input, &rbytes_.back())) {
          return ::yb::rpc::ParseFailed("rbytes");
        }
        break;
      }
      case 5: { // cycle
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>::Read(input, mutable_cycle())) {
          return ::yb::rpc::ParseFailed("cycle");
        }
        break;
      }
    }
  }
}

uint8_t* LWLightweightSubMessagePB::SerializeToArray(uint8_t* out) const {
  if (has_sf32()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SFIXED32, int32_t>, 13>(sf32_, out);
  }
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT32, int32_t>, 16>(rsi32_, out);
  if (has_str()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 26>(str_, out);
  }
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BYTES, ::yb::Slice>, 34>(rbytes_, out);
  if (has_cycle()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 42>(*cycle_, out);
  }
  return out;
}

size_t LWLightweightSubMessagePB::SerializedSize() const {
  size_t result = 0;
  if (has_sf32()) {
    result += 5;
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT32, int32_t>, 1>(rsi32_);
  }
  if (has_str()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(str_);
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BYTES, ::yb::Slice>, 1>(rbytes_);
  }
  if (has_cycle()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 1>(*cycle_);
  }
  cached_size_ = result;
  return result;
}

void LWLightweightSubMessagePB::ToGoogleProtobuf(LightweightSubMessagePB* out) const {
  if (has_sf32()) {
    out->set_sf32(sf32_);
  } else {
    out->clear_sf32();
  }
  {
    auto& repeated = *out->mutable_rsi32();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(rsi32_.size()));
    for (const auto& entry : rsi32_) {
      repeated.Add(entry);
    }
  }
  if (has_str()) {
    out->set_str(str_.cdata(), str_.size());
  } else {
    out->clear_str();
  }
  {
    auto& repeated = *out->mutable_rbytes();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(rbytes_.size()));
    for (const auto& entry : rbytes_) {
      repeated.Add()->assign(entry.cdata(), entry.size());
    }
  }
  if (has_cycle()) {
    cycle().ToGoogleProtobuf(out->mutable_cycle());
  }
}

LWLightweightPairPB::LWLightweightPairPB(::yb::Arena* arena)
    : arena_(*arena) {
}

LWLightweightPairPB::LWLightweightPairPB(::yb::Arena* arena, const LWLightweightPairPB& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      s1_(arena->DupSlice(rhs.s1_)),
      s2_(arena->DupSlice(rhs.s2_)) {
}

void LWLightweightPairPB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_s1()) {
    ::yb::rpc::AppendFieldTitle("s1", ": \"", &first, out);
    *out += s1().ToBuffer();
    *out += '"';
  }
  if (has_s2()) {
    ::yb::rpc::AppendFieldTitle("s2", ": \"", &first, out);
    *out += s2().ToBuffer();
    *out += '"';
  }
}

void LWLightweightPairPB::Clear() {
  clear_s1();
  clear_s2();
}

void LWLightweightPairPB::CopyFrom(const LWLightweightPairPB& rhs) {
  if (rhs.has_s1()) {
    s1_ = arena_.DupSlice(rhs.s1_);
  } else {
    clear_s1();
  }
  if (rhs.has_s2()) {
    s2_ = arena_.DupSlice(rhs.s2_);
  } else {
    clear_s2();
  }
  has_fields_ = rhs.has_fields_;
}

void LWLightweightPairPB::CopyFrom(const LightweightPairPB& rhs) {
  if (rhs.has_s1()) {
    s1_ = arena_.DupSlice(rhs.s1());
    has_fields_.Set(LightweightPairPBFields::kS1);
  } else {
    clear_s1();
  }
  if (rhs.has_s2()) {
    s2_ = arena_.DupSlice(rhs.s2());
    has_fields_.Set(LightweightPairPBFields::kS2);
  } else {
    clear_s2();
  }
}

Status LWLightweightPairPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(31);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // s1
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_s1())) {
          return ::yb::rpc::ParseFailed("s1");
        }
        break;
      }
      case 2: { // s2
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_s2())) {
          return ::yb::rpc::ParseFailed("s2");
        }
        break;
      }
    }
  }
}

uint8_t* LWLightweightPairPB::SerializeToArray(uint8_t* out) const {
  if (has_s1()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 10>(s1_, out);
  }
  if (has_s2()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 18>(s2_, out);
  }
  return out;
}

size_t LWLightweightPairPB::SerializedSize() const {
  size_t result = 0;
  if (has_s1()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(s1_);
  }
  if (has_s2()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(s2_);
  }
  cached_size_ = result;
  return result;
}

void LWLightweightPairPB::ToGoogleProtobuf(LightweightPairPB* out) const {
  if (has_s1()) {
    out->set_s1(s1_.cdata(), s1_.size());
  } else {
    out->clear_s1();
  }
  if (has_s2()) {
    out->set_s2(s2_.cdata(), s2_.size());
  } else {
    out->clear_s2();
  }
}

LWLightweightRequestPB_LWMapEntry_DoNotUse::LWLightweightRequestPB_LWMapEntry_DoNotUse(::yb::Arena* arena)
    : arena_(*arena) {
}

LWLightweightRequestPB_LWMapEntry_DoNotUse::LWLightweightRequestPB_LWMapEntry_DoNotUse(::yb::Arena* arena, const LWLightweightRequestPB_LWMapEntry_DoNotUse& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      key_(arena->DupSlice(rhs.key_)),
      value_(rhs.value_) {
}

void LWLightweightRequestPB_LWMapEntry_DoNotUse::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_key()) {
    ::yb::rpc::AppendFieldTitle("key", ": \"", &first, out);
    *out += key().ToBuffer();
    *out += '"';
  }
  if (has_value()) {
    ::yb::rpc::AppendFieldTitle("value", ": ", &first, out);
    *out += std::to_string(value());
  }
}

void LWLightweightRequestPB_LWMapEntry_DoNotUse::Clear() {
  clear_key();
  clear_value();
}

void LWLightweightRequestPB_LWMapEntry_DoNotUse::CopyFrom(const LWLightweightRequestPB_LWMapEntry_DoNotUse& rhs) {
  {
    key_ = arena_.DupSlice(rhs.key_);
  }
  {
    value_ = rhs.value_;
  }
  has_fields_ = rhs.has_fields_;
}

void LWLightweightRequestPB_LWMapEntry_DoNotUse::CopyFrom(const ::google::protobuf::MapPair<std::string, int64_t>& rhs) {
  {
    key_ = arena_.DupSlice(rhs.first);
    has_fields_.Set(LightweightRequestPB_MapEntry_DoNotUseFields::kKey);
  }
  {
    value_ = rhs.second;
    has_fields_.Set(LightweightRequestPB_MapEntry_DoNotUseFields::kValue);
  }
}

Status LWLightweightRequestPB_LWMapEntry_DoNotUse::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(31);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // key
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_key())) {
          return ::yb::rpc::ParseFailed("key");
        }
        break;
      }
      case 2: { // value
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT64, int64_t>::Read(input, mutable_value())) {
          return ::yb::rpc::ParseFailed("value");
        }
        break;
      }
    }
  }
}

uint8_t* LWLightweightRequestPB_LWMapEntry_DoNotUse::SerializeToArray(uint8_t* out) const {
  if (has_key()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 10>(key_, out);
  }
  if (has_value()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT64, int64_t>, 16>(value_, out);
  }
  return out;
}

size_t LWLightweightRequestPB_LWMapEntry_DoNotUse::SerializedSize() const {
  size_t result = 0;
  if (has_key()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(key_);
  }
  if (has_value()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT64, int64_t>, 1>(value_);
  }
  cached_size_ = result;
  return result;
}

LWLightweightRequestPB::LWLightweightRequestPB(::yb::Arena* arena)
    : arena_(*arena),
      ru32_(arena),
      rf32_(arena),
      rstr_(arena),
      message_(arena),
      repeated_messages_(arena),
      packed_u64_(arena),
      packed_f32_(arena),
      pairs_(arena),
      map_(arena),
      extra_data_(arena) {
}

LWLightweightRequestPB::LWLightweightRequestPB(::yb::Arena* arena, const LWLightweightRequestPB& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      i32_(rhs.i32_),
      i64_(rhs.i64_),
      f32_(rhs.f32_),
      f64_(rhs.f64_),
      u32_(rhs.u32_),
      u64_(rhs.u64_),
      r32_(rhs.r32_),
      r64_(rhs.r64_),
      str_(arena->DupSlice(rhs.str_)),
      bytes_(arena->DupSlice(rhs.bytes_)),
      en_(rhs.en_),
      sf32_(rhs.sf32_),
      sf64_(rhs.sf64_),
      si32_(rhs.si32_),
      si64_(rhs.si64_),
      ru32_(rhs.ru32_.begin(), rhs.ru32_.end(), arena),
      rf32_(rhs.rf32_.begin(), rhs.rf32_.end(), arena),
      rstr_(arena),
      message_(arena, rhs.message_),
      repeated_messages_(arena, rhs.repeated_messages_),
      packed_u64_(rhs.packed_u64_.begin(), rhs.packed_u64_.end(), arena),
      packed_f32_(rhs.packed_f32_.begin(), rhs.packed_f32_.end(), arena),
      pairs_(arena, rhs.pairs_),
      ptr_message_(rhs.ptr_message_ ? arena->NewObject<::yb::rpc_test::LWLightweightSubMessagePB>(arena, *rhs.ptr_message_) : nullptr),
      map_(arena, rhs.map_),
      extra_data_(arena, rhs.extra_data_) {
  rstr_.reserve(rhs.rstr_.size());
  for (const auto& entry : rhs.rstr_) {
    rstr_.push_back(arena->DupSlice(entry));
  }
}

void LWLightweightRequestPB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_i32()) {
    ::yb::rpc::AppendFieldTitle("i32", ": ", &first, out);
    *out += std::to_string(i32());
  }
  if (has_i64()) {
    ::yb::rpc::AppendFieldTitle("i64", ": ", &first, out);
    *out += std::to_string(i64());
  }
  if (has_f32()) {
    ::yb::rpc::AppendFieldTitle("f32", ": ", &first, out);
    *out += std::to_string(f32());
  }
  if (has_f64()) {
    ::yb::rpc::AppendFieldTitle("f64", ": ", &first, out);
    *out += std::to_string(f64());
  }
  if (has_u32()) {
    ::yb::rpc::AppendFieldTitle("u32", ": ", &first, out);
    *out += std::to_string(u32());
  }
  if (has_u64()) {
    ::yb::rpc::AppendFieldTitle("u64", ": ", &first, out);
    *out += std::to_string(u64());
  }
  if (has_r32()) {
    ::yb::rpc::AppendFieldTitle("r32", ": ", &first, out);
    *out += ::SimpleFtoa(r32());
  }
  if (has_r64()) {
    ::yb::rpc::AppendFieldTitle("r64", ": ", &first, out);
    *out += ::SimpleDtoa(r64());
  }
  if (has_str()) {
    ::yb::rpc::AppendFieldTitle("str", ": \"", &first, out);
    *out += str().ToBuffer();
    *out += '"';
  }
  if (has_bytes()) {
    ::yb::rpc::AppendFieldTitle("bytes", ": \"", &first, out);
    *out += bytes().ToBuffer();
    *out += '"';
  }
  if (has_en()) {
    ::yb::rpc::AppendFieldTitle("en", ": ", &first, out);
    *out += ::yb::rpc_test::LightweightEnum_Name(en());
  }
  if (has_sf32()) {
    ::yb::rpc::AppendFieldTitle("sf32", ": ", &first, out);
    *out += std::to_string(sf32());
  }
  if (has_sf64()) {
    ::yb::rpc::AppendFieldTitle("sf64", ": ", &first, out);
    *out += std::to_string(sf64());
  }
  if (has_si32()) {
    ::yb::rpc::AppendFieldTitle("si32", ": ", &first, out);
    *out += std::to_string(si32());
  }
  if (has_si64()) {
    ::yb::rpc::AppendFieldTitle("si64", ": ", &first, out);
    *out += std::to_string(si64());
  }
  for (const auto& entry : ru32_) {
    ::yb::rpc::AppendFieldTitle("ru32", ": ", &first, out);
    *out += std::to_string(entry);
  }
  for (const auto& entry : rf32_) {
    ::yb::rpc::AppendFieldTitle("rf32", ": ", &first, out);
    *out += std::to_string(entry);
  }
  for (const auto& entry : rstr_) {
    ::yb::rpc::AppendFieldTitle("rstr", ": \"", &first, out);
    *out += entry.ToBuffer();
    *out += '"';
  }
  if (has_message()) {
    ::yb::rpc::AppendFieldTitle("message", " { ", &first, out);
    message().AppendToDebugString(out);
    *out += " }";
  }
  for (const auto& entry : repeated_messages_) {
    ::yb::rpc::AppendFieldTitle("repeated_messages", " { ", &first, out);
    entry.AppendToDebugString(out);
    *out += " }";
  }
  for (const auto& entry : packed_u64_) {
    ::yb::rpc::AppendFieldTitle("packed_u64", ": ", &first, out);
    *out += std::to_string(entry);
  }
  for (const auto& entry : packed_f32_) {
    ::yb::rpc::AppendFieldTitle("packed_f32", ": ", &first, out);
    *out += std::to_string(entry);
  }
  for (const auto& entry : pairs_) {
    ::yb::rpc::AppendFieldTitle("pairs", " { ", &first, out);
    entry.AppendToDebugString(out);
    *out += " }";
  }
  if (has_ptr_message()) {
    ::yb::rpc::AppendFieldTitle("ptr_message", " { ", &first, out);
    ptr_message().AppendToDebugString(out);
    *out += " }";
  }
  for (const auto& entry : map_) {
    ::yb::rpc::AppendFieldTitle("map", " { ", &first, out);
    entry.AppendToDebugString(out);
    *out += " }";
  }
  if (has_extra_data()) {
    ::yb::rpc::AppendFieldTitle("extra_data", " { ", &first, out);
    extra_data().AppendToDebugString(out);
    *out += " }";
  }
}

void LWLightweightRequestPB::Clear() {
  clear_i32();
  clear_i64();
  clear_f32();
  clear_f64();
  clear_u32();
  clear_u64();
  clear_r32();
  clear_r64();
  clear_str();
  clear_bytes();
  clear_en();
  clear_sf32();
  clear_sf64();
  clear_si32();
  clear_si64();
  ru32_.clear();
  rf32_.clear();
  rstr_.clear();
  clear_message();
  repeated_messages_.clear();
  packed_u64_.clear();
  packed_f32_.clear();
  pairs_.clear();
  clear_ptr_message();
  map_.clear();
  clear_extra_data();
}

void LWLightweightRequestPB::CopyFrom(const LWLightweightRequestPB& rhs) {
  if (rhs.has_i32()) {
    i32_ = rhs.i32_;
  } else {
    clear_i32();
  }
  if (rhs.has_i64()) {
    i64_ = rhs.i64_;
  } else {
    clear_i64();
  }
  if (rhs.has_f32()) {
    f32_ = rhs.f32_;
  } else {
    clear_f32();
  }
  if (rhs.has_f64()) {
    f64_ = rhs.f64_;
  } else {
    clear_f64();
  }
  if (rhs.has_u32()) {
    u32_ = rhs.u32_;
  } else {
    clear_u32();
  }
  if (rhs.has_u64()) {
    u64_ = rhs.u64_;
  } else {
    clear_u64();
  }
  if (rhs.has_r32()) {
    r32_ = rhs.r32_;
  } else {
    clear_r32();
  }
  if (rhs.has_r64()) {
    r64_ = rhs.r64_;
  } else {
    clear_r64();
  }
  if (rhs.has_str()) {
    str_ = arena_.DupSlice(rhs.str_);
  } else {
    clear_str();
  }
  if (rhs.has_bytes()) {
    bytes_ = arena_.DupSlice(rhs.bytes_);
  } else {
    clear_bytes();
  }
  if (rhs.has_en()) {
    en_ = rhs.en_;
  } else {
    clear_en();
  }
  if (rhs.has_sf32()) {
    sf32_ = rhs.sf32_;
  } else {
    clear_sf32();
  }
  if (rhs.has_sf64()) {
    sf64_ = rhs.sf64_;
  } else {
    clear_sf64();
  }
  if (rhs.has_si32()) {
    si32_ = rhs.si32_;
  } else {
    clear_si32();
  }
  if (rhs.has_si64()) {
    si64_ = rhs.si64_;
  } else {
    clear_si64();
  }
  ru32_ = rhs.ru32_;
  rf32_ = rhs.rf32_;
  rstr_.reserve(rhs.rstr_.size());
  for (const auto& entry : rhs.rstr_) {
    rstr_.push_back(arena_.DupSlice(entry));
  }
  if (rhs.has_message()) {
    message_.CopyFrom(rhs.message_);
  } else {
    clear_message();
  }
  repeated_messages_ = rhs.repeated_messages_;
  packed_u64_ = rhs.packed_u64_;
  packed_f32_ = rhs.packed_f32_;
  pairs_ = rhs.pairs_;
  if (rhs.ptr_message_) {
    mutable_ptr_message()->CopyFrom(*rhs.ptr_message_);
  } else {
    clear_ptr_message();
  }
  map_ = rhs.map_;
  if (rhs.has_extra_data()) {
    extra_data_.CopyFrom(rhs.extra_data_);
  } else {
    clear_extra_data();
  }
  has_fields_ = rhs.has_fields_;
}

void LWLightweightRequestPB::CopyFrom(const LightweightRequestPB& rhs) {
  if (rhs.has_i32()) {
    i32_ = rhs.i32();
    has_fields_.Set(LightweightRequestPBFields::kI32);
  } else {
    clear_i32();
  }
  if (rhs.has_i64()) {
    i64_ = rhs.i64();
    has_fields_.Set(LightweightRequestPBFields::kI64);
  } else {
    clear_i64();
  }
  if (rhs.has_f32()) {
    f32_ = rhs.f32();
    has_fields_.Set(LightweightRequestPBFields::kF32);
  } else {
    clear_f32();
  }
  if (rhs.has_f64()) {
    f64_ = rhs.f64();
    has_fields_.Set(LightweightRequestPBFields::kF64);
  } else {
    clear_f64();
  }
  if (rhs.has_u32()) {
    u32_ = rhs.u32();
    has_fields_.Set(LightweightRequestPBFields::kU32);
  } else {
    clear_u32();
  }
  if (rhs.has_u64()) {
    u64_ = rhs.u64();
    has_fields_.Set(LightweightRequestPBFields::kU64);
  } else {
    clear_u64();
  }
  if (rhs.has_r32()) {
    r32_ = rhs.r32();
    has_fields_.Set(LightweightRequestPBFields::kR32);
  } else {
    clear_r32();
  }
  if (rhs.has_r64()) {
    r64_ = rhs.r64();
    has_fields_.Set(LightweightRequestPBFields::kR64);
  } else {
    clear_r64();
  }
  if (rhs.has_str()) {
    str_ = arena_.DupSlice(rhs.str());
    has_fields_.Set(LightweightRequestPBFields::kStr);
  } else {
    clear_str();
  }
  if (rhs.has_bytes()) {
    bytes_ = arena_.DupSlice(rhs.bytes());
    has_fields_.Set(LightweightRequestPBFields::kBytes);
  } else {
    clear_bytes();
  }
  if (rhs.has_en()) {
    en_ = rhs.en();
    has_fields_.Set(LightweightRequestPBFields::kEn);
  } else {
    clear_en();
  }
  if (rhs.has_sf32()) {
    sf32_ = rhs.sf32();
    has_fields_.Set(LightweightRequestPBFields::kSf32);
  } else {
    clear_sf32();
  }
  if (rhs.has_sf64()) {
    sf64_ = rhs.sf64();
    has_fields_.Set(LightweightRequestPBFields::kSf64);
  } else {
    clear_sf64();
  }
  if (rhs.has_si32()) {
    si32_ = rhs.si32();
    has_fields_.Set(LightweightRequestPBFields::kSi32);
  } else {
    clear_si32();
  }
  if (rhs.has_si64()) {
    si64_ = rhs.si64();
    has_fields_.Set(LightweightRequestPBFields::kSi64);
  } else {
    clear_si64();
  }
  ru32_.assign(rhs.ru32().begin(), rhs.ru32().end());
  rf32_.assign(rhs.rf32().begin(), rhs.rf32().end());
  rstr_.reserve(rhs.rstr().size());
  for (const auto& entry : rhs.rstr()) {
    rstr_.push_back(arena_.DupSlice(entry));
  }
  if (rhs.has_message()) {
    message_.CopyFrom(rhs.message());
    has_fields_.Set(LightweightRequestPBFields::kMessage);
  } else {
    clear_message();
  }
  repeated_messages_.assign(rhs.repeated_messages().begin(), rhs.repeated_messages().end());
  packed_u64_.assign(rhs.packed_u64().begin(), rhs.packed_u64().end());
  packed_f32_.assign(rhs.packed_f32().begin(), rhs.packed_f32().end());
  pairs_.assign(rhs.pairs().begin(), rhs.pairs().end());
  if (rhs.has_ptr_message()) {
    mutable_ptr_message()->CopyFrom(rhs.ptr_message());
  } else {
    clear_ptr_message();
  }
  map_.assign(rhs.map().begin(), rhs.map().end());
  if (rhs.has_extra_data()) {
    extra_data_.CopyFrom(rhs.extra_data());
    has_fields_.Set(LightweightRequestPBFields::kExtraData);
  } else {
    clear_extra_data();
  }
}

Status LWLightweightRequestPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(255);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // i32
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>::Read(input, mutable_i32())) {
          return ::yb::rpc::ParseFailed("i32");
        }
        break;
      }
      case 2: { // i64
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT64, int64_t>::Read(input, mutable_i64())) {
          return ::yb::rpc::ParseFailed("i64");
        }
        break;
      }
      case 3: { // f32
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>::Read(input, mutable_f32())) {
          return ::yb::rpc::ParseFailed("f32");
        }
        break;
      }
      case 4: { // f64
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED64, uint64_t>::Read(input, mutable_f64())) {
          return ::yb::rpc::ParseFailed("f64");
        }
        break;
      }
      case 5: { // u32
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, mutable_u32())) {
          return ::yb::rpc::ParseFailed("u32");
        }
        break;
      }
      case 6: { // u64
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>::Read(input, mutable_u64())) {
          return ::yb::rpc::ParseFailed("u64");
        }
        break;
      }
      case 7: { // r32
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FLOAT, float>::Read(input, mutable_r32())) {
          return ::yb::rpc::ParseFailed("r32");
        }
        break;
      }
      case 8: { // r64
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE, double>::Read(input, mutable_r64())) {
          return ::yb::rpc::ParseFailed("r64");
        }
        break;
      }
      case 9: { // str
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_str())) {
          return ::yb::rpc::ParseFailed("str");
        }
        break;
      }
      case 10: { // bytes
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BYTES, ::yb::Slice>::Read(input, mutable_bytes())) {
          return ::yb::rpc::ParseFailed("bytes");
        }
        break;
      }
      case 11: { // en
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_ENUM, ::yb::rpc_test::LightweightEnum>::Read(input, mutable_en())) {
          return ::yb::rpc::ParseFailed("en");
        }
        break;
      }
      case 12: { // sf32
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SFIXED32, int32_t>::Read(input, mutable_sf32())) {
          return ::yb::rpc::ParseFailed("sf32");
        }
        break;
      }
      case 13: { // sf64
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SFIXED64, int64_t>::Read(input, mutable_sf64())) {
          return ::yb::rpc::ParseFailed("sf64");
        }
        break;
      }
      case 14: { // si32
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT32, int32_t>::Read(input, mutable_si32())) {
          return ::yb::rpc::ParseFailed("si32");
        }
        break;
      }
      case 15: { // si64
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT64, int64_t>::Read(input, mutable_si64())) {
          return ::yb::rpc::ParseFailed("si64");
        }
        break;
      }
      case 16: { // ru32
        if (p.first == 130) {
          int length;
          if (!input->ReadVarintSizeAsInt(&length)) {
            return ::yb::rpc::ParseFailed("ru32");
          }
          auto old_limit = input->PushLimit(length);
          while (input->BytesUntilLimit() > 0) {
            ru32_.emplace_back();
            if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, &ru32_.back())) {
              return ::yb::rpc::ParseFailed("ru32");
            }
          }

          input->PopLimit(old_limit);
        } else {
          ru32_.emplace_back();
          if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, &ru32_.back())) {
            return ::yb::rpc::ParseFailed("ru32");
          }
        }
        break;
      }
      case 17: { // rf32
        if (p.first == 138) {
          int length;
          if (!input->ReadVarintSizeAsInt(&length)) {
            return ::yb::rpc::ParseFailed("rf32");
          }
          auto old_limit = input->PushLimit(length);
          while (input->BytesUntilLimit() > 0) {
            rf32_.emplace_back();
            if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>::Read(input, &rf32_.back())) {
              return ::yb::rpc::ParseFailed("rf32");
            }
          }

          input->PopLimit(old_limit);
        } else {
          rf32_.emplace_back();
          if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>::Read(input, &rf32_.back())) {
            return ::yb::rpc::ParseFailed("rf32");
          }
        }
        break;
      }
      case 18: { // rstr
        rstr_.emplace_back();
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, &rstr_.back())) {
          return ::yb::rpc::ParseFailed("rstr");
        }
        break;
      }
      case 19: { // message
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>::Read(input, mutable_message())) {
          return ::yb::rpc::ParseFailed("message");
        }
        break;
      }
      case 20: { // repeated_messages
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>::Read(input, &repeated_messages_.emplace_back())) {
          return ::yb::rpc::ParseFailed("repeated_messages");
        }
        break;
      }
      case 21: { // packed_u64
        if (p.first == 170) {
          int length;
          if (!input->ReadVarintSizeAsInt(&length)) {
            return ::yb::rpc::ParseFailed("packed_u64");
          }
          auto old_limit = input->PushLimit(length);
          while (input->BytesUntilLimit() > 0) {
            packed_u64_.emplace_back();
            if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>::Read(input, &packed_u64_.back())) {
              return ::yb::rpc::ParseFailed("packed_u64");
            }
          }

          input->PopLimit(old_limit);
        } else {
          packed_u64_.emplace_back();
          if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>::Read(input, &packed_u64_.back())) {
            return ::yb::rpc::ParseFailed("packed_u64");
          }
        }
        break;
      }
      case 22: { // packed_f32
        if (p.first == 178) {
          int length;
          if (!input->ReadVarintSizeAsInt(&length)) {
            return ::yb::rpc::ParseFailed("packed_f32");
          }
          auto old_limit = input->PushLimit(length);
          while (input->BytesUntilLimit() > 0) {
            packed_f32_.emplace_back();
            if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>::Read(input, &packed_f32_.back())) {
              return ::yb::rpc::ParseFailed("packed_f32");
            }
          }

          input->PopLimit(old_limit);
        } else {
          packed_f32_.emplace_back();
          if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>::Read(input, &packed_f32_.back())) {
            return ::yb::rpc::ParseFailed("packed_f32");
          }
        }
        break;
      }
      case 23: { // pairs
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightPairPB>::Read(input, &pairs_.emplace_back())) {
          return ::yb::rpc::ParseFailed("pairs");
        }
        break;
      }
      case 24: { // ptr_message
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>::Read(input, mutable_ptr_message())) {
          return ::yb::rpc::ParseFailed("ptr_message");
        }
        break;
      }
      case 25: { // map
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightRequestPB_LWMapEntry_DoNotUse>::Read(input, &map_.emplace_back())) {
          return ::yb::rpc::ParseFailed("map");
        }
        break;
      }
      case 26: { // extra_data
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc::LWAny>::Read(input, mutable_extra_data())) {
          return ::yb::rpc::ParseFailed("extra_data");
        }
        break;
      }
    }
  }
}

uint8_t* LWLightweightRequestPB::SerializeToArray(uint8_t* out) const {
  if (has_i32()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>, 8>(i32_, out);
  }
  if (has_i64()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT64, int64_t>, 16>(i64_, out);
  }
  if (has_f32()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>, 29>(f32_, out);
  }
  if (has_f64()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED64, uint64_t>, 33>(f64_, out);
  }
  if (has_u32()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 40>(u32_, out);
  }
  if (has_u64()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 48>(u64_, out);
  }
  if (has_r32()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FLOAT, float>, 61>(r32_, out);
  }
  if (has_r64()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE, double>, 65>(r64_, out);
  }
  if (has_str()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 74>(str_, out);
  }
  if (has_bytes()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BYTES, ::yb::Slice>, 82>(bytes_, out);
  }
  if (has_en()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_ENUM, ::yb::rpc_test::LightweightEnum>, 88>(en_, out);
  }
  if (has_sf32()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SFIXED32, int32_t>, 101>(sf32_, out);
  }
  if (has_sf64()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SFIXED64, int64_t>, 105>(sf64_, out);
  }
  if (has_si32()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT32, int32_t>, 112>(si32_, out);
  }
  if (has_si64()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT64, int64_t>, 120>(si64_, out);
  }
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 128>(ru32_, out);
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>, 141>(rf32_, out);
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 146>(rstr_, out);
  if (has_message()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 154>(message_, out);
  }
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 162>(repeated_messages_, out);
  out = ::yb::rpc::PackedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 170>(packed_u64_, packed_u64_cached_size_, out);
  out = ::yb::rpc::PackedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>, 178>(packed_f32_, 4 * packed_f32_.size(), out);
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightPairPB>, 186>(pairs_, out);
  if (has_ptr_message()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 194>(*ptr_message_, out);
  }
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightRequestPB_LWMapEntry_DoNotUse>, 202>(map_, out);
  if (has_extra_data()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc::LWAny>, 210>(extra_data_, out);
  }
  return out;
}

size_t LWLightweightRequestPB::SerializedSize() const {
  size_t result = 0;
  if (has_i32()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>, 1>(i32_);
  }
  if (has_i64()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT64, int64_t>, 1>(i64_);
  }
  if (has_f32()) {
    result += 5;
  }
  if (has_f64()) {
    result += 9;
  }
  if (has_u32()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 1>(u32_);
  }
  if (has_u64()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 1>(u64_);
  }
  if (has_r32()) {
    result += 5;
  }
  if (has_r64()) {
    result += 9;
  }
  if (has_str()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(str_);
  }
  if (has_bytes()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BYTES, ::yb::Slice>, 1>(bytes_);
  }
  if (has_en()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_ENUM, ::yb::rpc_test::LightweightEnum>, 1>(en_);
  }
  if (has_sf32()) {
    result += 5;
  }
  if (has_sf64()) {
    result += 9;
  }
  if (has_si32()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT32, int32_t>, 1>(si32_);
  }
  if (has_si64()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT64, int64_t>, 1>(si64_);
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 2>(ru32_);
  }
  {
    result += 6 * rf32_.size();
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 2>(rstr_);
  }
  if (has_message()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 2>(message_);
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 2>(repeated_messages_);
  }
  {
    result += ::yb::rpc::PackedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 2>(packed_u64_, &packed_u64_cached_size_);
  }
  {
    size_t body_size = 4 * packed_f32_.size();
    result += 2 + ::google::protobuf::io::CodedOutputStream::VarintSize32(narrow_cast<uint32_t>(body_size)) + body_size;
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightPairPB>, 2>(pairs_);
  }
  if (has_ptr_message()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 2>(*ptr_message_);
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightRequestPB_LWMapEntry_DoNotUse>, 2>(map_);
  }
  if (has_extra_data()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc::LWAny>, 2>(extra_data_);
  }
  cached_size_ = result;
  return result;
}

void LWLightweightRequestPB::ToGoogleProtobuf(LightweightRequestPB* out) const {
  if (has_i32()) {
    out->set_i32(i32_);
  } else {
    out->clear_i32();
  }
  if (has_i64()) {
    out->set_i64(i64_);
  } else {
    out->clear_i64();
  }
  if (has_f32()) {
    out->set_f32(f32_);
  } else {
    out->clear_f32();
  }
  if (has_f64()) {
    out->set_f64(f64_);
  } else {
    out->clear_f64();
  }
  if (has_u32()) {
    out->set_u32(u32_);
  } else {
    out->clear_u32();
  }
  if (has_u64()) {
    out->set_u64(u64_);
  } else {
    out->clear_u64();
  }
  if (has_r32()) {
    out->set_r32(r32_);
  } else {
    out->clear_r32();
  }
  if (has_r64()) {
    out->set_r64(r64_);
  } else {
    out->clear_r64();
  }
  if (has_str()) {
    out->set_str(str_.cdata(), str_.size());
  } else {
    out->clear_str();
  }
  if (has_bytes()) {
    out->set_bytes(bytes_.cdata(), bytes_.size());
  } else {
    out->clear_bytes();
  }
  if (has_en()) {
    out->set_en(en_);
  } else {
    out->clear_en();
  }
  if (has_sf32()) {
    out->set_sf32(sf32_);
  } else {
    out->clear_sf32();
  }
  if (has_sf64()) {
    out->set_sf64(sf64_);
  } else {
    out->clear_sf64();
  }
  if (has_si32()) {
    out->set_si32(si32_);
  } else {
    out->clear_si32();
  }
  if (has_si64()) {
    out->set_si64(si64_);
  } else {
    out->clear_si64();
  }
  {
    auto& repeated = *out->mutable_ru32();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(ru32_.size()));
    for (const auto& entry : ru32_) {
      repeated.Add(entry);
    }
  }
  {
    auto& repeated = *out->mutable_rf32();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(rf32_.size()));
    for (const auto& entry : rf32_) {
      repeated.Add(entry);
    }
  }
  {
    auto& repeated = *out->mutable_rstr();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(rstr_.size()));
    for (const auto& entry : rstr_) {
      repeated.Add()->assign(entry.cdata(), entry.size());
    }
  }
  if (has_message()) {
    message().ToGoogleProtobuf(out->mutable_message());
  }
  repeated_messages().ToGoogleProtobuf(out->mutable_repeated_messages());
  {
    auto& repeated = *out->mutable_packed_u64();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(packed_u64_.size()));
    for (const auto& entry : packed_u64_) {
      repeated.Add(entry);
    }
  }
  {
    auto& repeated = *out->mutable_packed_f32();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(packed_f32_.size()));
    for (const auto& entry : packed_f32_) {
      repeated.Add(entry);
    }
  }
  pairs().ToGoogleProtobuf(out->mutable_pairs());
  if (has_ptr_message()) {
    ptr_message().ToGoogleProtobuf(out->mutable_ptr_message());
  }
  {
    auto& repeated = *out->mutable_map();
    repeated.clear();
    for (const auto& entry : map_) {
      repeated[entry.key().ToBuffer()] = entry.value();
    }
  }
  if (has_extra_data()) {
    extra_data().ToGoogleProtobuf(out->mutable_extra_data());
  }
}

LWLightweightResponsePB_LWMapEntry_DoNotUse::LWLightweightResponsePB_LWMapEntry_DoNotUse(::yb::Arena* arena)
    : arena_(*arena) {
}

LWLightweightResponsePB_LWMapEntry_DoNotUse::LWLightweightResponsePB_LWMapEntry_DoNotUse(::yb::Arena* arena, const LWLightweightResponsePB_LWMapEntry_DoNotUse& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      key_(arena->DupSlice(rhs.key_)),
      value_(rhs.value_) {
}

void LWLightweightResponsePB_LWMapEntry_DoNotUse::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_key()) {
    ::yb::rpc::AppendFieldTitle("key", ": \"", &first, out);
    *out += key().ToBuffer();
    *out += '"';
  }
  if (has_value()) {
    ::yb::rpc::AppendFieldTitle("value", ": ", &first, out);
    *out += std::to_string(value());
  }
}

void LWLightweightResponsePB_LWMapEntry_DoNotUse::Clear() {
  clear_key();
  clear_value();
}

void LWLightweightResponsePB_LWMapEntry_DoNotUse::CopyFrom(const LWLightweightResponsePB_LWMapEntry_DoNotUse& rhs) {
  {
    key_ = arena_.DupSlice(rhs.key_);
  }
  {
    value_ = rhs.value_;
  }
  has_fields_ = rhs.has_fields_;
}

void LWLightweightResponsePB_LWMapEntry_DoNotUse::CopyFrom(const ::google::protobuf::MapPair<std::string, int64_t>& rhs) {
  {
    key_ = arena_.DupSlice(rhs.first);
    has_fields_.Set(LightweightResponsePB_MapEntry_DoNotUseFields::kKey);
  }
  {
    value_ = rhs.second;
    has_fields_.Set(LightweightResponsePB_MapEntry_DoNotUseFields::kValue);
  }
}

Status LWLightweightResponsePB_LWMapEntry_DoNotUse::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(31);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // key
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_key())) {
          return ::yb::rpc::ParseFailed("key");
        }
        break;
      }
      case 2: { // value
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT64, int64_t>::Read(input, mutable_value())) {
          return ::yb::rpc::ParseFailed("value");
        }
        break;
      }
    }
  }
}

uint8_t* LWLightweightResponsePB_LWMapEntry_DoNotUse::SerializeToArray(uint8_t* out) const {
  if (has_key()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 10>(key_, out);
  }
  if (has_value()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT64, int64_t>, 16>(value_, out);
  }
  return out;
}

size_t LWLightweightResponsePB_LWMapEntry_DoNotUse::SerializedSize() const {
  size_t result = 0;
  if (has_key()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(key_);
  }
  if (has_value()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT64, int64_t>, 1>(value_);
  }
  cached_size_ = result;
  return result;
}

LWLightweightResponsePB::LWLightweightResponsePB(::yb::Arena* arena)
    : arena_(*arena),
      ru32_(arena),
      rf32_(arena),
      rstr_(arena),
      message_(arena),
      repeated_messages_(arena),
      repeated_messages_copy_(arena),
      packed_u64_(arena),
      packed_f32_(arena),
      pairs_(arena),
      map_(arena) {
}

LWLightweightResponsePB::LWLightweightResponsePB(::yb::Arena* arena, const LWLightweightResponsePB& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      i32_(rhs.i32_),
      i64_(rhs.i64_),
      f32_(rhs.f32_),
      f64_(rhs.f64_),
      u32_(rhs.u32_),
      u64_(rhs.u64_),
      r32_(rhs.r32_),
      r64_(rhs.r64_),
      str_(arena->DupSlice(rhs.str_)),
      bytes_(arena->DupSlice(rhs.bytes_)),
      en_(rhs.en_),
      sf32_(rhs.sf32_),
      sf64_(rhs.sf64_),
      si32_(rhs.si32_),
      si64_(rhs.si64_),
      ru32_(rhs.ru32_.begin(), rhs.ru32_.end(), arena),
      rf32_(rhs.rf32_.begin(), rhs.rf32_.end(), arena),
      rstr_(arena),
      message_(arena, rhs.message_),
      repeated_messages_(arena, rhs.repeated_messages_),
      repeated_messages_copy_(arena, rhs.repeated_messages_copy_),
      packed_u64_(rhs.packed_u64_.begin(), rhs.packed_u64_.end(), arena),
      packed_f32_(rhs.packed_f32_.begin(), rhs.packed_f32_.end(), arena),
      pairs_(arena, rhs.pairs_),
      ptr_message_(rhs.ptr_message_ ? arena->NewObject<::yb::rpc_test::LWLightweightSubMessagePB>(arena, *rhs.ptr_message_) : nullptr),
      map_(arena, rhs.map_),
      short_debug_string_(arena->DupSlice(rhs.short_debug_string_)) {
  rstr_.reserve(rhs.rstr_.size());
  for (const auto& entry : rhs.rstr_) {
    rstr_.push_back(arena->DupSlice(entry));
  }
}

void LWLightweightResponsePB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_i32()) {
    ::yb::rpc::AppendFieldTitle("i32", ": ", &first, out);
    *out += std::to_string(i32());
  }
  if (has_i64()) {
    ::yb::rpc::AppendFieldTitle("i64", ": ", &first, out);
    *out += std::to_string(i64());
  }
  if (has_f32()) {
    ::yb::rpc::AppendFieldTitle("f32", ": ", &first, out);
    *out += std::to_string(f32());
  }
  if (has_f64()) {
    ::yb::rpc::AppendFieldTitle("f64", ": ", &first, out);
    *out += std::to_string(f64());
  }
  if (has_u32()) {
    ::yb::rpc::AppendFieldTitle("u32", ": ", &first, out);
    *out += std::to_string(u32());
  }
  if (has_u64()) {
    ::yb::rpc::AppendFieldTitle("u64", ": ", &first, out);
    *out += std::to_string(u64());
  }
  if (has_r32()) {
    ::yb::rpc::AppendFieldTitle("r32", ": ", &first, out);
    *out += ::SimpleFtoa(r32());
  }
  if (has_r64()) {
    ::yb::rpc::AppendFieldTitle("r64", ": ", &first, out);
    *out += ::SimpleDtoa(r64());
  }
  if (has_str()) {
    ::yb::rpc::AppendFieldTitle("str", ": \"", &first, out);
    *out += str().ToBuffer();
    *out += '"';
  }
  if (has_bytes()) {
    ::yb::rpc::AppendFieldTitle("bytes", ": \"", &first, out);
    *out += bytes().ToBuffer();
    *out += '"';
  }
  if (has_en()) {
    ::yb::rpc::AppendFieldTitle("en", ": ", &first, out);
    *out += ::yb::rpc_test::LightweightEnum_Name(en());
  }
  if (has_sf32()) {
    ::yb::rpc::AppendFieldTitle("sf32", ": ", &first, out);
    *out += std::to_string(sf32());
  }
  if (has_sf64()) {
    ::yb::rpc::AppendFieldTitle("sf64", ": ", &first, out);
    *out += std::to_string(sf64());
  }
  if (has_si32()) {
    ::yb::rpc::AppendFieldTitle("si32", ": ", &first, out);
    *out += std::to_string(si32());
  }
  if (has_si64()) {
    ::yb::rpc::AppendFieldTitle("si64", ": ", &first, out);
    *out += std::to_string(si64());
  }
  for (const auto& entry : ru32_) {
    ::yb::rpc::AppendFieldTitle("ru32", ": ", &first, out);
    *out += std::to_string(entry);
  }
  for (const auto& entry : rf32_) {
    ::yb::rpc::AppendFieldTitle("rf32", ": ", &first, out);
    *out += std::to_string(entry);
  }
  for (const auto& entry : rstr_) {
    ::yb::rpc::AppendFieldTitle("rstr", ": \"", &first, out);
    *out += entry.ToBuffer();
    *out += '"';
  }
  if (has_message()) {
    ::yb::rpc::AppendFieldTitle("message", " { ", &first, out);
    message().AppendToDebugString(out);
    *out += " }";
  }
  for (const auto& entry : repeated_messages_) {
    ::yb::rpc::AppendFieldTitle("repeated_messages", " { ", &first, out);
    entry.AppendToDebugString(out);
    *out += " }";
  }
  for (const auto& entry : packed_u64_) {
    ::yb::rpc::AppendFieldTitle("packed_u64", ": ", &first, out);
    *out += std::to_string(entry);
  }
  for (const auto& entry : packed_f32_) {
    ::yb::rpc::AppendFieldTitle("packed_f32", ": ", &first, out);
    *out += std::to_string(entry);
  }
  for (const auto& entry : pairs_) {
    ::yb::rpc::AppendFieldTitle("pairs", " { ", &first, out);
    entry.AppendToDebugString(out);
    *out += " }";
  }
  if (has_ptr_message()) {
    ::yb::rpc::AppendFieldTitle("ptr_message", " { ", &first, out);
    ptr_message().AppendToDebugString(out);
    *out += " }";
  }
  for (const auto& entry : map_) {
    ::yb::rpc::AppendFieldTitle("map", " { ", &first, out);
    entry.AppendToDebugString(out);
    *out += " }";
  }
  if (has_short_debug_string()) {
    ::yb::rpc::AppendFieldTitle("short_debug_string", ": \"", &first, out);
    *out += short_debug_string().ToBuffer();
    *out += '"';
  }
  for (const auto& entry : repeated_messages_copy_) {
    ::yb::rpc::AppendFieldTitle("repeated_messages_copy", " { ", &first, out);
    entry.AppendToDebugString(out);
    *out += " }";
  }
}

void LWLightweightResponsePB::Clear() {
  clear_i32();
  clear_i64();
  clear_f32();
  clear_f64();
  clear_u32();
  clear_u64();
  clear_r32();
  clear_r64();
  clear_str();
  clear_bytes();
  clear_en();
  clear_sf32();
  clear_sf64();
  clear_si32();
  clear_si64();
  ru32_.clear();
  rf32_.clear();
  rstr_.clear();
  clear_message();
  repeated_messages_.clear();
  repeated_messages_copy_.clear();
  packed_u64_.clear();
  packed_f32_.clear();
  pairs_.clear();
  clear_ptr_message();
  map_.clear();
  clear_short_debug_string();
}

void LWLightweightResponsePB::CopyFrom(const LWLightweightResponsePB& rhs) {
  if (rhs.has_i32()) {
    i32_ = rhs.i32_;
  } else {
    clear_i32();
  }
  if (rhs.has_i64()) {
    i64_ = rhs.i64_;
  } else {
    clear_i64();
  }
  if (rhs.has_f32()) {
    f32_ = rhs.f32_;
  } else {
    clear_f32();
  }
  if (rhs.has_f64()) {
    f64_ = rhs.f64_;
  } else {
    clear_f64();
  }
  if (rhs.has_u32()) {
    u32_ = rhs.u32_;
  } else {
    clear_u32();
  }
  if (rhs.has_u64()) {
    u64_ = rhs.u64_;
  } else {
    clear_u64();
  }
  if (rhs.has_r32()) {
    r32_ = rhs.r32_;
  } else {
    clear_r32();
  }
  if (rhs.has_r64()) {
    r64_ = rhs.r64_;
  } else {
    clear_r64();
  }
  if (rhs.has_str()) {
    str_ = arena_.DupSlice(rhs.str_);
  } else {
    clear_str();
  }
  if (rhs.has_bytes()) {
    bytes_ = arena_.DupSlice(rhs.bytes_);
  } else {
    clear_bytes();
  }
  if (rhs.has_en()) {
    en_ = rhs.en_;
  } else {
    clear_en();
  }
  if (rhs.has_sf32()) {
    sf32_ = rhs.sf32_;
  } else {
    clear_sf32();
  }
  if (rhs.has_sf64()) {
    sf64_ = rhs.sf64_;
  } else {
    clear_sf64();
  }
  if (rhs.has_si32()) {
    si32_ = rhs.si32_;
  } else {
    clear_si32();
  }
  if (rhs.has_si64()) {
    si64_ = rhs.si64_;
  } else {
    clear_si64();
  }
  ru32_ = rhs.ru32_;
  rf32_ = rhs.rf32_;
  rstr_.reserve(rhs.rstr_.size());
  for (const auto& entry : rhs.rstr_) {
    rstr_.push_back(arena_.DupSlice(entry));
  }
  if (rhs.has_message()) {
    message_.CopyFrom(rhs.message_);
  } else {
    clear_message();
  }
  repeated_messages_ = rhs.repeated_messages_;
  repeated_messages_copy_ = rhs.repeated_messages_copy_;
  packed_u64_ = rhs.packed_u64_;
  packed_f32_ = rhs.packed_f32_;
  pairs_ = rhs.pairs_;
  if (rhs.ptr_message_) {
    mutable_ptr_message()->CopyFrom(*rhs.ptr_message_);
  } else {
    clear_ptr_message();
  }
  map_ = rhs.map_;
  if (rhs.has_short_debug_string()) {
    short_debug_string_ = arena_.DupSlice(rhs.short_debug_string_);
  } else {
    clear_short_debug_string();
  }
  has_fields_ = rhs.has_fields_;
}

void LWLightweightResponsePB::CopyFrom(const LightweightResponsePB& rhs) {
  if (rhs.has_i32()) {
    i32_ = rhs.i32();
    has_fields_.Set(LightweightResponsePBFields::kI32);
  } else {
    clear_i32();
  }
  if (rhs.has_i64()) {
    i64_ = rhs.i64();
    has_fields_.Set(LightweightResponsePBFields::kI64);
  } else {
    clear_i64();
  }
  if (rhs.has_f32()) {
    f32_ = rhs.f32();
    has_fields_.Set(LightweightResponsePBFields::kF32);
  } else {
    clear_f32();
  }
  if (rhs.has_f64()) {
    f64_ = rhs.f64();
    has_fields_.Set(LightweightResponsePBFields::kF64);
  } else {
    clear_f64();
  }
  if (rhs.has_u32()) {
    u32_ = rhs.u32();
    has_fields_.Set(LightweightResponsePBFields::kU32);
  } else {
    clear_u32();
  }
  if (rhs.has_u64()) {
    u64_ = rhs.u64();
    has_fields_.Set(LightweightResponsePBFields::kU64);
  } else {
    clear_u64();
  }
  if (rhs.has_r32()) {
    r32_ = rhs.r32();
    has_fields_.Set(LightweightResponsePBFields::kR32);
  } else {
    clear_r32();
  }
  if (rhs.has_r64()) {
    r64_ = rhs.r64();
    has_fields_.Set(LightweightResponsePBFields::kR64);
  } else {
    clear_r64();
  }
  if (rhs.has_str()) {
    str_ = arena_.DupSlice(rhs.str());
    has_fields_.Set(LightweightResponsePBFields::kStr);
  } else {
    clear_str();
  }
  if (rhs.has_bytes()) {
    bytes_ = arena_.DupSlice(rhs.bytes());
    has_fields_.Set(LightweightResponsePBFields::kBytes);
  } else {
    clear_bytes();
  }
  if (rhs.has_en()) {
    en_ = rhs.en();
    has_fields_.Set(LightweightResponsePBFields::kEn);
  } else {
    clear_en();
  }
  if (rhs.has_sf32()) {
    sf32_ = rhs.sf32();
    has_fields_.Set(LightweightResponsePBFields::kSf32);
  } else {
    clear_sf32();
  }
  if (rhs.has_sf64()) {
    sf64_ = rhs.sf64();
    has_fields_.Set(LightweightResponsePBFields::kSf64);
  } else {
    clear_sf64();
  }
  if (rhs.has_si32()) {
    si32_ = rhs.si32();
    has_fields_.Set(LightweightResponsePBFields::kSi32);
  } else {
    clear_si32();
  }
  if (rhs.has_si64()) {
    si64_ = rhs.si64();
    has_fields_.Set(LightweightResponsePBFields::kSi64);
  } else {
    clear_si64();
  }
  ru32_.assign(rhs.ru32().begin(), rhs.ru32().end());
  rf32_.assign(rhs.rf32().begin(), rhs.rf32().end());
  rstr_.reserve(rhs.rstr().size());
  for (const auto& entry : rhs.rstr()) {
    rstr_.push_back(arena_.DupSlice(entry));
  }
  if (rhs.has_message()) {
    message_.CopyFrom(rhs.message());
    has_fields_.Set(LightweightResponsePBFields::kMessage);
  } else {
    clear_message();
  }
  repeated_messages_.assign(rhs.repeated_messages().begin(), rhs.repeated_messages().end());
  repeated_messages_copy_.assign(rhs.repeated_messages_copy().begin(), rhs.repeated_messages_copy().end());
  packed_u64_.assign(rhs.packed_u64().begin(), rhs.packed_u64().end());
  packed_f32_.assign(rhs.packed_f32().begin(), rhs.packed_f32().end());
  pairs_.assign(rhs.pairs().begin(), rhs.pairs().end());
  if (rhs.has_ptr_message()) {
    mutable_ptr_message()->CopyFrom(rhs.ptr_message());
  } else {
    clear_ptr_message();
  }
  map_.assign(rhs.map().begin(), rhs.map().end());
  if (rhs.has_short_debug_string()) {
    short_debug_string_ = arena_.DupSlice(rhs.short_debug_string());
    has_fields_.Set(LightweightResponsePBFields::kShortDebugString);
  } else {
    clear_short_debug_string();
  }
}

Status LWLightweightResponsePB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(1023);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // i32
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>::Read(input, mutable_i32())) {
          return ::yb::rpc::ParseFailed("i32");
        }
        break;
      }
      case 2: { // i64
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT64, int64_t>::Read(input, mutable_i64())) {
          return ::yb::rpc::ParseFailed("i64");
        }
        break;
      }
      case 3: { // f32
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>::Read(input, mutable_f32())) {
          return ::yb::rpc::ParseFailed("f32");
        }
        break;
      }
      case 4: { // f64
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED64, uint64_t>::Read(input, mutable_f64())) {
          return ::yb::rpc::ParseFailed("f64");
        }
        break;
      }
      case 5: { // u32
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, mutable_u32())) {
          return ::yb::rpc::ParseFailed("u32");
        }
        break;
      }
      case 6: { // u64
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>::Read(input, mutable_u64())) {
          return ::yb::rpc::ParseFailed("u64");
        }
        break;
      }
      case 7: { // r32
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FLOAT, float>::Read(input, mutable_r32())) {
          return ::yb::rpc::ParseFailed("r32");
        }
        break;
      }
      case 8: { // r64
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE, double>::Read(input, mutable_r64())) {
          return ::yb::rpc::ParseFailed("r64");
        }
        break;
      }
      case 9: { // str
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_str())) {
          return ::yb::rpc::ParseFailed("str");
        }
        break;
      }
      case 10: { // bytes
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BYTES, ::yb::Slice>::Read(input, mutable_bytes())) {
          return ::yb::rpc::ParseFailed("bytes");
        }
        break;
      }
      case 11: { // en
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_ENUM, ::yb::rpc_test::LightweightEnum>::Read(input, mutable_en())) {
          return ::yb::rpc::ParseFailed("en");
        }
        break;
      }
      case 12: { // sf32
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SFIXED32, int32_t>::Read(input, mutable_sf32())) {
          return ::yb::rpc::ParseFailed("sf32");
        }
        break;
      }
      case 13: { // sf64
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SFIXED64, int64_t>::Read(input, mutable_sf64())) {
          return ::yb::rpc::ParseFailed("sf64");
        }
        break;
      }
      case 14: { // si32
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT32, int32_t>::Read(input, mutable_si32())) {
          return ::yb::rpc::ParseFailed("si32");
        }
        break;
      }
      case 15: { // si64
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT64, int64_t>::Read(input, mutable_si64())) {
          return ::yb::rpc::ParseFailed("si64");
        }
        break;
      }
      case 16: { // ru32
        if (p.first == 130) {
          int length;
          if (!input->ReadVarintSizeAsInt(&length)) {
            return ::yb::rpc::ParseFailed("ru32");
          }
          auto old_limit = input->PushLimit(length);
          while (input->BytesUntilLimit() > 0) {
            ru32_.emplace_back();
            if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, &ru32_.back())) {
              return ::yb::rpc::ParseFailed("ru32");
            }
          }

          input->PopLimit(old_limit);
        } else {
          ru32_.emplace_back();
          if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>::Read(input, &ru32_.back())) {
            return ::yb::rpc::ParseFailed("ru32");
          }
        }
        break;
      }
      case 17: { // rf32
        if (p.first == 138) {
          int length;
          if (!input->ReadVarintSizeAsInt(&length)) {
            return ::yb::rpc::ParseFailed("rf32");
          }
          auto old_limit = input->PushLimit(length);
          while (input->BytesUntilLimit() > 0) {
            rf32_.emplace_back();
            if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>::Read(input, &rf32_.back())) {
              return ::yb::rpc::ParseFailed("rf32");
            }
          }

          input->PopLimit(old_limit);
        } else {
          rf32_.emplace_back();
          if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>::Read(input, &rf32_.back())) {
            return ::yb::rpc::ParseFailed("rf32");
          }
        }
        break;
      }
      case 18: { // rstr
        rstr_.emplace_back();
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, &rstr_.back())) {
          return ::yb::rpc::ParseFailed("rstr");
        }
        break;
      }
      case 19: { // message
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>::Read(input, mutable_message())) {
          return ::yb::rpc::ParseFailed("message");
        }
        break;
      }
      case 20: { // repeated_messages
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>::Read(input, &repeated_messages_.emplace_back())) {
          return ::yb::rpc::ParseFailed("repeated_messages");
        }
        break;
      }
      case 120: { // repeated_messages_copy
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>::Read(input, &repeated_messages_copy_.emplace_back())) {
          return ::yb::rpc::ParseFailed("repeated_messages_copy");
        }
        break;
      }
      case 21: { // packed_u64
        if (p.first == 170) {
          int length;
          if (!input->ReadVarintSizeAsInt(&length)) {
            return ::yb::rpc::ParseFailed("packed_u64");
          }
          auto old_limit = input->PushLimit(length);
          while (input->BytesUntilLimit() > 0) {
            packed_u64_.emplace_back();
            if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>::Read(input, &packed_u64_.back())) {
              return ::yb::rpc::ParseFailed("packed_u64");
            }
          }

          input->PopLimit(old_limit);
        } else {
          packed_u64_.emplace_back();
          if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>::Read(input, &packed_u64_.back())) {
            return ::yb::rpc::ParseFailed("packed_u64");
          }
        }
        break;
      }
      case 22: { // packed_f32
        if (p.first == 178) {
          int length;
          if (!input->ReadVarintSizeAsInt(&length)) {
            return ::yb::rpc::ParseFailed("packed_f32");
          }
          auto old_limit = input->PushLimit(length);
          while (input->BytesUntilLimit() > 0) {
            packed_f32_.emplace_back();
            if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>::Read(input, &packed_f32_.back())) {
              return ::yb::rpc::ParseFailed("packed_f32");
            }
          }

          input->PopLimit(old_limit);
        } else {
          packed_f32_.emplace_back();
          if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>::Read(input, &packed_f32_.back())) {
            return ::yb::rpc::ParseFailed("packed_f32");
          }
        }
        break;
      }
      case 23: { // pairs
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightPairPB>::Read(input, &pairs_.emplace_back())) {
          return ::yb::rpc::ParseFailed("pairs");
        }
        break;
      }
      case 24: { // ptr_message
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>::Read(input, mutable_ptr_message())) {
          return ::yb::rpc::ParseFailed("ptr_message");
        }
        break;
      }
      case 25: { // map
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightResponsePB_LWMapEntry_DoNotUse>::Read(input, &map_.emplace_back())) {
          return ::yb::rpc::ParseFailed("map");
        }
        break;
      }
      case 100: { // short_debug_string
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>::Read(input, mutable_short_debug_string())) {
          return ::yb::rpc::ParseFailed("short_debug_string");
        }
        break;
      }
    }
  }
}

uint8_t* LWLightweightResponsePB::SerializeToArray(uint8_t* out) const {
  if (has_i32()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>, 8>(i32_, out);
  }
  if (has_i64()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT64, int64_t>, 16>(i64_, out);
  }
  if (has_f32()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>, 29>(f32_, out);
  }
  if (has_f64()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED64, uint64_t>, 33>(f64_, out);
  }
  if (has_u32()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 40>(u32_, out);
  }
  if (has_u64()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 48>(u64_, out);
  }
  if (has_r32()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FLOAT, float>, 61>(r32_, out);
  }
  if (has_r64()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE, double>, 65>(r64_, out);
  }
  if (has_str()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 74>(str_, out);
  }
  if (has_bytes()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BYTES, ::yb::Slice>, 82>(bytes_, out);
  }
  if (has_en()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_ENUM, ::yb::rpc_test::LightweightEnum>, 88>(en_, out);
  }
  if (has_sf32()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SFIXED32, int32_t>, 101>(sf32_, out);
  }
  if (has_sf64()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SFIXED64, int64_t>, 105>(sf64_, out);
  }
  if (has_si32()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT32, int32_t>, 112>(si32_, out);
  }
  if (has_si64()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT64, int64_t>, 120>(si64_, out);
  }
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 128>(ru32_, out);
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>, 141>(rf32_, out);
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 146>(rstr_, out);
  if (has_message()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 154>(message_, out);
  }
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 162>(repeated_messages_, out);
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 962>(repeated_messages_copy_, out);
  out = ::yb::rpc::PackedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 170>(packed_u64_, packed_u64_cached_size_, out);
  out = ::yb::rpc::PackedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_FIXED32, uint32_t>, 178>(packed_f32_, 4 * packed_f32_.size(), out);
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightPairPB>, 186>(pairs_, out);
  if (has_ptr_message()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 194>(*ptr_message_, out);
  }
  out = ::yb::rpc::RepeatedWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightResponsePB_LWMapEntry_DoNotUse>, 202>(map_, out);
  if (has_short_debug_string()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 802>(short_debug_string_, out);
  }
  return out;
}

size_t LWLightweightResponsePB::SerializedSize() const {
  size_t result = 0;
  if (has_i32()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>, 1>(i32_);
  }
  if (has_i64()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT64, int64_t>, 1>(i64_);
  }
  if (has_f32()) {
    result += 5;
  }
  if (has_f64()) {
    result += 9;
  }
  if (has_u32()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 1>(u32_);
  }
  if (has_u64()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 1>(u64_);
  }
  if (has_r32()) {
    result += 5;
  }
  if (has_r64()) {
    result += 9;
  }
  if (has_str()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 1>(str_);
  }
  if (has_bytes()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_BYTES, ::yb::Slice>, 1>(bytes_);
  }
  if (has_en()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_ENUM, ::yb::rpc_test::LightweightEnum>, 1>(en_);
  }
  if (has_sf32()) {
    result += 5;
  }
  if (has_sf64()) {
    result += 9;
  }
  if (has_si32()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT32, int32_t>, 1>(si32_);
  }
  if (has_si64()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_SINT64, int64_t>, 1>(si64_);
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT32, uint32_t>, 2>(ru32_);
  }
  {
    result += 6 * rf32_.size();
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 2>(rstr_);
  }
  if (has_message()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 2>(message_);
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 2>(repeated_messages_);
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 2>(repeated_messages_copy_);
  }
  {
    result += ::yb::rpc::PackedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_UINT64, uint64_t>, 2>(packed_u64_, &packed_u64_cached_size_);
  }
  {
    size_t body_size = 4 * packed_f32_.size();
    result += 2 + ::google::protobuf::io::CodedOutputStream::VarintSize32(narrow_cast<uint32_t>(body_size)) + body_size;
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightPairPB>, 2>(pairs_);
  }
  if (has_ptr_message()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightSubMessagePB>, 2>(*ptr_message_);
  }
  {
    result += ::yb::rpc::RepeatedSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWLightweightResponsePB_LWMapEntry_DoNotUse>, 2>(map_);
  }
  if (has_short_debug_string()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_STRING, ::yb::Slice>, 2>(short_debug_string_);
  }
  cached_size_ = result;
  return result;
}

void LWLightweightResponsePB::ToGoogleProtobuf(LightweightResponsePB* out) const {
  if (has_i32()) {
    out->set_i32(i32_);
  } else {
    out->clear_i32();
  }
  if (has_i64()) {
    out->set_i64(i64_);
  } else {
    out->clear_i64();
  }
  if (has_f32()) {
    out->set_f32(f32_);
  } else {
    out->clear_f32();
  }
  if (has_f64()) {
    out->set_f64(f64_);
  } else {
    out->clear_f64();
  }
  if (has_u32()) {
    out->set_u32(u32_);
  } else {
    out->clear_u32();
  }
  if (has_u64()) {
    out->set_u64(u64_);
  } else {
    out->clear_u64();
  }
  if (has_r32()) {
    out->set_r32(r32_);
  } else {
    out->clear_r32();
  }
  if (has_r64()) {
    out->set_r64(r64_);
  } else {
    out->clear_r64();
  }
  if (has_str()) {
    out->set_str(str_.cdata(), str_.size());
  } else {
    out->clear_str();
  }
  if (has_bytes()) {
    out->set_bytes(bytes_.cdata(), bytes_.size());
  } else {
    out->clear_bytes();
  }
  if (has_en()) {
    out->set_en(en_);
  } else {
    out->clear_en();
  }
  if (has_sf32()) {
    out->set_sf32(sf32_);
  } else {
    out->clear_sf32();
  }
  if (has_sf64()) {
    out->set_sf64(sf64_);
  } else {
    out->clear_sf64();
  }
  if (has_si32()) {
    out->set_si32(si32_);
  } else {
    out->clear_si32();
  }
  if (has_si64()) {
    out->set_si64(si64_);
  } else {
    out->clear_si64();
  }
  {
    auto& repeated = *out->mutable_ru32();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(ru32_.size()));
    for (const auto& entry : ru32_) {
      repeated.Add(entry);
    }
  }
  {
    auto& repeated = *out->mutable_rf32();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(rf32_.size()));
    for (const auto& entry : rf32_) {
      repeated.Add(entry);
    }
  }
  {
    auto& repeated = *out->mutable_rstr();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(rstr_.size()));
    for (const auto& entry : rstr_) {
      repeated.Add()->assign(entry.cdata(), entry.size());
    }
  }
  if (has_message()) {
    message().ToGoogleProtobuf(out->mutable_message());
  }
  repeated_messages().ToGoogleProtobuf(out->mutable_repeated_messages());
  repeated_messages_copy().ToGoogleProtobuf(out->mutable_repeated_messages_copy());
  {
    auto& repeated = *out->mutable_packed_u64();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(packed_u64_.size()));
    for (const auto& entry : packed_u64_) {
      repeated.Add(entry);
    }
  }
  {
    auto& repeated = *out->mutable_packed_f32();
    repeated.Clear();
    repeated.Reserve(narrow_cast<int>(packed_f32_.size()));
    for (const auto& entry : packed_f32_) {
      repeated.Add(entry);
    }
  }
  pairs().ToGoogleProtobuf(out->mutable_pairs());
  if (has_ptr_message()) {
    ptr_message().ToGoogleProtobuf(out->mutable_ptr_message());
  }
  {
    auto& repeated = *out->mutable_map();
    repeated.clear();
    for (const auto& entry : map_) {
      repeated[entry.key().ToBuffer()] = entry.value();
    }
  }
  if (has_short_debug_string()) {
    out->set_short_debug_string(short_debug_string_.cdata(), short_debug_string_.size());
  } else {
    out->clear_short_debug_string();
  }
}

LWTrivialRequestPB::LWTrivialRequestPB(::yb::Arena* arena) {
}

LWTrivialRequestPB::LWTrivialRequestPB(::yb::Arena* arena, const LWTrivialRequestPB& rhs)
    : has_fields_(rhs.has_fields_),
      value_(rhs.value_) {
}

void LWTrivialRequestPB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_value()) {
    ::yb::rpc::AppendFieldTitle("value", ": ", &first, out);
    *out += std::to_string(value());
  }
}

void LWTrivialRequestPB::Clear() {
  clear_value();
}

void LWTrivialRequestPB::CopyFrom(const LWTrivialRequestPB& rhs) {
  if (rhs.has_value()) {
    value_ = rhs.value_;
  } else {
    clear_value();
  }
  has_fields_ = rhs.has_fields_;
}

void LWTrivialRequestPB::CopyFrom(const TrivialRequestPB& rhs) {
  if (rhs.has_value()) {
    value_ = rhs.value();
    has_fields_.Set(TrivialRequestPBFields::kValue);
  } else {
    clear_value();
  }
}

Status LWTrivialRequestPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(15);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // value
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>::Read(input, mutable_value())) {
          return ::yb::rpc::ParseFailed("value");
        }
        break;
      }
    }
  }
}

uint8_t* LWTrivialRequestPB::SerializeToArray(uint8_t* out) const {
  if (has_value()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>, 8>(value_, out);
  }
  return out;
}

size_t LWTrivialRequestPB::SerializedSize() const {
  size_t result = 0;
  if (has_value()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>, 1>(value_);
  }
  cached_size_ = result;
  return result;
}

void LWTrivialRequestPB::ToGoogleProtobuf(TrivialRequestPB* out) const {
  if (has_value()) {
    out->set_value(value_);
  } else {
    out->clear_value();
  }
}

LWTrivialErrorPB::LWTrivialErrorPB(::yb::Arena* arena) {
}

LWTrivialErrorPB::LWTrivialErrorPB(::yb::Arena* arena, const LWTrivialErrorPB& rhs)
    : has_fields_(rhs.has_fields_),
      code_(rhs.code_) {
}

void LWTrivialErrorPB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_code()) {
    ::yb::rpc::AppendFieldTitle("code", ": ", &first, out);
    *out += std::to_string(code());
  }
}

void LWTrivialErrorPB::Clear() {
  clear_code();
}

void LWTrivialErrorPB::CopyFrom(const LWTrivialErrorPB& rhs) {
  if (rhs.has_code()) {
    code_ = rhs.code_;
  } else {
    clear_code();
  }
  has_fields_ = rhs.has_fields_;
}

void LWTrivialErrorPB::CopyFrom(const TrivialErrorPB& rhs) {
  if (rhs.has_code()) {
    code_ = rhs.code();
    has_fields_.Set(TrivialErrorPBFields::kCode);
  } else {
    clear_code();
  }
}

Status LWTrivialErrorPB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(15);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // code
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>::Read(input, mutable_code())) {
          return ::yb::rpc::ParseFailed("code");
        }
        break;
      }
    }
  }
}

uint8_t* LWTrivialErrorPB::SerializeToArray(uint8_t* out) const {
  if (has_code()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>, 8>(code_, out);
  }
  return out;
}

size_t LWTrivialErrorPB::SerializedSize() const {
  size_t result = 0;
  if (has_code()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>, 1>(code_);
  }
  cached_size_ = result;
  return result;
}

void LWTrivialErrorPB::ToGoogleProtobuf(TrivialErrorPB* out) const {
  if (has_code()) {
    out->set_code(code_);
  } else {
    out->clear_code();
  }
}

LWTrivialResponsePB::LWTrivialResponsePB(::yb::Arena* arena)
    : arena_(*arena),
      error_(arena) {
}

LWTrivialResponsePB::LWTrivialResponsePB(::yb::Arena* arena, const LWTrivialResponsePB& rhs)
    : arena_(*arena),
      has_fields_(rhs.has_fields_),
      error_(arena, rhs.error_),
      value_(rhs.value_) {
}

void LWTrivialResponsePB::AppendToDebugString(std::string* out) const {
  bool first = true;if (has_error()) {
    ::yb::rpc::AppendFieldTitle("error", " { ", &first, out);
    error().AppendToDebugString(out);
    *out += " }";
  }
  if (has_value()) {
    ::yb::rpc::AppendFieldTitle("value", ": ", &first, out);
    *out += std::to_string(value());
  }
}

void LWTrivialResponsePB::Clear() {
  clear_error();
  clear_value();
}

void LWTrivialResponsePB::CopyFrom(const LWTrivialResponsePB& rhs) {
  if (rhs.has_error()) {
    error_.CopyFrom(rhs.error_);
  } else {
    clear_error();
  }
  if (rhs.has_value()) {
    value_ = rhs.value_;
  } else {
    clear_value();
  }
  has_fields_ = rhs.has_fields_;
}

void LWTrivialResponsePB::CopyFrom(const TrivialResponsePB& rhs) {
  if (rhs.has_error()) {
    error_.CopyFrom(rhs.error());
    has_fields_.Set(TrivialResponsePBFields::kError);
  } else {
    clear_error();
  }
  if (rhs.has_value()) {
    value_ = rhs.value();
    has_fields_.Set(TrivialResponsePBFields::kValue);
  } else {
    clear_value();
  }
}

Status LWTrivialResponsePB::ParseFromCodedStream(google::protobuf::io::CodedInputStream* input) {
  for (;;) {
    auto p = input->ReadTagWithCutoffNoLastTag(31);
    if (!p.second && !p.first) {
      return Status::OK();
    }
    switch(::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(p.first)) {
      case 1: { // error
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWTrivialErrorPB>::Read(input, mutable_error())) {
          return ::yb::rpc::ParseFailed("error");
        }
        break;
      }
      case 2: { // value
        if (!::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>::Read(input, mutable_value())) {
          return ::yb::rpc::ParseFailed("value");
        }
        break;
      }
    }
  }
}

uint8_t* LWTrivialResponsePB::SerializeToArray(uint8_t* out) const {
  if (has_error()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWTrivialErrorPB>, 10>(error_, out);
  }
  if (has_value()) {
    out = ::yb::rpc::SingleWrite<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>, 16>(value_, out);
  }
  return out;
}

size_t LWTrivialResponsePB::SerializedSize() const {
  size_t result = 0;
  if (has_error()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE, ::yb::rpc_test::LWTrivialErrorPB>, 1>(error_);
  }
  if (has_value()) {
    result += ::yb::rpc::SingleSize<::yb::rpc::LightweightSerialization<::google::protobuf::internal::WireFormatLite::TYPE_INT32, int32_t>, 1>(value_);
  }
  cached_size_ = result;
  return result;
}

void LWTrivialResponsePB::ToGoogleProtobuf(TrivialResponsePB* out) const {
  if (has_error()) {
    error().ToGoogleProtobuf(out->mutable_error());
  }
  if (has_value()) {
    out->set_value(value_);
  } else {
    out->clear_value();
  }
}

} // namespace rpc_test
} // namespace yb

YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

Coverage Report

Created: 2022-03-09 17:30