contrib/native/client/src/protobuf/User.pb.cc

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: User.proto

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "User.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)

namespace exec {
namespace user {

namespace {

const ::google::protobuf::Descriptor* Property_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Property_reflection_ = NULL;
const ::google::protobuf::Descriptor* UserProperties_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  UserProperties_reflection_ = NULL;
const ::google::protobuf::Descriptor* UserToBitHandshake_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  UserToBitHandshake_reflection_ = NULL;
const ::google::protobuf::Descriptor* RequestResults_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  RequestResults_reflection_ = NULL;
const ::google::protobuf::Descriptor* RunQuery_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  RunQuery_reflection_ = NULL;
const ::google::protobuf::Descriptor* BitToUserHandshake_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  BitToUserHandshake_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* RpcType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* QueryResultsMode_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* HandshakeStatus_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_User_2eproto() {
  protobuf_AddDesc_User_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "User.proto");
  GOOGLE_CHECK(file != NULL);
  Property_descriptor_ = file->message_type(0);
  static const int Property_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Property, key_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Property, value_),
  };
  Property_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Property_descriptor_,
      Property::default_instance_,
      Property_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Property, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Property, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Property));
  UserProperties_descriptor_ = file->message_type(1);
  static const int UserProperties_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserProperties, properties_),
  };
  UserProperties_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      UserProperties_descriptor_,
      UserProperties::default_instance_,
      UserProperties_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserProperties, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserProperties, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(UserProperties));
  UserToBitHandshake_descriptor_ = file->message_type(2);
  static const int UserToBitHandshake_offsets_[7] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, channel_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, support_listening_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, rpc_version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, credentials_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, properties_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, support_complex_types_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, support_timeout_),
  };
  UserToBitHandshake_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      UserToBitHandshake_descriptor_,
      UserToBitHandshake::default_instance_,
      UserToBitHandshake_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserToBitHandshake, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(UserToBitHandshake));
  RequestResults_descriptor_ = file->message_type(3);
  static const int RequestResults_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RequestResults, query_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RequestResults, maximum_responses_),
  };
  RequestResults_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      RequestResults_descriptor_,
      RequestResults::default_instance_,
      RequestResults_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RequestResults, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RequestResults, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(RequestResults));
  RunQuery_descriptor_ = file->message_type(4);
  static const int RunQuery_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, results_mode_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, plan_),
  };
  RunQuery_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      RunQuery_descriptor_,
      RunQuery::default_instance_,
      RunQuery_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(RunQuery));
  BitToUserHandshake_descriptor_ = file->message_type(5);
  static const int BitToUserHandshake_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, rpc_version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, status_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, errorid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, errormessage_),
  };
  BitToUserHandshake_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      BitToUserHandshake_descriptor_,
      BitToUserHandshake::default_instance_,
      BitToUserHandshake_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BitToUserHandshake, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(BitToUserHandshake));
  RpcType_descriptor_ = file->enum_type(0);
  QueryResultsMode_descriptor_ = file->enum_type(1);
  HandshakeStatus_descriptor_ = file->enum_type(2);
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_User_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Property_descriptor_, &Property::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    UserProperties_descriptor_, &UserProperties::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    UserToBitHandshake_descriptor_, &UserToBitHandshake::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    RequestResults_descriptor_, &RequestResults::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    RunQuery_descriptor_, &RunQuery::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    BitToUserHandshake_descriptor_, &BitToUserHandshake::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_User_2eproto() {
  delete Property::default_instance_;
  delete Property_reflection_;
  delete UserProperties::default_instance_;
  delete UserProperties_reflection_;
  delete UserToBitHandshake::default_instance_;
  delete UserToBitHandshake_reflection_;
  delete RequestResults::default_instance_;
  delete RequestResults_reflection_;
  delete RunQuery::default_instance_;
  delete RunQuery_reflection_;
  delete BitToUserHandshake::default_instance_;
  delete BitToUserHandshake_reflection_;
}

void protobuf_AddDesc_User_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::exec::protobuf_AddDesc_SchemaDef_2eproto();
  ::exec::shared::protobuf_AddDesc_UserBitShared_2eproto();
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\nUser.proto\022\texec.user\032\017SchemaDef.proto"
    "\032\023UserBitShared.proto\"&\n\010Property\022\013\n\003key"
    "\030\001 \002(\t\022\r\n\005value\030\002 \002(\t\"9\n\016UserProperties\022"
    "\'\n\nproperties\030\001 \003(\0132\023.exec.user.Property"
    "\"\234\002\n\022UserToBitHandshake\022.\n\007channel\030\001 \001(\016"
    "2\027.exec.shared.RpcChannel:\004USER\022\031\n\021suppo"
    "rt_listening\030\002 \001(\010\022\023\n\013rpc_version\030\003 \001(\005\022"
    "1\n\013credentials\030\004 \001(\0132\034.exec.shared.UserC"
    "redentials\022-\n\nproperties\030\005 \001(\0132\031.exec.us"
    "er.UserProperties\022$\n\025support_complex_typ"
    "es\030\006 \001(\010:\005false\022\036\n\017support_timeout\030\007 \001(\010"
    ":\005false\"S\n\016RequestResults\022&\n\010query_id\030\001 "
    "\001(\0132\024.exec.shared.QueryId\022\031\n\021maximum_res"
    "ponses\030\002 \001(\005\"q\n\010RunQuery\0221\n\014results_mode"
    "\030\001 \001(\0162\033.exec.user.QueryResultsMode\022$\n\004t"
    "ype\030\002 \001(\0162\026.exec.shared.QueryType\022\014\n\004pla"
    "n\030\003 \001(\t\"|\n\022BitToUserHandshake\022\023\n\013rpc_ver"
    "sion\030\002 \001(\005\022*\n\006status\030\003 \001(\0162\032.exec.user.H"
    "andshakeStatus\022\017\n\007errorId\030\004 \001(\t\022\024\n\014error"
    "Message\030\005 \001(\t*\341\001\n\007RpcType\022\r\n\tHANDSHAKE\020\000"
    "\022\007\n\003ACK\020\001\022\013\n\007GOODBYE\020\002\022\r\n\tRUN_QUERY\020\003\022\020\n"
    "\014CANCEL_QUERY\020\004\022\023\n\017REQUEST_RESULTS\020\005\022\027\n\023"
    "RESUME_PAUSED_QUERY\020\013\022\016\n\nQUERY_DATA\020\006\022\020\n"
    "\014QUERY_HANDLE\020\007\022\026\n\022REQ_META_FUNCTIONS\020\010\022"
    "\026\n\022RESP_FUNCTION_LIST\020\t\022\020\n\014QUERY_RESULT\020"
    "\n*#\n\020QueryResultsMode\022\017\n\013STREAM_FULL\020\001*^"
    "\n\017HandshakeStatus\022\013\n\007SUCCESS\020\001\022\030\n\024RPC_VE"
    "RSION_MISMATCH\020\002\022\017\n\013AUTH_FAILED\020\003\022\023\n\017UNK"
    "NOWN_FAILURE\020\004B+\n\033org.apache.drill.exec."
    "protoB\nUserProtosH\001", 1179);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "User.proto", &protobuf_RegisterTypes);
  Property::default_instance_ = new Property();
  UserProperties::default_instance_ = new UserProperties();
  UserToBitHandshake::default_instance_ = new UserToBitHandshake();
  RequestResults::default_instance_ = new RequestResults();
  RunQuery::default_instance_ = new RunQuery();
  BitToUserHandshake::default_instance_ = new BitToUserHandshake();
  Property::default_instance_->InitAsDefaultInstance();
  UserProperties::default_instance_->InitAsDefaultInstance();
  UserToBitHandshake::default_instance_->InitAsDefaultInstance();
  RequestResults::default_instance_->InitAsDefaultInstance();
  RunQuery::default_instance_->InitAsDefaultInstance();
  BitToUserHandshake::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_User_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_User_2eproto {
  StaticDescriptorInitializer_User_2eproto() {
    protobuf_AddDesc_User_2eproto();
  }
} static_descriptor_initializer_User_2eproto_;
const ::google::protobuf::EnumDescriptor* RpcType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return RpcType_descriptor_;
}
bool RpcType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* QueryResultsMode_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return QueryResultsMode_descriptor_;
}
bool QueryResultsMode_IsValid(int value) {
  switch(value) {
    case 1:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* HandshakeStatus_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return HandshakeStatus_descriptor_;
}
bool HandshakeStatus_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}


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

#ifndef _MSC_VER
const int Property::kKeyFieldNumber;
const int Property::kValueFieldNumber;
#endif  // !_MSC_VER

Property::Property()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void Property::InitAsDefaultInstance() {
}

Property::Property(const Property& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void Property::SharedCtor() {
  _cached_size_ = 0;
  key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

Property::~Property() {
  SharedDtor();
}

void Property::SharedDtor() {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    delete key_;
  }
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    delete value_;
  }
  if (this != default_instance_) {
  }
}

void Property::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Property::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Property_descriptor_;
}

const Property& Property::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

Property* Property::default_instance_ = NULL;

Property* Property::New() const {
  return new Property;
}

void Property::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_key()) {
      if (key_ != &::google::protobuf::internal::kEmptyString) {
        key_->clear();
      }
    }
    if (has_value()) {
      if (value_ != &::google::protobuf::internal::kEmptyString) {
        value_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Property::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string key = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_key()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->key().data(), this->key().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_value;
        break;
      }

      // required string value = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_value:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_value()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->value().data(), this->value().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Property::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string key = 1;
  if (has_key()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->key().data(), this->key().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->key(), output);
  }

  // required string value = 2;
  if (has_value()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->value().data(), this->value().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->value(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* Property::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required string key = 1;
  if (has_key()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->key().data(), this->key().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->key(), target);
  }

  // required string value = 2;
  if (has_value()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->value().data(), this->value().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->value(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int Property::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string key = 1;
    if (has_key()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->key());
    }

    // required string value = 2;
    if (has_value()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->value());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Property::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Property* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Property*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Property::MergeFrom(const Property& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_key()) {
      set_key(from.key());
    }
    if (from.has_value()) {
      set_value(from.value());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void Property::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Property::CopyFrom(const Property& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Property::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void Property::Swap(Property* other) {
  if (other != this) {
    std::swap(key_, other->key_);
    std::swap(value_, other->value_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Property::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Property_descriptor_;
  metadata.reflection = Property_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int UserProperties::kPropertiesFieldNumber;
#endif  // !_MSC_VER

UserProperties::UserProperties()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void UserProperties::InitAsDefaultInstance() {
}

UserProperties::UserProperties(const UserProperties& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void UserProperties::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UserProperties::~UserProperties() {
  SharedDtor();
}

void UserProperties::SharedDtor() {
  if (this != default_instance_) {
  }
}

void UserProperties::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* UserProperties::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return UserProperties_descriptor_;
}

const UserProperties& UserProperties::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

UserProperties* UserProperties::default_instance_ = NULL;

UserProperties* UserProperties::New() const {
  return new UserProperties;
}

void UserProperties::Clear() {
  properties_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool UserProperties::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .exec.user.Property properties = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_properties:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_properties()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_properties;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void UserProperties::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated .exec.user.Property properties = 1;
  for (int i = 0; i < this->properties_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->properties(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* UserProperties::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated .exec.user.Property properties = 1;
  for (int i = 0; i < this->properties_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->properties(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int UserProperties::ByteSize() const {
  int total_size = 0;

  // repeated .exec.user.Property properties = 1;
  total_size += 1 * this->properties_size();
  for (int i = 0; i < this->properties_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->properties(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UserProperties::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const UserProperties* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const UserProperties*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void UserProperties::MergeFrom(const UserProperties& from) {
  GOOGLE_CHECK_NE(&from, this);
  properties_.MergeFrom(from.properties_);
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void UserProperties::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void UserProperties::CopyFrom(const UserProperties& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserProperties::IsInitialized() const {

  for (int i = 0; i < properties_size(); i++) {
    if (!this->properties(i).IsInitialized()) return false;
  }
  return true;
}

void UserProperties::Swap(UserProperties* other) {
  if (other != this) {
    properties_.Swap(&other->properties_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata UserProperties::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = UserProperties_descriptor_;
  metadata.reflection = UserProperties_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int UserToBitHandshake::kChannelFieldNumber;
const int UserToBitHandshake::kSupportListeningFieldNumber;
const int UserToBitHandshake::kRpcVersionFieldNumber;
const int UserToBitHandshake::kCredentialsFieldNumber;
const int UserToBitHandshake::kPropertiesFieldNumber;
const int UserToBitHandshake::kSupportComplexTypesFieldNumber;
const int UserToBitHandshake::kSupportTimeoutFieldNumber;
#endif  // !_MSC_VER

UserToBitHandshake::UserToBitHandshake()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void UserToBitHandshake::InitAsDefaultInstance() {
  credentials_ = const_cast< ::exec::shared::UserCredentials*>(&::exec::shared::UserCredentials::default_instance());
  properties_ = const_cast< ::exec::user::UserProperties*>(&::exec::user::UserProperties::default_instance());
}

UserToBitHandshake::UserToBitHandshake(const UserToBitHandshake& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void UserToBitHandshake::SharedCtor() {
  _cached_size_ = 0;
  channel_ = 2;
  support_listening_ = false;
  rpc_version_ = 0;
  credentials_ = NULL;
  properties_ = NULL;
  support_complex_types_ = false;
  support_timeout_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

UserToBitHandshake::~UserToBitHandshake() {
  SharedDtor();
}

void UserToBitHandshake::SharedDtor() {
  if (this != default_instance_) {
    delete credentials_;
    delete properties_;
  }
}

void UserToBitHandshake::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* UserToBitHandshake::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return UserToBitHandshake_descriptor_;
}

const UserToBitHandshake& UserToBitHandshake::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

UserToBitHandshake* UserToBitHandshake::default_instance_ = NULL;

UserToBitHandshake* UserToBitHandshake::New() const {
  return new UserToBitHandshake;
}

void UserToBitHandshake::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    channel_ = 2;
    support_listening_ = false;
    rpc_version_ = 0;
    if (has_credentials()) {
      if (credentials_ != NULL) credentials_->::exec::shared::UserCredentials::Clear();
    }
    if (has_properties()) {
      if (properties_ != NULL) properties_->::exec::user::UserProperties::Clear();
    }
    support_complex_types_ = false;
    support_timeout_ = false;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool UserToBitHandshake::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .exec.shared.RpcChannel channel = 1 [default = USER];
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::shared::RpcChannel_IsValid(value)) {
            set_channel(static_cast< ::exec::shared::RpcChannel >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_support_listening;
        break;
      }

      // optional bool support_listening = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_support_listening:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &support_listening_)));
          set_has_support_listening();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_rpc_version;
        break;
      }

      // optional int32 rpc_version = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_rpc_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &rpc_version_)));
          set_has_rpc_version();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_credentials;
        break;
      }

      // optional .exec.shared.UserCredentials credentials = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_credentials:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_credentials()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_properties;
        break;
      }

      // optional .exec.user.UserProperties properties = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_properties:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_properties()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_support_complex_types;
        break;
      }

      // optional bool support_complex_types = 6 [default = false];
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_support_complex_types:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &support_complex_types_)));
          set_has_support_complex_types();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_support_timeout;
        break;
      }

      // optional bool support_timeout = 7 [default = false];
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_support_timeout:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &support_timeout_)));
          set_has_support_timeout();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void UserToBitHandshake::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .exec.shared.RpcChannel channel = 1 [default = USER];
  if (has_channel()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->channel(), output);
  }

  // optional bool support_listening = 2;
  if (has_support_listening()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->support_listening(), output);
  }

  // optional int32 rpc_version = 3;
  if (has_rpc_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->rpc_version(), output);
  }

  // optional .exec.shared.UserCredentials credentials = 4;
  if (has_credentials()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->credentials(), output);
  }

  // optional .exec.user.UserProperties properties = 5;
  if (has_properties()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->properties(), output);
  }

  // optional bool support_complex_types = 6 [default = false];
  if (has_support_complex_types()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->support_complex_types(), output);
  }

  // optional bool support_timeout = 7 [default = false];
  if (has_support_timeout()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->support_timeout(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* UserToBitHandshake::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .exec.shared.RpcChannel channel = 1 [default = USER];
  if (has_channel()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->channel(), target);
  }

  // optional bool support_listening = 2;
  if (has_support_listening()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->support_listening(), target);
  }

  // optional int32 rpc_version = 3;
  if (has_rpc_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->rpc_version(), target);
  }

  // optional .exec.shared.UserCredentials credentials = 4;
  if (has_credentials()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->credentials(), target);
  }

  // optional .exec.user.UserProperties properties = 5;
  if (has_properties()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->properties(), target);
  }

  // optional bool support_complex_types = 6 [default = false];
  if (has_support_complex_types()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->support_complex_types(), target);
  }

  // optional bool support_timeout = 7 [default = false];
  if (has_support_timeout()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->support_timeout(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int UserToBitHandshake::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .exec.shared.RpcChannel channel = 1 [default = USER];
    if (has_channel()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->channel());
    }

    // optional bool support_listening = 2;
    if (has_support_listening()) {
      total_size += 1 + 1;
    }

    // optional int32 rpc_version = 3;
    if (has_rpc_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->rpc_version());
    }

    // optional .exec.shared.UserCredentials credentials = 4;
    if (has_credentials()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->credentials());
    }

    // optional .exec.user.UserProperties properties = 5;
    if (has_properties()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->properties());
    }

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

    // optional bool support_timeout = 7 [default = false];
    if (has_support_timeout()) {
      total_size += 1 + 1;
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UserToBitHandshake::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const UserToBitHandshake* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const UserToBitHandshake*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void UserToBitHandshake::MergeFrom(const UserToBitHandshake& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_channel()) {
      set_channel(from.channel());
    }
    if (from.has_support_listening()) {
      set_support_listening(from.support_listening());
    }
    if (from.has_rpc_version()) {
      set_rpc_version(from.rpc_version());
    }
    if (from.has_credentials()) {
      mutable_credentials()->::exec::shared::UserCredentials::MergeFrom(from.credentials());
    }
    if (from.has_properties()) {
      mutable_properties()->::exec::user::UserProperties::MergeFrom(from.properties());
    }
    if (from.has_support_complex_types()) {
      set_support_complex_types(from.support_complex_types());
    }
    if (from.has_support_timeout()) {
      set_support_timeout(from.support_timeout());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void UserToBitHandshake::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void UserToBitHandshake::CopyFrom(const UserToBitHandshake& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserToBitHandshake::IsInitialized() const {

  if (has_properties()) {
    if (!this->properties().IsInitialized()) return false;
  }
  return true;
}

void UserToBitHandshake::Swap(UserToBitHandshake* other) {
  if (other != this) {
    std::swap(channel_, other->channel_);
    std::swap(support_listening_, other->support_listening_);
    std::swap(rpc_version_, other->rpc_version_);
    std::swap(credentials_, other->credentials_);
    std::swap(properties_, other->properties_);
    std::swap(support_complex_types_, other->support_complex_types_);
    std::swap(support_timeout_, other->support_timeout_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata UserToBitHandshake::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = UserToBitHandshake_descriptor_;
  metadata.reflection = UserToBitHandshake_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int RequestResults::kQueryIdFieldNumber;
const int RequestResults::kMaximumResponsesFieldNumber;
#endif  // !_MSC_VER

RequestResults::RequestResults()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void RequestResults::InitAsDefaultInstance() {
  query_id_ = const_cast< ::exec::shared::QueryId*>(&::exec::shared::QueryId::default_instance());
}

RequestResults::RequestResults(const RequestResults& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void RequestResults::SharedCtor() {
  _cached_size_ = 0;
  query_id_ = NULL;
  maximum_responses_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

RequestResults::~RequestResults() {
  SharedDtor();
}

void RequestResults::SharedDtor() {
  if (this != default_instance_) {
    delete query_id_;
  }
}

void RequestResults::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RequestResults::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return RequestResults_descriptor_;
}

const RequestResults& RequestResults::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

RequestResults* RequestResults::default_instance_ = NULL;

RequestResults* RequestResults::New() const {
  return new RequestResults;
}

void RequestResults::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_query_id()) {
      if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
    }
    maximum_responses_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool RequestResults::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .exec.shared.QueryId query_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_query_id()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_maximum_responses;
        break;
      }

      // optional int32 maximum_responses = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_maximum_responses:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &maximum_responses_)));
          set_has_maximum_responses();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void RequestResults::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .exec.shared.QueryId query_id = 1;
  if (has_query_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->query_id(), output);
  }

  // optional int32 maximum_responses = 2;
  if (has_maximum_responses()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->maximum_responses(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* RequestResults::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .exec.shared.QueryId query_id = 1;
  if (has_query_id()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->query_id(), target);
  }

  // optional int32 maximum_responses = 2;
  if (has_maximum_responses()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->maximum_responses(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int RequestResults::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .exec.shared.QueryId query_id = 1;
    if (has_query_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->query_id());
    }

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

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RequestResults::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const RequestResults* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const RequestResults*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void RequestResults::MergeFrom(const RequestResults& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_query_id()) {
      mutable_query_id()->::exec::shared::QueryId::MergeFrom(from.query_id());
    }
    if (from.has_maximum_responses()) {
      set_maximum_responses(from.maximum_responses());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void RequestResults::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RequestResults::CopyFrom(const RequestResults& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RequestResults::IsInitialized() const {

  return true;
}

void RequestResults::Swap(RequestResults* other) {
  if (other != this) {
    std::swap(query_id_, other->query_id_);
    std::swap(maximum_responses_, other->maximum_responses_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata RequestResults::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = RequestResults_descriptor_;
  metadata.reflection = RequestResults_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int RunQuery::kResultsModeFieldNumber;
const int RunQuery::kTypeFieldNumber;
const int RunQuery::kPlanFieldNumber;
#endif  // !_MSC_VER

RunQuery::RunQuery()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void RunQuery::InitAsDefaultInstance() {
}

RunQuery::RunQuery(const RunQuery& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void RunQuery::SharedCtor() {
  _cached_size_ = 0;
  results_mode_ = 1;
  type_ = 1;
  plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

RunQuery::~RunQuery() {
  SharedDtor();
}

void RunQuery::SharedDtor() {
  if (plan_ != &::google::protobuf::internal::kEmptyString) {
    delete plan_;
  }
  if (this != default_instance_) {
  }
}

void RunQuery::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RunQuery::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return RunQuery_descriptor_;
}

const RunQuery& RunQuery::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

RunQuery* RunQuery::default_instance_ = NULL;

RunQuery* RunQuery::New() const {
  return new RunQuery;
}

void RunQuery::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    results_mode_ = 1;
    type_ = 1;
    if (has_plan()) {
      if (plan_ != &::google::protobuf::internal::kEmptyString) {
        plan_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool RunQuery::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .exec.user.QueryResultsMode results_mode = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::QueryResultsMode_IsValid(value)) {
            set_results_mode(static_cast< ::exec::user::QueryResultsMode >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_type;
        break;
      }

      // optional .exec.shared.QueryType type = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::shared::QueryType_IsValid(value)) {
            set_type(static_cast< ::exec::shared::QueryType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(2, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_plan;
        break;
      }

      // optional string plan = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_plan:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_plan()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->plan().data(), this->plan().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void RunQuery::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .exec.user.QueryResultsMode results_mode = 1;
  if (has_results_mode()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->results_mode(), output);
  }

  // optional .exec.shared.QueryType type = 2;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->type(), output);
  }

  // optional string plan = 3;
  if (has_plan()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->plan().data(), this->plan().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      3, this->plan(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* RunQuery::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .exec.user.QueryResultsMode results_mode = 1;
  if (has_results_mode()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->results_mode(), target);
  }

  // optional .exec.shared.QueryType type = 2;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->type(), target);
  }

  // optional string plan = 3;
  if (has_plan()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->plan().data(), this->plan().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->plan(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int RunQuery::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .exec.user.QueryResultsMode results_mode = 1;
    if (has_results_mode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->results_mode());
    }

    // optional .exec.shared.QueryType type = 2;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
    }

    // optional string plan = 3;
    if (has_plan()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->plan());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RunQuery::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const RunQuery* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const RunQuery*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void RunQuery::MergeFrom(const RunQuery& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_results_mode()) {
      set_results_mode(from.results_mode());
    }
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_plan()) {
      set_plan(from.plan());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void RunQuery::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RunQuery::CopyFrom(const RunQuery& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RunQuery::IsInitialized() const {

  return true;
}

void RunQuery::Swap(RunQuery* other) {
  if (other != this) {
    std::swap(results_mode_, other->results_mode_);
    std::swap(type_, other->type_);
    std::swap(plan_, other->plan_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata RunQuery::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = RunQuery_descriptor_;
  metadata.reflection = RunQuery_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int BitToUserHandshake::kRpcVersionFieldNumber;
const int BitToUserHandshake::kStatusFieldNumber;
const int BitToUserHandshake::kErrorIdFieldNumber;
const int BitToUserHandshake::kErrorMessageFieldNumber;
#endif  // !_MSC_VER

BitToUserHandshake::BitToUserHandshake()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void BitToUserHandshake::InitAsDefaultInstance() {
}

BitToUserHandshake::BitToUserHandshake(const BitToUserHandshake& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void BitToUserHandshake::SharedCtor() {
  _cached_size_ = 0;
  rpc_version_ = 0;
  status_ = 1;
  errorid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

BitToUserHandshake::~BitToUserHandshake() {
  SharedDtor();
}

void BitToUserHandshake::SharedDtor() {
  if (errorid_ != &::google::protobuf::internal::kEmptyString) {
    delete errorid_;
  }
  if (errormessage_ != &::google::protobuf::internal::kEmptyString) {
    delete errormessage_;
  }
  if (this != default_instance_) {
  }
}

void BitToUserHandshake::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* BitToUserHandshake::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return BitToUserHandshake_descriptor_;
}

const BitToUserHandshake& BitToUserHandshake::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto();
  return *default_instance_;
}

BitToUserHandshake* BitToUserHandshake::default_instance_ = NULL;

BitToUserHandshake* BitToUserHandshake::New() const {
  return new BitToUserHandshake;
}

void BitToUserHandshake::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    rpc_version_ = 0;
    status_ = 1;
    if (has_errorid()) {
      if (errorid_ != &::google::protobuf::internal::kEmptyString) {
        errorid_->clear();
      }
    }
    if (has_errormessage()) {
      if (errormessage_ != &::google::protobuf::internal::kEmptyString) {
        errormessage_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool BitToUserHandshake::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 rpc_version = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &rpc_version_)));
          set_has_rpc_version();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_status;
        break;
      }

      // optional .exec.user.HandshakeStatus status = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_status:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::user::HandshakeStatus_IsValid(value)) {
            set_status(static_cast< ::exec::user::HandshakeStatus >(value));
          } else {
            mutable_unknown_fields()->AddVarint(3, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_errorId;
        break;
      }

      // optional string errorId = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_errorId:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_errorid()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->errorid().data(), this->errorid().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_errorMessage;
        break;
      }

      // optional string errorMessage = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_errorMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_errormessage()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->errormessage().data(), this->errormessage().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void BitToUserHandshake::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 rpc_version = 2;
  if (has_rpc_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->rpc_version(), output);
  }

  // optional .exec.user.HandshakeStatus status = 3;
  if (has_status()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->status(), output);
  }

  // optional string errorId = 4;
  if (has_errorid()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->errorid().data(), this->errorid().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      4, this->errorid(), output);
  }

  // optional string errorMessage = 5;
  if (has_errormessage()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->errormessage().data(), this->errormessage().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      5, this->errormessage(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* BitToUserHandshake::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 rpc_version = 2;
  if (has_rpc_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->rpc_version(), target);
  }

  // optional .exec.user.HandshakeStatus status = 3;
  if (has_status()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->status(), target);
  }

  // optional string errorId = 4;
  if (has_errorid()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->errorid().data(), this->errorid().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->errorid(), target);
  }

  // optional string errorMessage = 5;
  if (has_errormessage()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->errormessage().data(), this->errormessage().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        5, this->errormessage(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int BitToUserHandshake::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 rpc_version = 2;
    if (has_rpc_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->rpc_version());
    }

    // optional .exec.user.HandshakeStatus status = 3;
    if (has_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
    }

    // optional string errorId = 4;
    if (has_errorid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->errorid());
    }

    // optional string errorMessage = 5;
    if (has_errormessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->errormessage());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void BitToUserHandshake::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const BitToUserHandshake* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const BitToUserHandshake*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void BitToUserHandshake::MergeFrom(const BitToUserHandshake& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_rpc_version()) {
      set_rpc_version(from.rpc_version());
    }
    if (from.has_status()) {
      set_status(from.status());
    }
    if (from.has_errorid()) {
      set_errorid(from.errorid());
    }
    if (from.has_errormessage()) {
      set_errormessage(from.errormessage());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void BitToUserHandshake::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void BitToUserHandshake::CopyFrom(const BitToUserHandshake& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool BitToUserHandshake::IsInitialized() const {

  return true;
}

void BitToUserHandshake::Swap(BitToUserHandshake* other) {
  if (other != this) {
    std::swap(rpc_version_, other->rpc_version_);
    std::swap(status_, other->status_);
    std::swap(errorid_, other->errorid_);
    std::swap(errormessage_, other->errormessage_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata BitToUserHandshake::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = BitToUserHandshake_descriptor_;
  metadata.reflection = BitToUserHandshake_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace user
}  // namespace exec

// @@protoc_insertion_point(global_scope)