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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "Coordination.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 {

const ::google::protobuf::Descriptor* DrillbitEndpoint_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DrillbitEndpoint_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* DrillbitEndpoint_State_descriptor_ = NULL;
const ::google::protobuf::Descriptor* DrillServiceInstance_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DrillServiceInstance_reflection_ = NULL;
const ::google::protobuf::Descriptor* Roles_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Roles_reflection_ = NULL;

}  // namespace


void protobuf_AssignDesc_Coordination_2eproto() {
  protobuf_AddDesc_Coordination_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "Coordination.proto");
  GOOGLE_CHECK(file != NULL);
  DrillbitEndpoint_descriptor_ = file->message_type(0);
  static const int DrillbitEndpoint_offsets_[8] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillbitEndpoint, address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillbitEndpoint, user_port_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillbitEndpoint, control_port_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillbitEndpoint, data_port_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillbitEndpoint, roles_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillbitEndpoint, version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillbitEndpoint, state_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillbitEndpoint, http_port_),
  };
  DrillbitEndpoint_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DrillbitEndpoint_descriptor_,
      DrillbitEndpoint::default_instance_,
      DrillbitEndpoint_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillbitEndpoint, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillbitEndpoint, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DrillbitEndpoint));
  DrillbitEndpoint_State_descriptor_ = DrillbitEndpoint_descriptor_->enum_type(0);
  DrillServiceInstance_descriptor_ = file->message_type(1);
  static const int DrillServiceInstance_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillServiceInstance, id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillServiceInstance, registrationtimeutc_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillServiceInstance, endpoint_),
  };
  DrillServiceInstance_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DrillServiceInstance_descriptor_,
      DrillServiceInstance::default_instance_,
      DrillServiceInstance_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillServiceInstance, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrillServiceInstance, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DrillServiceInstance));
  Roles_descriptor_ = file->message_type(2);
  static const int Roles_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Roles, sql_query_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Roles, logical_plan_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Roles, physical_plan_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Roles, java_executor_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Roles, distributed_cache_),
  };
  Roles_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Roles_descriptor_,
      Roles::default_instance_,
      Roles_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Roles, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Roles, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Roles));
}

namespace {

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

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DrillbitEndpoint_descriptor_, &DrillbitEndpoint::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DrillServiceInstance_descriptor_, &DrillServiceInstance::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Roles_descriptor_, &Roles::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_Coordination_2eproto() {
  delete DrillbitEndpoint::default_instance_;
  delete DrillbitEndpoint_reflection_;
  delete DrillServiceInstance::default_instance_;
  delete DrillServiceInstance_reflection_;
  delete Roles::default_instance_;
  delete Roles_reflection_;
}

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

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\022Coordination.proto\022\004exec\"\212\002\n\020DrillbitE"
    "ndpoint\022\017\n\007address\030\001 \001(\t\022\021\n\tuser_port\030\002 "
    "\001(\005\022\024\n\014control_port\030\003 \001(\005\022\021\n\tdata_port\030\004"
    " \001(\005\022\032\n\005roles\030\005 \001(\0132\013.exec.Roles\022\017\n\007vers"
    "ion\030\006 \001(\t\022+\n\005state\030\007 \001(\0162\034.exec.Drillbit"
    "Endpoint.State\022\021\n\thttp_port\030\010 \001(\005\"<\n\005Sta"
    "te\022\013\n\007STARTUP\020\000\022\n\n\006ONLINE\020\001\022\r\n\tQUIESCENT"
    "\020\002\022\013\n\007OFFLINE\020\003\"i\n\024DrillServiceInstance\022"
    "\n\n\002id\030\001 \001(\t\022\033\n\023registrationTimeUTC\030\002 \001(\003"
    "\022(\n\010endpoint\030\003 \001(\0132\026.exec.DrillbitEndpoi"
    "nt\"\227\001\n\005Roles\022\027\n\tsql_query\030\001 \001(\010:\004true\022\032\n"
    "\014logical_plan\030\002 \001(\010:\004true\022\033\n\rphysical_pl"
    "an\030\003 \001(\010:\004true\022\033\n\rjava_executor\030\004 \001(\010:\004t"
    "rue\022\037\n\021distributed_cache\030\005 \001(\010:\004trueB3\n\033"
    "org.apache.drill.exec.protoB\022Coordinatio"
    "nProtosH\001", 609);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "Coordination.proto", &protobuf_RegisterTypes);
  DrillbitEndpoint::default_instance_ = new DrillbitEndpoint();
  DrillServiceInstance::default_instance_ = new DrillServiceInstance();
  Roles::default_instance_ = new Roles();
  DrillbitEndpoint::default_instance_->InitAsDefaultInstance();
  DrillServiceInstance::default_instance_->InitAsDefaultInstance();
  Roles::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_Coordination_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_Coordination_2eproto {
  StaticDescriptorInitializer_Coordination_2eproto() {
    protobuf_AddDesc_Coordination_2eproto();
  }
} static_descriptor_initializer_Coordination_2eproto_;

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

const ::google::protobuf::EnumDescriptor* DrillbitEndpoint_State_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DrillbitEndpoint_State_descriptor_;
}
bool DrillbitEndpoint_State_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const DrillbitEndpoint_State DrillbitEndpoint::STARTUP;
const DrillbitEndpoint_State DrillbitEndpoint::ONLINE;
const DrillbitEndpoint_State DrillbitEndpoint::QUIESCENT;
const DrillbitEndpoint_State DrillbitEndpoint::OFFLINE;
const DrillbitEndpoint_State DrillbitEndpoint::State_MIN;
const DrillbitEndpoint_State DrillbitEndpoint::State_MAX;
const int DrillbitEndpoint::State_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int DrillbitEndpoint::kAddressFieldNumber;
const int DrillbitEndpoint::kUserPortFieldNumber;
const int DrillbitEndpoint::kControlPortFieldNumber;
const int DrillbitEndpoint::kDataPortFieldNumber;
const int DrillbitEndpoint::kRolesFieldNumber;
const int DrillbitEndpoint::kVersionFieldNumber;
const int DrillbitEndpoint::kStateFieldNumber;
const int DrillbitEndpoint::kHttpPortFieldNumber;
#endif  // !_MSC_VER

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

void DrillbitEndpoint::InitAsDefaultInstance() {
  roles_ = const_cast< ::exec::Roles*>(&::exec::Roles::default_instance());
}

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

void DrillbitEndpoint::SharedCtor() {
  _cached_size_ = 0;
  address_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  user_port_ = 0;
  control_port_ = 0;
  data_port_ = 0;
  roles_ = NULL;
  version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  state_ = 0;
  http_port_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void DrillbitEndpoint::SharedDtor() {
  if (address_ != &::google::protobuf::internal::kEmptyString) {
    delete address_;
  }
  if (version_ != &::google::protobuf::internal::kEmptyString) {
    delete version_;
  }
  if (this != default_instance_) {
    delete roles_;
  }
}

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

const DrillbitEndpoint& DrillbitEndpoint::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_Coordination_2eproto();
  return *default_instance_;
}

DrillbitEndpoint* DrillbitEndpoint::default_instance_ = NULL;

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

void DrillbitEndpoint::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_address()) {
      if (address_ != &::google::protobuf::internal::kEmptyString) {
        address_->clear();
      }
    }
    user_port_ = 0;
    control_port_ = 0;
    data_port_ = 0;
    if (has_roles()) {
      if (roles_ != NULL) roles_->::exec::Roles::Clear();
    }
    if (has_version()) {
      if (version_ != &::google::protobuf::internal::kEmptyString) {
        version_->clear();
      }
    }
    state_ = 0;
    http_port_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DrillbitEndpoint::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 string address = 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_address()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->address().data(), this->address().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_user_port;
        break;
      }

      // optional int32 user_port = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_user_port:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &user_port_)));
          set_has_user_port();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_control_port;
        break;
      }

      // optional int32 control_port = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_control_port:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &control_port_)));
          set_has_control_port();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_data_port;
        break;
      }

      // optional int32 data_port = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_data_port:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &data_port_)));
          set_has_data_port();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_roles;
        break;
      }

      // optional .exec.Roles roles = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_roles:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_roles()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_version;
        break;
      }

      // optional string version = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_version:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_version()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->version().data(), this->version().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_state;
        break;
      }

      // optional .exec.DrillbitEndpoint.State state = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_state:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::exec::DrillbitEndpoint_State_IsValid(value)) {
            set_state(static_cast< ::exec::DrillbitEndpoint_State >(value));
          } else {
            mutable_unknown_fields()->AddVarint(7, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(64)) goto parse_http_port;
        break;
      }

      // optional int32 http_port = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_http_port:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &http_port_)));
          set_has_http_port();
        } 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 DrillbitEndpoint::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string address = 1;
  if (has_address()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->address().data(), this->address().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->address(), output);
  }

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

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

  // optional int32 data_port = 4;
  if (has_data_port()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->data_port(), output);
  }

  // optional .exec.Roles roles = 5;
  if (has_roles()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->roles(), output);
  }

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

  // optional .exec.DrillbitEndpoint.State state = 7;
  if (has_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      7, this->state(), output);
  }

  // optional int32 http_port = 8;
  if (has_http_port()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->http_port(), output);
  }

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

::google::protobuf::uint8* DrillbitEndpoint::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string address = 1;
  if (has_address()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->address().data(), this->address().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->address(), target);
  }

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

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

  // optional int32 data_port = 4;
  if (has_data_port()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->data_port(), target);
  }

  // optional .exec.Roles roles = 5;
  if (has_roles()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->roles(), target);
  }

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

  // optional .exec.DrillbitEndpoint.State state = 7;
  if (has_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      7, this->state(), target);
  }

  // optional int32 http_port = 8;
  if (has_http_port()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->http_port(), target);
  }

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

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

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

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

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

    // optional int32 data_port = 4;
    if (has_data_port()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->data_port());
    }

    // optional .exec.Roles roles = 5;
    if (has_roles()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->roles());
    }

    // optional string version = 6;
    if (has_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->version());
    }

    // optional .exec.DrillbitEndpoint.State state = 7;
    if (has_state()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->state());
    }

    // optional int32 http_port = 8;
    if (has_http_port()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->http_port());
    }

  }
  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 DrillbitEndpoint::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DrillbitEndpoint* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DrillbitEndpoint*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DrillbitEndpoint::MergeFrom(const DrillbitEndpoint& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_address()) {
      set_address(from.address());
    }
    if (from.has_user_port()) {
      set_user_port(from.user_port());
    }
    if (from.has_control_port()) {
      set_control_port(from.control_port());
    }
    if (from.has_data_port()) {
      set_data_port(from.data_port());
    }
    if (from.has_roles()) {
      mutable_roles()->::exec::Roles::MergeFrom(from.roles());
    }
    if (from.has_version()) {
      set_version(from.version());
    }
    if (from.has_state()) {
      set_state(from.state());
    }
    if (from.has_http_port()) {
      set_http_port(from.http_port());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool DrillbitEndpoint::IsInitialized() const {

  return true;
}

void DrillbitEndpoint::Swap(DrillbitEndpoint* other) {
  if (other != this) {
    std::swap(address_, other->address_);
    std::swap(user_port_, other->user_port_);
    std::swap(control_port_, other->control_port_);
    std::swap(data_port_, other->data_port_);
    std::swap(roles_, other->roles_);
    std::swap(version_, other->version_);
    std::swap(state_, other->state_);
    std::swap(http_port_, other->http_port_);
    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 DrillbitEndpoint::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DrillbitEndpoint_descriptor_;
  metadata.reflection = DrillbitEndpoint_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int DrillServiceInstance::kIdFieldNumber;
const int DrillServiceInstance::kRegistrationTimeUTCFieldNumber;
const int DrillServiceInstance::kEndpointFieldNumber;
#endif  // !_MSC_VER

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

void DrillServiceInstance::InitAsDefaultInstance() {
  endpoint_ = const_cast< ::exec::DrillbitEndpoint*>(&::exec::DrillbitEndpoint::default_instance());
}

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

void DrillServiceInstance::SharedCtor() {
  _cached_size_ = 0;
  id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  registrationtimeutc_ = GOOGLE_LONGLONG(0);
  endpoint_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void DrillServiceInstance::SharedDtor() {
  if (id_ != &::google::protobuf::internal::kEmptyString) {
    delete id_;
  }
  if (this != default_instance_) {
    delete endpoint_;
  }
}

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

const DrillServiceInstance& DrillServiceInstance::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_Coordination_2eproto();
  return *default_instance_;
}

DrillServiceInstance* DrillServiceInstance::default_instance_ = NULL;

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

void DrillServiceInstance::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_id()) {
      if (id_ != &::google::protobuf::internal::kEmptyString) {
        id_->clear();
      }
    }
    registrationtimeutc_ = GOOGLE_LONGLONG(0);
    if (has_endpoint()) {
      if (endpoint_ != NULL) endpoint_->::exec::DrillbitEndpoint::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DrillServiceInstance::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 string id = 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_id()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->id().data(), this->id().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_registrationTimeUTC;
        break;
      }

      // optional int64 registrationTimeUTC = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_registrationTimeUTC:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &registrationtimeutc_)));
          set_has_registrationtimeutc();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_endpoint;
        break;
      }

      // optional .exec.DrillbitEndpoint endpoint = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_endpoint:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_endpoint()));
        } 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 DrillServiceInstance::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string id = 1;
  if (has_id()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->id().data(), this->id().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->id(), output);
  }

  // optional int64 registrationTimeUTC = 2;
  if (has_registrationtimeutc()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->registrationtimeutc(), output);
  }

  // optional .exec.DrillbitEndpoint endpoint = 3;
  if (has_endpoint()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->endpoint(), output);
  }

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

::google::protobuf::uint8* DrillServiceInstance::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string id = 1;
  if (has_id()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->id().data(), this->id().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->id(), target);
  }

  // optional int64 registrationTimeUTC = 2;
  if (has_registrationtimeutc()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->registrationtimeutc(), target);
  }

  // optional .exec.DrillbitEndpoint endpoint = 3;
  if (has_endpoint()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->endpoint(), target);
  }

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

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

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

    // optional int64 registrationTimeUTC = 2;
    if (has_registrationtimeutc()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->registrationtimeutc());
    }

    // optional .exec.DrillbitEndpoint endpoint = 3;
    if (has_endpoint()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->endpoint());
    }

  }
  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 DrillServiceInstance::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DrillServiceInstance* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DrillServiceInstance*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DrillServiceInstance::MergeFrom(const DrillServiceInstance& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_id()) {
      set_id(from.id());
    }
    if (from.has_registrationtimeutc()) {
      set_registrationtimeutc(from.registrationtimeutc());
    }
    if (from.has_endpoint()) {
      mutable_endpoint()->::exec::DrillbitEndpoint::MergeFrom(from.endpoint());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool DrillServiceInstance::IsInitialized() const {

  return true;
}

void DrillServiceInstance::Swap(DrillServiceInstance* other) {
  if (other != this) {
    std::swap(id_, other->id_);
    std::swap(registrationtimeutc_, other->registrationtimeutc_);
    std::swap(endpoint_, other->endpoint_);
    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 DrillServiceInstance::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DrillServiceInstance_descriptor_;
  metadata.reflection = DrillServiceInstance_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Roles::kSqlQueryFieldNumber;
const int Roles::kLogicalPlanFieldNumber;
const int Roles::kPhysicalPlanFieldNumber;
const int Roles::kJavaExecutorFieldNumber;
const int Roles::kDistributedCacheFieldNumber;
#endif  // !_MSC_VER

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

void Roles::InitAsDefaultInstance() {
}

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

void Roles::SharedCtor() {
  _cached_size_ = 0;
  sql_query_ = true;
  logical_plan_ = true;
  physical_plan_ = true;
  java_executor_ = true;
  distributed_cache_ = true;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const Roles& Roles::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_Coordination_2eproto();
  return *default_instance_;
}

Roles* Roles::default_instance_ = NULL;

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

void Roles::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    sql_query_ = true;
    logical_plan_ = true;
    physical_plan_ = true;
    java_executor_ = true;
    distributed_cache_ = true;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Roles::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 bool sql_query = 1 [default = true];
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &sql_query_)));
          set_has_sql_query();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_logical_plan;
        break;
      }

      // optional bool logical_plan = 2 [default = true];
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_logical_plan:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &logical_plan_)));
          set_has_logical_plan();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_physical_plan;
        break;
      }

      // optional bool physical_plan = 3 [default = true];
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_physical_plan:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &physical_plan_)));
          set_has_physical_plan();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_java_executor;
        break;
      }

      // optional bool java_executor = 4 [default = true];
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_java_executor:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &java_executor_)));
          set_has_java_executor();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_distributed_cache;
        break;
      }

      // optional bool distributed_cache = 5 [default = true];
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_distributed_cache:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &distributed_cache_)));
          set_has_distributed_cache();
        } 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 Roles::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional bool sql_query = 1 [default = true];
  if (has_sql_query()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->sql_query(), output);
  }

  // optional bool logical_plan = 2 [default = true];
  if (has_logical_plan()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->logical_plan(), output);
  }

  // optional bool physical_plan = 3 [default = true];
  if (has_physical_plan()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->physical_plan(), output);
  }

  // optional bool java_executor = 4 [default = true];
  if (has_java_executor()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->java_executor(), output);
  }

  // optional bool distributed_cache = 5 [default = true];
  if (has_distributed_cache()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->distributed_cache(), output);
  }

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

::google::protobuf::uint8* Roles::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional bool sql_query = 1 [default = true];
  if (has_sql_query()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->sql_query(), target);
  }

  // optional bool logical_plan = 2 [default = true];
  if (has_logical_plan()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->logical_plan(), target);
  }

  // optional bool physical_plan = 3 [default = true];
  if (has_physical_plan()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->physical_plan(), target);
  }

  // optional bool java_executor = 4 [default = true];
  if (has_java_executor()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->java_executor(), target);
  }

  // optional bool distributed_cache = 5 [default = true];
  if (has_distributed_cache()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->distributed_cache(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bool sql_query = 1 [default = true];
    if (has_sql_query()) {
      total_size += 1 + 1;
    }

    // optional bool logical_plan = 2 [default = true];
    if (has_logical_plan()) {
      total_size += 1 + 1;
    }

    // optional bool physical_plan = 3 [default = true];
    if (has_physical_plan()) {
      total_size += 1 + 1;
    }

    // optional bool java_executor = 4 [default = true];
    if (has_java_executor()) {
      total_size += 1 + 1;
    }

    // optional bool distributed_cache = 5 [default = true];
    if (has_distributed_cache()) {
      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 Roles::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Roles* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Roles*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Roles::MergeFrom(const Roles& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_sql_query()) {
      set_sql_query(from.sql_query());
    }
    if (from.has_logical_plan()) {
      set_logical_plan(from.logical_plan());
    }
    if (from.has_physical_plan()) {
      set_physical_plan(from.physical_plan());
    }
    if (from.has_java_executor()) {
      set_java_executor(from.java_executor());
    }
    if (from.has_distributed_cache()) {
      set_distributed_cache(from.distributed_cache());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool Roles::IsInitialized() const {

  return true;
}

void Roles::Swap(Roles* other) {
  if (other != this) {
    std::swap(sql_query_, other->sql_query_);
    std::swap(logical_plan_, other->logical_plan_);
    std::swap(physical_plan_, other->physical_plan_);
    std::swap(java_executor_, other->java_executor_);
    std::swap(distributed_cache_, other->distributed_cache_);
    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 Roles::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Roles_descriptor_;
  metadata.reflection = Roles_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace exec

// @@protoc_insertion_point(global_scope)
