BitControl.pb.h

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

#ifndef PROTOBUF_INCLUDED_BitControl_2eproto
#define PROTOBUF_INCLUDED_BitControl_2eproto

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3006001
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "ExecutionProtos.pb.h"
#include "Coordination.pb.h"
#include "UserBitShared.pb.h"
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_BitControl_2eproto 

namespace protobuf_BitControl_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[10];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_BitControl_2eproto
namespace exec {
namespace bit {
namespace control {
class BitControlHandshake;
class BitControlHandshakeDefaultTypeInternal;
extern BitControlHandshakeDefaultTypeInternal _BitControlHandshake_default_instance_;
class BitStatus;
class BitStatusDefaultTypeInternal;
extern BitStatusDefaultTypeInternal _BitStatus_default_instance_;
class Collector;
class CollectorDefaultTypeInternal;
extern CollectorDefaultTypeInternal _Collector_default_instance_;
class CustomMessage;
class CustomMessageDefaultTypeInternal;
extern CustomMessageDefaultTypeInternal _CustomMessage_default_instance_;
class FinishedReceiver;
class FinishedReceiverDefaultTypeInternal;
extern FinishedReceiverDefaultTypeInternal _FinishedReceiver_default_instance_;
class FragmentStatus;
class FragmentStatusDefaultTypeInternal;
extern FragmentStatusDefaultTypeInternal _FragmentStatus_default_instance_;
class InitializeFragments;
class InitializeFragmentsDefaultTypeInternal;
extern InitializeFragmentsDefaultTypeInternal _InitializeFragments_default_instance_;
class PlanFragment;
class PlanFragmentDefaultTypeInternal;
extern PlanFragmentDefaultTypeInternal _PlanFragment_default_instance_;
class QueryContextInformation;
class QueryContextInformationDefaultTypeInternal;
extern QueryContextInformationDefaultTypeInternal _QueryContextInformation_default_instance_;
class WorkQueueStatus;
class WorkQueueStatusDefaultTypeInternal;
extern WorkQueueStatusDefaultTypeInternal _WorkQueueStatus_default_instance_;
}  // namespace control
}  // namespace bit
}  // namespace exec
namespace google {
namespace protobuf {
template<> ::exec::bit::control::BitControlHandshake* Arena::CreateMaybeMessage<::exec::bit::control::BitControlHandshake>(Arena*);
template<> ::exec::bit::control::BitStatus* Arena::CreateMaybeMessage<::exec::bit::control::BitStatus>(Arena*);
template<> ::exec::bit::control::Collector* Arena::CreateMaybeMessage<::exec::bit::control::Collector>(Arena*);
template<> ::exec::bit::control::CustomMessage* Arena::CreateMaybeMessage<::exec::bit::control::CustomMessage>(Arena*);
template<> ::exec::bit::control::FinishedReceiver* Arena::CreateMaybeMessage<::exec::bit::control::FinishedReceiver>(Arena*);
template<> ::exec::bit::control::FragmentStatus* Arena::CreateMaybeMessage<::exec::bit::control::FragmentStatus>(Arena*);
template<> ::exec::bit::control::InitializeFragments* Arena::CreateMaybeMessage<::exec::bit::control::InitializeFragments>(Arena*);
template<> ::exec::bit::control::PlanFragment* Arena::CreateMaybeMessage<::exec::bit::control::PlanFragment>(Arena*);
template<> ::exec::bit::control::QueryContextInformation* Arena::CreateMaybeMessage<::exec::bit::control::QueryContextInformation>(Arena*);
template<> ::exec::bit::control::WorkQueueStatus* Arena::CreateMaybeMessage<::exec::bit::control::WorkQueueStatus>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace exec {
namespace bit {
namespace control {

enum RpcType {
  HANDSHAKE = 0,
  ACK = 1,
  GOODBYE = 2,
  REQ_INITIALIZE_FRAGMENTS = 3,
  REQ_CANCEL_FRAGMENT = 6,
  REQ_RECEIVER_FINISHED = 7,
  REQ_FRAGMENT_STATUS = 8,
  REQ_BIT_STATUS = 9,
  REQ_QUERY_STATUS = 10,
  REQ_QUERY_CANCEL = 15,
  REQ_UNPAUSE_FRAGMENT = 16,
  REQ_CUSTOM = 17,
  RESP_FRAGMENT_HANDLE = 11,
  RESP_FRAGMENT_STATUS = 12,
  RESP_BIT_STATUS = 13,
  RESP_QUERY_STATUS = 14,
  RESP_CUSTOM = 18,
  SASL_MESSAGE = 19
};
bool RpcType_IsValid(int value);
const RpcType RpcType_MIN = HANDSHAKE;
const RpcType RpcType_MAX = SASL_MESSAGE;
const int RpcType_ARRAYSIZE = RpcType_MAX + 1;

const ::google::protobuf::EnumDescriptor* RpcType_descriptor();
inline const ::std::string& RpcType_Name(RpcType value) {
  return ::google::protobuf::internal::NameOfEnum(
    RpcType_descriptor(), value);
}
inline bool RpcType_Parse(
    const ::std::string& name, RpcType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<RpcType>(
    RpcType_descriptor(), name, value);
}
// ===================================================================

class BitControlHandshake : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exec.bit.control.BitControlHandshake) */ {
 public:
  BitControlHandshake();
  virtual ~BitControlHandshake();

  BitControlHandshake(const BitControlHandshake& from);

  inline BitControlHandshake& operator=(const BitControlHandshake& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  BitControlHandshake(BitControlHandshake&& from) noexcept
    : BitControlHandshake() {
    *this = ::std::move(from);
  }

  inline BitControlHandshake& operator=(BitControlHandshake&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BitControlHandshake& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BitControlHandshake* internal_default_instance() {
    return reinterpret_cast<const BitControlHandshake*>(
               &_BitControlHandshake_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  void Swap(BitControlHandshake* other);
  friend void swap(BitControlHandshake& a, BitControlHandshake& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline BitControlHandshake* New() const final {
    return CreateMaybeMessage<BitControlHandshake>(NULL);
  }

  BitControlHandshake* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<BitControlHandshake>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const BitControlHandshake& from);
  void MergeFrom(const BitControlHandshake& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BitControlHandshake* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated string authenticationMechanisms = 4;
  int authenticationmechanisms_size() const;
  void clear_authenticationmechanisms();
  static const int kAuthenticationMechanismsFieldNumber = 4;
  const ::std::string& authenticationmechanisms(int index) const;
  ::std::string* mutable_authenticationmechanisms(int index);
  void set_authenticationmechanisms(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_authenticationmechanisms(int index, ::std::string&& value);
  #endif
  void set_authenticationmechanisms(int index, const char* value);
  void set_authenticationmechanisms(int index, const char* value, size_t size);
  ::std::string* add_authenticationmechanisms();
  void add_authenticationmechanisms(const ::std::string& value);
  #if LANG_CXX11
  void add_authenticationmechanisms(::std::string&& value);
  #endif
  void add_authenticationmechanisms(const char* value);
  void add_authenticationmechanisms(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& authenticationmechanisms() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_authenticationmechanisms();

  // optional .exec.DrillbitEndpoint endpoint = 3;
  bool has_endpoint() const;
  void clear_endpoint();
  static const int kEndpointFieldNumber = 3;
  private:
  const ::exec::DrillbitEndpoint& _internal_endpoint() const;
  public:
  const ::exec::DrillbitEndpoint& endpoint() const;
  ::exec::DrillbitEndpoint* release_endpoint();
  ::exec::DrillbitEndpoint* mutable_endpoint();
  void set_allocated_endpoint(::exec::DrillbitEndpoint* endpoint);

  // optional int32 rpc_version = 1;
  bool has_rpc_version() const;
  void clear_rpc_version();
  static const int kRpcVersionFieldNumber = 1;
  ::google::protobuf::int32 rpc_version() const;
  void set_rpc_version(::google::protobuf::int32 value);

  // optional .exec.shared.RpcChannel channel = 2 [default = BIT_CONTROL];
  bool has_channel() const;
  void clear_channel();
  static const int kChannelFieldNumber = 2;
  ::exec::shared::RpcChannel channel() const;
  void set_channel(::exec::shared::RpcChannel value);

  // @@protoc_insertion_point(class_scope:exec.bit.control.BitControlHandshake)
 private:
  void set_has_rpc_version();
  void clear_has_rpc_version();
  void set_has_channel();
  void clear_has_channel();
  void set_has_endpoint();
  void clear_has_endpoint();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::std::string> authenticationmechanisms_;
  ::exec::DrillbitEndpoint* endpoint_;
  ::google::protobuf::int32 rpc_version_;
  int channel_;
  friend struct ::protobuf_BitControl_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class BitStatus : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exec.bit.control.BitStatus) */ {
 public:
  BitStatus();
  virtual ~BitStatus();

  BitStatus(const BitStatus& from);

  inline BitStatus& operator=(const BitStatus& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  BitStatus(BitStatus&& from) noexcept
    : BitStatus() {
    *this = ::std::move(from);
  }

  inline BitStatus& operator=(BitStatus&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BitStatus& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BitStatus* internal_default_instance() {
    return reinterpret_cast<const BitStatus*>(
               &_BitStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  void Swap(BitStatus* other);
  friend void swap(BitStatus& a, BitStatus& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline BitStatus* New() const final {
    return CreateMaybeMessage<BitStatus>(NULL);
  }

  BitStatus* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<BitStatus>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const BitStatus& from);
  void MergeFrom(const BitStatus& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BitStatus* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .exec.bit.control.FragmentStatus fragment_status = 1;
  int fragment_status_size() const;
  void clear_fragment_status();
  static const int kFragmentStatusFieldNumber = 1;
  ::exec::bit::control::FragmentStatus* mutable_fragment_status(int index);
  ::google::protobuf::RepeatedPtrField< ::exec::bit::control::FragmentStatus >*
      mutable_fragment_status();
  const ::exec::bit::control::FragmentStatus& fragment_status(int index) const;
  ::exec::bit::control::FragmentStatus* add_fragment_status();
  const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::FragmentStatus >&
      fragment_status() const;

  // @@protoc_insertion_point(class_scope:exec.bit.control.BitStatus)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::exec::bit::control::FragmentStatus > fragment_status_;
  friend struct ::protobuf_BitControl_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class FragmentStatus : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exec.bit.control.FragmentStatus) */ {
 public:
  FragmentStatus();
  virtual ~FragmentStatus();

  FragmentStatus(const FragmentStatus& from);

  inline FragmentStatus& operator=(const FragmentStatus& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  FragmentStatus(FragmentStatus&& from) noexcept
    : FragmentStatus() {
    *this = ::std::move(from);
  }

  inline FragmentStatus& operator=(FragmentStatus&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const FragmentStatus& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const FragmentStatus* internal_default_instance() {
    return reinterpret_cast<const FragmentStatus*>(
               &_FragmentStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  void Swap(FragmentStatus* other);
  friend void swap(FragmentStatus& a, FragmentStatus& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline FragmentStatus* New() const final {
    return CreateMaybeMessage<FragmentStatus>(NULL);
  }

  FragmentStatus* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<FragmentStatus>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const FragmentStatus& from);
  void MergeFrom(const FragmentStatus& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FragmentStatus* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.shared.MinorFragmentProfile profile = 1;
  bool has_profile() const;
  void clear_profile();
  static const int kProfileFieldNumber = 1;
  private:
  const ::exec::shared::MinorFragmentProfile& _internal_profile() const;
  public:
  const ::exec::shared::MinorFragmentProfile& profile() const;
  ::exec::shared::MinorFragmentProfile* release_profile();
  ::exec::shared::MinorFragmentProfile* mutable_profile();
  void set_allocated_profile(::exec::shared::MinorFragmentProfile* profile);

  // optional .exec.bit.FragmentHandle handle = 2;
  bool has_handle() const;
  void clear_handle();
  static const int kHandleFieldNumber = 2;
  private:
  const ::exec::bit::FragmentHandle& _internal_handle() const;
  public:
  const ::exec::bit::FragmentHandle& handle() const;
  ::exec::bit::FragmentHandle* release_handle();
  ::exec::bit::FragmentHandle* mutable_handle();
  void set_allocated_handle(::exec::bit::FragmentHandle* handle);

  // @@protoc_insertion_point(class_scope:exec.bit.control.FragmentStatus)
 private:
  void set_has_profile();
  void clear_has_profile();
  void set_has_handle();
  void clear_has_handle();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::exec::shared::MinorFragmentProfile* profile_;
  ::exec::bit::FragmentHandle* handle_;
  friend struct ::protobuf_BitControl_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class InitializeFragments : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exec.bit.control.InitializeFragments) */ {
 public:
  InitializeFragments();
  virtual ~InitializeFragments();

  InitializeFragments(const InitializeFragments& from);

  inline InitializeFragments& operator=(const InitializeFragments& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  InitializeFragments(InitializeFragments&& from) noexcept
    : InitializeFragments() {
    *this = ::std::move(from);
  }

  inline InitializeFragments& operator=(InitializeFragments&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const InitializeFragments& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const InitializeFragments* internal_default_instance() {
    return reinterpret_cast<const InitializeFragments*>(
               &_InitializeFragments_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  void Swap(InitializeFragments* other);
  friend void swap(InitializeFragments& a, InitializeFragments& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline InitializeFragments* New() const final {
    return CreateMaybeMessage<InitializeFragments>(NULL);
  }

  InitializeFragments* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<InitializeFragments>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const InitializeFragments& from);
  void MergeFrom(const InitializeFragments& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InitializeFragments* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .exec.bit.control.PlanFragment fragment = 1;
  int fragment_size() const;
  void clear_fragment();
  static const int kFragmentFieldNumber = 1;
  ::exec::bit::control::PlanFragment* mutable_fragment(int index);
  ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >*
      mutable_fragment();
  const ::exec::bit::control::PlanFragment& fragment(int index) const;
  ::exec::bit::control::PlanFragment* add_fragment();
  const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >&
      fragment() const;

  // @@protoc_insertion_point(class_scope:exec.bit.control.InitializeFragments)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment > fragment_;
  friend struct ::protobuf_BitControl_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class CustomMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exec.bit.control.CustomMessage) */ {
 public:
  CustomMessage();
  virtual ~CustomMessage();

  CustomMessage(const CustomMessage& from);

  inline CustomMessage& operator=(const CustomMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  CustomMessage(CustomMessage&& from) noexcept
    : CustomMessage() {
    *this = ::std::move(from);
  }

  inline CustomMessage& operator=(CustomMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const CustomMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CustomMessage* internal_default_instance() {
    return reinterpret_cast<const CustomMessage*>(
               &_CustomMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  void Swap(CustomMessage* other);
  friend void swap(CustomMessage& a, CustomMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline CustomMessage* New() const final {
    return CreateMaybeMessage<CustomMessage>(NULL);
  }

  CustomMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<CustomMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const CustomMessage& from);
  void MergeFrom(const CustomMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CustomMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes message = 2;
  bool has_message() const;
  void clear_message();
  static const int kMessageFieldNumber = 2;
  const ::std::string& message() const;
  void set_message(const ::std::string& value);
  #if LANG_CXX11
  void set_message(::std::string&& value);
  #endif
  void set_message(const char* value);
  void set_message(const void* value, size_t size);
  ::std::string* mutable_message();
  ::std::string* release_message();
  void set_allocated_message(::std::string* message);

  // optional int32 type = 1;
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 1;
  ::google::protobuf::int32 type() const;
  void set_type(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:exec.bit.control.CustomMessage)
 private:
  void set_has_type();
  void clear_has_type();
  void set_has_message();
  void clear_has_message();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr message_;
  ::google::protobuf::int32 type_;
  friend struct ::protobuf_BitControl_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class PlanFragment : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exec.bit.control.PlanFragment) */ {
 public:
  PlanFragment();
  virtual ~PlanFragment();

  PlanFragment(const PlanFragment& from);

  inline PlanFragment& operator=(const PlanFragment& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  PlanFragment(PlanFragment&& from) noexcept
    : PlanFragment() {
    *this = ::std::move(from);
  }

  inline PlanFragment& operator=(PlanFragment&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const PlanFragment& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PlanFragment* internal_default_instance() {
    return reinterpret_cast<const PlanFragment*>(
               &_PlanFragment_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  void Swap(PlanFragment* other);
  friend void swap(PlanFragment& a, PlanFragment& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline PlanFragment* New() const final {
    return CreateMaybeMessage<PlanFragment>(NULL);
  }

  PlanFragment* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<PlanFragment>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const PlanFragment& from);
  void MergeFrom(const PlanFragment& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PlanFragment* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .exec.bit.control.Collector collector = 17;
  int collector_size() const;
  void clear_collector();
  static const int kCollectorFieldNumber = 17;
  ::exec::bit::control::Collector* mutable_collector(int index);
  ::google::protobuf::RepeatedPtrField< ::exec::bit::control::Collector >*
      mutable_collector();
  const ::exec::bit::control::Collector& collector(int index) const;
  ::exec::bit::control::Collector* add_collector();
  const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::Collector >&
      collector() const;

  // optional string fragment_json = 8;
  bool has_fragment_json() const;
  void clear_fragment_json();
  static const int kFragmentJsonFieldNumber = 8;
  const ::std::string& fragment_json() const;
  void set_fragment_json(const ::std::string& value);
  #if LANG_CXX11
  void set_fragment_json(::std::string&& value);
  #endif
  void set_fragment_json(const char* value);
  void set_fragment_json(const char* value, size_t size);
  ::std::string* mutable_fragment_json();
  ::std::string* release_fragment_json();
  void set_allocated_fragment_json(::std::string* fragment_json);

  // optional string options_json = 15;
  bool has_options_json() const;
  void clear_options_json();
  static const int kOptionsJsonFieldNumber = 15;
  const ::std::string& options_json() const;
  void set_options_json(const ::std::string& value);
  #if LANG_CXX11
  void set_options_json(::std::string&& value);
  #endif
  void set_options_json(const char* value);
  void set_options_json(const char* value, size_t size);
  ::std::string* mutable_options_json();
  ::std::string* release_options_json();
  void set_allocated_options_json(::std::string* options_json);

  // optional string assignedEndpointUUID = 18;
  bool has_assignedendpointuuid() const;
  void clear_assignedendpointuuid();
  static const int kAssignedEndpointUUIDFieldNumber = 18;
  const ::std::string& assignedendpointuuid() const;
  void set_assignedendpointuuid(const ::std::string& value);
  #if LANG_CXX11
  void set_assignedendpointuuid(::std::string&& value);
  #endif
  void set_assignedendpointuuid(const char* value);
  void set_assignedendpointuuid(const char* value, size_t size);
  ::std::string* mutable_assignedendpointuuid();
  ::std::string* release_assignedendpointuuid();
  void set_allocated_assignedendpointuuid(::std::string* assignedendpointuuid);

  // optional .exec.bit.FragmentHandle handle = 1;
  bool has_handle() const;
  void clear_handle();
  static const int kHandleFieldNumber = 1;
  private:
  const ::exec::bit::FragmentHandle& _internal_handle() const;
  public:
  const ::exec::bit::FragmentHandle& handle() const;
  ::exec::bit::FragmentHandle* release_handle();
  ::exec::bit::FragmentHandle* mutable_handle();
  void set_allocated_handle(::exec::bit::FragmentHandle* handle);

  // optional .exec.DrillbitEndpoint assignment = 10;
  bool has_assignment() const;
  void clear_assignment();
  static const int kAssignmentFieldNumber = 10;
  private:
  const ::exec::DrillbitEndpoint& _internal_assignment() const;
  public:
  const ::exec::DrillbitEndpoint& assignment() const;
  ::exec::DrillbitEndpoint* release_assignment();
  ::exec::DrillbitEndpoint* mutable_assignment();
  void set_allocated_assignment(::exec::DrillbitEndpoint* assignment);

  // optional .exec.DrillbitEndpoint foreman = 11;
  bool has_foreman() const;
  void clear_foreman();
  static const int kForemanFieldNumber = 11;
  private:
  const ::exec::DrillbitEndpoint& _internal_foreman() const;
  public:
  const ::exec::DrillbitEndpoint& foreman() const;
  ::exec::DrillbitEndpoint* release_foreman();
  ::exec::DrillbitEndpoint* mutable_foreman();
  void set_allocated_foreman(::exec::DrillbitEndpoint* foreman);

  // optional .exec.shared.UserCredentials credentials = 14;
  bool has_credentials() const;
  void clear_credentials();
  static const int kCredentialsFieldNumber = 14;
  private:
  const ::exec::shared::UserCredentials& _internal_credentials() const;
  public:
  const ::exec::shared::UserCredentials& credentials() const;
  ::exec::shared::UserCredentials* release_credentials();
  ::exec::shared::UserCredentials* mutable_credentials();
  void set_allocated_credentials(::exec::shared::UserCredentials* credentials);

  // optional .exec.bit.control.QueryContextInformation context = 16;
  bool has_context() const;
  void clear_context();
  static const int kContextFieldNumber = 16;
  private:
  const ::exec::bit::control::QueryContextInformation& _internal_context() const;
  public:
  const ::exec::bit::control::QueryContextInformation& context() const;
  ::exec::bit::control::QueryContextInformation* release_context();
  ::exec::bit::control::QueryContextInformation* mutable_context();
  void set_allocated_context(::exec::bit::control::QueryContextInformation* context);

  // optional float network_cost = 4;
  bool has_network_cost() const;
  void clear_network_cost();
  static const int kNetworkCostFieldNumber = 4;
  float network_cost() const;
  void set_network_cost(float value);

  // optional float cpu_cost = 5;
  bool has_cpu_cost() const;
  void clear_cpu_cost();
  static const int kCpuCostFieldNumber = 5;
  float cpu_cost() const;
  void set_cpu_cost(float value);

  // optional float disk_cost = 6;
  bool has_disk_cost() const;
  void clear_disk_cost();
  static const int kDiskCostFieldNumber = 6;
  float disk_cost() const;
  void set_disk_cost(float value);

  // optional float memory_cost = 7;
  bool has_memory_cost() const;
  void clear_memory_cost();
  static const int kMemoryCostFieldNumber = 7;
  float memory_cost() const;
  void set_memory_cost(float value);

  // optional bool leaf_fragment = 9;
  bool has_leaf_fragment() const;
  void clear_leaf_fragment();
  static const int kLeafFragmentFieldNumber = 9;
  bool leaf_fragment() const;
  void set_leaf_fragment(bool value);

  // optional int64 mem_initial = 12 [default = 20000000];
  bool has_mem_initial() const;
  void clear_mem_initial();
  static const int kMemInitialFieldNumber = 12;
  ::google::protobuf::int64 mem_initial() const;
  void set_mem_initial(::google::protobuf::int64 value);

  // optional int64 mem_max = 13 [default = 2000000000];
  bool has_mem_max() const;
  void clear_mem_max();
  static const int kMemMaxFieldNumber = 13;
  ::google::protobuf::int64 mem_max() const;
  void set_mem_max(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:exec.bit.control.PlanFragment)
 private:
  void set_has_handle();
  void clear_has_handle();
  void set_has_network_cost();
  void clear_has_network_cost();
  void set_has_cpu_cost();
  void clear_has_cpu_cost();
  void set_has_disk_cost();
  void clear_has_disk_cost();
  void set_has_memory_cost();
  void clear_has_memory_cost();
  void set_has_fragment_json();
  void clear_has_fragment_json();
  void set_has_leaf_fragment();
  void clear_has_leaf_fragment();
  void set_has_assignment();
  void clear_has_assignment();
  void set_has_foreman();
  void clear_has_foreman();
  void set_has_mem_initial();
  void clear_has_mem_initial();
  void set_has_mem_max();
  void clear_has_mem_max();
  void set_has_credentials();
  void clear_has_credentials();
  void set_has_options_json();
  void clear_has_options_json();
  void set_has_context();
  void clear_has_context();
  void set_has_assignedendpointuuid();
  void clear_has_assignedendpointuuid();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::exec::bit::control::Collector > collector_;
  ::google::protobuf::internal::ArenaStringPtr fragment_json_;
  ::google::protobuf::internal::ArenaStringPtr options_json_;
  ::google::protobuf::internal::ArenaStringPtr assignedendpointuuid_;
  ::exec::bit::FragmentHandle* handle_;
  ::exec::DrillbitEndpoint* assignment_;
  ::exec::DrillbitEndpoint* foreman_;
  ::exec::shared::UserCredentials* credentials_;
  ::exec::bit::control::QueryContextInformation* context_;
  float network_cost_;
  float cpu_cost_;
  float disk_cost_;
  float memory_cost_;
  bool leaf_fragment_;
  ::google::protobuf::int64 mem_initial_;
  ::google::protobuf::int64 mem_max_;
  friend struct ::protobuf_BitControl_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Collector : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exec.bit.control.Collector) */ {
 public:
  Collector();
  virtual ~Collector();

  Collector(const Collector& from);

  inline Collector& operator=(const Collector& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Collector(Collector&& from) noexcept
    : Collector() {
    *this = ::std::move(from);
  }

  inline Collector& operator=(Collector&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Collector& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Collector* internal_default_instance() {
    return reinterpret_cast<const Collector*>(
               &_Collector_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  void Swap(Collector* other);
  friend void swap(Collector& a, Collector& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline Collector* New() const final {
    return CreateMaybeMessage<Collector>(NULL);
  }

  Collector* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Collector>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const Collector& from);
  void MergeFrom(const Collector& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Collector* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 incoming_minor_fragment = 2 [packed = true];
  int incoming_minor_fragment_size() const;
  void clear_incoming_minor_fragment();
  static const int kIncomingMinorFragmentFieldNumber = 2;
  ::google::protobuf::int32 incoming_minor_fragment(int index) const;
  void set_incoming_minor_fragment(int index, ::google::protobuf::int32 value);
  void add_incoming_minor_fragment(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      incoming_minor_fragment() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_incoming_minor_fragment();

  // optional int32 opposite_major_fragment_id = 1;
  bool has_opposite_major_fragment_id() const;
  void clear_opposite_major_fragment_id();
  static const int kOppositeMajorFragmentIdFieldNumber = 1;
  ::google::protobuf::int32 opposite_major_fragment_id() const;
  void set_opposite_major_fragment_id(::google::protobuf::int32 value);

  // optional bool supports_out_of_order = 3;
  bool has_supports_out_of_order() const;
  void clear_supports_out_of_order();
  static const int kSupportsOutOfOrderFieldNumber = 3;
  bool supports_out_of_order() const;
  void set_supports_out_of_order(bool value);

  // optional bool is_spooling = 4;
  bool has_is_spooling() const;
  void clear_is_spooling();
  static const int kIsSpoolingFieldNumber = 4;
  bool is_spooling() const;
  void set_is_spooling(bool value);

  // @@protoc_insertion_point(class_scope:exec.bit.control.Collector)
 private:
  void set_has_opposite_major_fragment_id();
  void clear_has_opposite_major_fragment_id();
  void set_has_supports_out_of_order();
  void clear_has_supports_out_of_order();
  void set_has_is_spooling();
  void clear_has_is_spooling();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > incoming_minor_fragment_;
  mutable int _incoming_minor_fragment_cached_byte_size_;
  ::google::protobuf::int32 opposite_major_fragment_id_;
  bool supports_out_of_order_;
  bool is_spooling_;
  friend struct ::protobuf_BitControl_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class QueryContextInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exec.bit.control.QueryContextInformation) */ {
 public:
  QueryContextInformation();
  virtual ~QueryContextInformation();

  QueryContextInformation(const QueryContextInformation& from);

  inline QueryContextInformation& operator=(const QueryContextInformation& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  QueryContextInformation(QueryContextInformation&& from) noexcept
    : QueryContextInformation() {
    *this = ::std::move(from);
  }

  inline QueryContextInformation& operator=(QueryContextInformation&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const QueryContextInformation& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const QueryContextInformation* internal_default_instance() {
    return reinterpret_cast<const QueryContextInformation*>(
               &_QueryContextInformation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  void Swap(QueryContextInformation* other);
  friend void swap(QueryContextInformation& a, QueryContextInformation& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline QueryContextInformation* New() const final {
    return CreateMaybeMessage<QueryContextInformation>(NULL);
  }

  QueryContextInformation* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<QueryContextInformation>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const QueryContextInformation& from);
  void MergeFrom(const QueryContextInformation& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(QueryContextInformation* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string default_schema_name = 3;
  bool has_default_schema_name() const;
  void clear_default_schema_name();
  static const int kDefaultSchemaNameFieldNumber = 3;
  const ::std::string& default_schema_name() const;
  void set_default_schema_name(const ::std::string& value);
  #if LANG_CXX11
  void set_default_schema_name(::std::string&& value);
  #endif
  void set_default_schema_name(const char* value);
  void set_default_schema_name(const char* value, size_t size);
  ::std::string* mutable_default_schema_name();
  ::std::string* release_default_schema_name();
  void set_allocated_default_schema_name(::std::string* default_schema_name);

  // optional string session_id = 4;
  bool has_session_id() const;
  void clear_session_id();
  static const int kSessionIdFieldNumber = 4;
  const ::std::string& session_id() const;
  void set_session_id(const ::std::string& value);
  #if LANG_CXX11
  void set_session_id(::std::string&& value);
  #endif
  void set_session_id(const char* value);
  void set_session_id(const char* value, size_t size);
  ::std::string* mutable_session_id();
  ::std::string* release_session_id();
  void set_allocated_session_id(::std::string* session_id);

  // optional int64 query_start_time = 1;
  bool has_query_start_time() const;
  void clear_query_start_time();
  static const int kQueryStartTimeFieldNumber = 1;
  ::google::protobuf::int64 query_start_time() const;
  void set_query_start_time(::google::protobuf::int64 value);

  // optional int32 time_zone = 2;
  bool has_time_zone() const;
  void clear_time_zone();
  static const int kTimeZoneFieldNumber = 2;
  ::google::protobuf::int32 time_zone() const;
  void set_time_zone(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:exec.bit.control.QueryContextInformation)
 private:
  void set_has_query_start_time();
  void clear_has_query_start_time();
  void set_has_time_zone();
  void clear_has_time_zone();
  void set_has_default_schema_name();
  void clear_has_default_schema_name();
  void set_has_session_id();
  void clear_has_session_id();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr default_schema_name_;
  ::google::protobuf::internal::ArenaStringPtr session_id_;
  ::google::protobuf::int64 query_start_time_;
  ::google::protobuf::int32 time_zone_;
  friend struct ::protobuf_BitControl_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class WorkQueueStatus : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exec.bit.control.WorkQueueStatus) */ {
 public:
  WorkQueueStatus();
  virtual ~WorkQueueStatus();

  WorkQueueStatus(const WorkQueueStatus& from);

  inline WorkQueueStatus& operator=(const WorkQueueStatus& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  WorkQueueStatus(WorkQueueStatus&& from) noexcept
    : WorkQueueStatus() {
    *this = ::std::move(from);
  }

  inline WorkQueueStatus& operator=(WorkQueueStatus&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const WorkQueueStatus& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const WorkQueueStatus* internal_default_instance() {
    return reinterpret_cast<const WorkQueueStatus*>(
               &_WorkQueueStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  void Swap(WorkQueueStatus* other);
  friend void swap(WorkQueueStatus& a, WorkQueueStatus& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline WorkQueueStatus* New() const final {
    return CreateMaybeMessage<WorkQueueStatus>(NULL);
  }

  WorkQueueStatus* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<WorkQueueStatus>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const WorkQueueStatus& from);
  void MergeFrom(const WorkQueueStatus& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WorkQueueStatus* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.DrillbitEndpoint endpoint = 1;
  bool has_endpoint() const;
  void clear_endpoint();
  static const int kEndpointFieldNumber = 1;
  private:
  const ::exec::DrillbitEndpoint& _internal_endpoint() const;
  public:
  const ::exec::DrillbitEndpoint& endpoint() const;
  ::exec::DrillbitEndpoint* release_endpoint();
  ::exec::DrillbitEndpoint* mutable_endpoint();
  void set_allocated_endpoint(::exec::DrillbitEndpoint* endpoint);

  // optional int64 report_time = 3;
  bool has_report_time() const;
  void clear_report_time();
  static const int kReportTimeFieldNumber = 3;
  ::google::protobuf::int64 report_time() const;
  void set_report_time(::google::protobuf::int64 value);

  // optional int32 queue_length = 2;
  bool has_queue_length() const;
  void clear_queue_length();
  static const int kQueueLengthFieldNumber = 2;
  ::google::protobuf::int32 queue_length() const;
  void set_queue_length(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:exec.bit.control.WorkQueueStatus)
 private:
  void set_has_endpoint();
  void clear_has_endpoint();
  void set_has_queue_length();
  void clear_has_queue_length();
  void set_has_report_time();
  void clear_has_report_time();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::exec::DrillbitEndpoint* endpoint_;
  ::google::protobuf::int64 report_time_;
  ::google::protobuf::int32 queue_length_;
  friend struct ::protobuf_BitControl_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class FinishedReceiver : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:exec.bit.control.FinishedReceiver) */ {
 public:
  FinishedReceiver();
  virtual ~FinishedReceiver();

  FinishedReceiver(const FinishedReceiver& from);

  inline FinishedReceiver& operator=(const FinishedReceiver& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  FinishedReceiver(FinishedReceiver&& from) noexcept
    : FinishedReceiver() {
    *this = ::std::move(from);
  }

  inline FinishedReceiver& operator=(FinishedReceiver&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const FinishedReceiver& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const FinishedReceiver* internal_default_instance() {
    return reinterpret_cast<const FinishedReceiver*>(
               &_FinishedReceiver_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  void Swap(FinishedReceiver* other);
  friend void swap(FinishedReceiver& a, FinishedReceiver& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline FinishedReceiver* New() const final {
    return CreateMaybeMessage<FinishedReceiver>(NULL);
  }

  FinishedReceiver* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<FinishedReceiver>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const FinishedReceiver& from);
  void MergeFrom(const FinishedReceiver& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FinishedReceiver* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .exec.bit.FragmentHandle receiver = 1;
  bool has_receiver() const;
  void clear_receiver();
  static const int kReceiverFieldNumber = 1;
  private:
  const ::exec::bit::FragmentHandle& _internal_receiver() const;
  public:
  const ::exec::bit::FragmentHandle& receiver() const;
  ::exec::bit::FragmentHandle* release_receiver();
  ::exec::bit::FragmentHandle* mutable_receiver();
  void set_allocated_receiver(::exec::bit::FragmentHandle* receiver);

  // optional .exec.bit.FragmentHandle sender = 2;
  bool has_sender() const;
  void clear_sender();
  static const int kSenderFieldNumber = 2;
  private:
  const ::exec::bit::FragmentHandle& _internal_sender() const;
  public:
  const ::exec::bit::FragmentHandle& sender() const;
  ::exec::bit::FragmentHandle* release_sender();
  ::exec::bit::FragmentHandle* mutable_sender();
  void set_allocated_sender(::exec::bit::FragmentHandle* sender);

  // @@protoc_insertion_point(class_scope:exec.bit.control.FinishedReceiver)
 private:
  void set_has_receiver();
  void clear_has_receiver();
  void set_has_sender();
  void clear_has_sender();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::exec::bit::FragmentHandle* receiver_;
  ::exec::bit::FragmentHandle* sender_;
  friend struct ::protobuf_BitControl_2eproto::TableStruct;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// BitControlHandshake

// optional int32 rpc_version = 1;
inline bool BitControlHandshake::has_rpc_version() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BitControlHandshake::set_has_rpc_version() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BitControlHandshake::clear_has_rpc_version() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BitControlHandshake::clear_rpc_version() {
  rpc_version_ = 0;
  clear_has_rpc_version();
}
inline ::google::protobuf::int32 BitControlHandshake::rpc_version() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.BitControlHandshake.rpc_version)
  return rpc_version_;
}
inline void BitControlHandshake::set_rpc_version(::google::protobuf::int32 value) {
  set_has_rpc_version();
  rpc_version_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.BitControlHandshake.rpc_version)
}

// optional .exec.shared.RpcChannel channel = 2 [default = BIT_CONTROL];
inline bool BitControlHandshake::has_channel() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BitControlHandshake::set_has_channel() {
  _has_bits_[0] |= 0x00000004u;
}
inline void BitControlHandshake::clear_has_channel() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void BitControlHandshake::clear_channel() {
  channel_ = 0;
  clear_has_channel();
}
inline ::exec::shared::RpcChannel BitControlHandshake::channel() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.BitControlHandshake.channel)
  return static_cast< ::exec::shared::RpcChannel >(channel_);
}
inline void BitControlHandshake::set_channel(::exec::shared::RpcChannel value) {
  assert(::exec::shared::RpcChannel_IsValid(value));
  set_has_channel();
  channel_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.BitControlHandshake.channel)
}

// optional .exec.DrillbitEndpoint endpoint = 3;
inline bool BitControlHandshake::has_endpoint() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BitControlHandshake::set_has_endpoint() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BitControlHandshake::clear_has_endpoint() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::exec::DrillbitEndpoint& BitControlHandshake::_internal_endpoint() const {
  return *endpoint_;
}
inline const ::exec::DrillbitEndpoint& BitControlHandshake::endpoint() const {
  const ::exec::DrillbitEndpoint* p = endpoint_;
  // @@protoc_insertion_point(field_get:exec.bit.control.BitControlHandshake.endpoint)
  return p != NULL ? *p : *reinterpret_cast<const ::exec::DrillbitEndpoint*>(
      &::exec::_DrillbitEndpoint_default_instance_);
}
inline ::exec::DrillbitEndpoint* BitControlHandshake::release_endpoint() {
  // @@protoc_insertion_point(field_release:exec.bit.control.BitControlHandshake.endpoint)
  clear_has_endpoint();
  ::exec::DrillbitEndpoint* temp = endpoint_;
  endpoint_ = NULL;
  return temp;
}
inline ::exec::DrillbitEndpoint* BitControlHandshake::mutable_endpoint() {
  set_has_endpoint();
  if (endpoint_ == NULL) {
    auto* p = CreateMaybeMessage<::exec::DrillbitEndpoint>(GetArenaNoVirtual());
    endpoint_ = p;
  }
  // @@protoc_insertion_point(field_mutable:exec.bit.control.BitControlHandshake.endpoint)
  return endpoint_;
}
inline void BitControlHandshake::set_allocated_endpoint(::exec::DrillbitEndpoint* endpoint) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(endpoint_);
  }
  if (endpoint) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      endpoint = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, endpoint, submessage_arena);
    }
    set_has_endpoint();
  } else {
    clear_has_endpoint();
  }
  endpoint_ = endpoint;
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.BitControlHandshake.endpoint)
}

// repeated string authenticationMechanisms = 4;
inline int BitControlHandshake::authenticationmechanisms_size() const {
  return authenticationmechanisms_.size();
}
inline void BitControlHandshake::clear_authenticationmechanisms() {
  authenticationmechanisms_.Clear();
}
inline const ::std::string& BitControlHandshake::authenticationmechanisms(int index) const {
  // @@protoc_insertion_point(field_get:exec.bit.control.BitControlHandshake.authenticationMechanisms)
  return authenticationmechanisms_.Get(index);
}
inline ::std::string* BitControlHandshake::mutable_authenticationmechanisms(int index) {
  // @@protoc_insertion_point(field_mutable:exec.bit.control.BitControlHandshake.authenticationMechanisms)
  return authenticationmechanisms_.Mutable(index);
}
inline void BitControlHandshake::set_authenticationmechanisms(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:exec.bit.control.BitControlHandshake.authenticationMechanisms)
  authenticationmechanisms_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void BitControlHandshake::set_authenticationmechanisms(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:exec.bit.control.BitControlHandshake.authenticationMechanisms)
  authenticationmechanisms_.Mutable(index)->assign(std::move(value));
}
#endif
inline void BitControlHandshake::set_authenticationmechanisms(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  authenticationmechanisms_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:exec.bit.control.BitControlHandshake.authenticationMechanisms)
}
inline void BitControlHandshake::set_authenticationmechanisms(int index, const char* value, size_t size) {
  authenticationmechanisms_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:exec.bit.control.BitControlHandshake.authenticationMechanisms)
}
inline ::std::string* BitControlHandshake::add_authenticationmechanisms() {
  // @@protoc_insertion_point(field_add_mutable:exec.bit.control.BitControlHandshake.authenticationMechanisms)
  return authenticationmechanisms_.Add();
}
inline void BitControlHandshake::add_authenticationmechanisms(const ::std::string& value) {
  authenticationmechanisms_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:exec.bit.control.BitControlHandshake.authenticationMechanisms)
}
#if LANG_CXX11
inline void BitControlHandshake::add_authenticationmechanisms(::std::string&& value) {
  authenticationmechanisms_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:exec.bit.control.BitControlHandshake.authenticationMechanisms)
}
#endif
inline void BitControlHandshake::add_authenticationmechanisms(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  authenticationmechanisms_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:exec.bit.control.BitControlHandshake.authenticationMechanisms)
}
inline void BitControlHandshake::add_authenticationmechanisms(const char* value, size_t size) {
  authenticationmechanisms_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:exec.bit.control.BitControlHandshake.authenticationMechanisms)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
BitControlHandshake::authenticationmechanisms() const {
  // @@protoc_insertion_point(field_list:exec.bit.control.BitControlHandshake.authenticationMechanisms)
  return authenticationmechanisms_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
BitControlHandshake::mutable_authenticationmechanisms() {
  // @@protoc_insertion_point(field_mutable_list:exec.bit.control.BitControlHandshake.authenticationMechanisms)
  return &authenticationmechanisms_;
}

// -------------------------------------------------------------------

// BitStatus

// repeated .exec.bit.control.FragmentStatus fragment_status = 1;
inline int BitStatus::fragment_status_size() const {
  return fragment_status_.size();
}
inline void BitStatus::clear_fragment_status() {
  fragment_status_.Clear();
}
inline ::exec::bit::control::FragmentStatus* BitStatus::mutable_fragment_status(int index) {
  // @@protoc_insertion_point(field_mutable:exec.bit.control.BitStatus.fragment_status)
  return fragment_status_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::FragmentStatus >*
BitStatus::mutable_fragment_status() {
  // @@protoc_insertion_point(field_mutable_list:exec.bit.control.BitStatus.fragment_status)
  return &fragment_status_;
}
inline const ::exec::bit::control::FragmentStatus& BitStatus::fragment_status(int index) const {
  // @@protoc_insertion_point(field_get:exec.bit.control.BitStatus.fragment_status)
  return fragment_status_.Get(index);
}
inline ::exec::bit::control::FragmentStatus* BitStatus::add_fragment_status() {
  // @@protoc_insertion_point(field_add:exec.bit.control.BitStatus.fragment_status)
  return fragment_status_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::FragmentStatus >&
BitStatus::fragment_status() const {
  // @@protoc_insertion_point(field_list:exec.bit.control.BitStatus.fragment_status)
  return fragment_status_;
}

// -------------------------------------------------------------------

// FragmentStatus

// optional .exec.shared.MinorFragmentProfile profile = 1;
inline bool FragmentStatus::has_profile() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FragmentStatus::set_has_profile() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FragmentStatus::clear_has_profile() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::exec::shared::MinorFragmentProfile& FragmentStatus::_internal_profile() const {
  return *profile_;
}
inline const ::exec::shared::MinorFragmentProfile& FragmentStatus::profile() const {
  const ::exec::shared::MinorFragmentProfile* p = profile_;
  // @@protoc_insertion_point(field_get:exec.bit.control.FragmentStatus.profile)
  return p != NULL ? *p : *reinterpret_cast<const ::exec::shared::MinorFragmentProfile*>(
      &::exec::shared::_MinorFragmentProfile_default_instance_);
}
inline ::exec::shared::MinorFragmentProfile* FragmentStatus::release_profile() {
  // @@protoc_insertion_point(field_release:exec.bit.control.FragmentStatus.profile)
  clear_has_profile();
  ::exec::shared::MinorFragmentProfile* temp = profile_;
  profile_ = NULL;
  return temp;
}
inline ::exec::shared::MinorFragmentProfile* FragmentStatus::mutable_profile() {
  set_has_profile();
  if (profile_ == NULL) {
    auto* p = CreateMaybeMessage<::exec::shared::MinorFragmentProfile>(GetArenaNoVirtual());
    profile_ = p;
  }
  // @@protoc_insertion_point(field_mutable:exec.bit.control.FragmentStatus.profile)
  return profile_;
}
inline void FragmentStatus::set_allocated_profile(::exec::shared::MinorFragmentProfile* profile) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(profile_);
  }
  if (profile) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      profile = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, profile, submessage_arena);
    }
    set_has_profile();
  } else {
    clear_has_profile();
  }
  profile_ = profile;
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.FragmentStatus.profile)
}

// optional .exec.bit.FragmentHandle handle = 2;
inline bool FragmentStatus::has_handle() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FragmentStatus::set_has_handle() {
  _has_bits_[0] |= 0x00000002u;
}
inline void FragmentStatus::clear_has_handle() {
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::exec::bit::FragmentHandle& FragmentStatus::_internal_handle() const {
  return *handle_;
}
inline const ::exec::bit::FragmentHandle& FragmentStatus::handle() const {
  const ::exec::bit::FragmentHandle* p = handle_;
  // @@protoc_insertion_point(field_get:exec.bit.control.FragmentStatus.handle)
  return p != NULL ? *p : *reinterpret_cast<const ::exec::bit::FragmentHandle*>(
      &::exec::bit::_FragmentHandle_default_instance_);
}
inline ::exec::bit::FragmentHandle* FragmentStatus::release_handle() {
  // @@protoc_insertion_point(field_release:exec.bit.control.FragmentStatus.handle)
  clear_has_handle();
  ::exec::bit::FragmentHandle* temp = handle_;
  handle_ = NULL;
  return temp;
}
inline ::exec::bit::FragmentHandle* FragmentStatus::mutable_handle() {
  set_has_handle();
  if (handle_ == NULL) {
    auto* p = CreateMaybeMessage<::exec::bit::FragmentHandle>(GetArenaNoVirtual());
    handle_ = p;
  }
  // @@protoc_insertion_point(field_mutable:exec.bit.control.FragmentStatus.handle)
  return handle_;
}
inline void FragmentStatus::set_allocated_handle(::exec::bit::FragmentHandle* handle) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(handle_);
  }
  if (handle) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      handle = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, handle, submessage_arena);
    }
    set_has_handle();
  } else {
    clear_has_handle();
  }
  handle_ = handle;
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.FragmentStatus.handle)
}

// -------------------------------------------------------------------

// InitializeFragments

// repeated .exec.bit.control.PlanFragment fragment = 1;
inline int InitializeFragments::fragment_size() const {
  return fragment_.size();
}
inline void InitializeFragments::clear_fragment() {
  fragment_.Clear();
}
inline ::exec::bit::control::PlanFragment* InitializeFragments::mutable_fragment(int index) {
  // @@protoc_insertion_point(field_mutable:exec.bit.control.InitializeFragments.fragment)
  return fragment_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >*
InitializeFragments::mutable_fragment() {
  // @@protoc_insertion_point(field_mutable_list:exec.bit.control.InitializeFragments.fragment)
  return &fragment_;
}
inline const ::exec::bit::control::PlanFragment& InitializeFragments::fragment(int index) const {
  // @@protoc_insertion_point(field_get:exec.bit.control.InitializeFragments.fragment)
  return fragment_.Get(index);
}
inline ::exec::bit::control::PlanFragment* InitializeFragments::add_fragment() {
  // @@protoc_insertion_point(field_add:exec.bit.control.InitializeFragments.fragment)
  return fragment_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >&
InitializeFragments::fragment() const {
  // @@protoc_insertion_point(field_list:exec.bit.control.InitializeFragments.fragment)
  return fragment_;
}

// -------------------------------------------------------------------

// CustomMessage

// optional int32 type = 1;
inline bool CustomMessage::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CustomMessage::set_has_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CustomMessage::clear_has_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CustomMessage::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::google::protobuf::int32 CustomMessage::type() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.CustomMessage.type)
  return type_;
}
inline void CustomMessage::set_type(::google::protobuf::int32 value) {
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.CustomMessage.type)
}

// optional bytes message = 2;
inline bool CustomMessage::has_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CustomMessage::set_has_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CustomMessage::clear_has_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CustomMessage::clear_message() {
  message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_message();
}
inline const ::std::string& CustomMessage::message() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.CustomMessage.message)
  return message_.GetNoArena();
}
inline void CustomMessage::set_message(const ::std::string& value) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exec.bit.control.CustomMessage.message)
}
#if LANG_CXX11
inline void CustomMessage::set_message(::std::string&& value) {
  set_has_message();
  message_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exec.bit.control.CustomMessage.message)
}
#endif
inline void CustomMessage::set_message(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exec.bit.control.CustomMessage.message)
}
inline void CustomMessage::set_message(const void* value, size_t size) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exec.bit.control.CustomMessage.message)
}
inline ::std::string* CustomMessage::mutable_message() {
  set_has_message();
  // @@protoc_insertion_point(field_mutable:exec.bit.control.CustomMessage.message)
  return message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* CustomMessage::release_message() {
  // @@protoc_insertion_point(field_release:exec.bit.control.CustomMessage.message)
  if (!has_message()) {
    return NULL;
  }
  clear_has_message();
  return message_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CustomMessage::set_allocated_message(::std::string* message) {
  if (message != NULL) {
    set_has_message();
  } else {
    clear_has_message();
  }
  message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message);
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.CustomMessage.message)
}

// -------------------------------------------------------------------

// PlanFragment

// optional .exec.bit.FragmentHandle handle = 1;
inline bool PlanFragment::has_handle() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void PlanFragment::set_has_handle() {
  _has_bits_[0] |= 0x00000008u;
}
inline void PlanFragment::clear_has_handle() {
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::exec::bit::FragmentHandle& PlanFragment::_internal_handle() const {
  return *handle_;
}
inline const ::exec::bit::FragmentHandle& PlanFragment::handle() const {
  const ::exec::bit::FragmentHandle* p = handle_;
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.handle)
  return p != NULL ? *p : *reinterpret_cast<const ::exec::bit::FragmentHandle*>(
      &::exec::bit::_FragmentHandle_default_instance_);
}
inline ::exec::bit::FragmentHandle* PlanFragment::release_handle() {
  // @@protoc_insertion_point(field_release:exec.bit.control.PlanFragment.handle)
  clear_has_handle();
  ::exec::bit::FragmentHandle* temp = handle_;
  handle_ = NULL;
  return temp;
}
inline ::exec::bit::FragmentHandle* PlanFragment::mutable_handle() {
  set_has_handle();
  if (handle_ == NULL) {
    auto* p = CreateMaybeMessage<::exec::bit::FragmentHandle>(GetArenaNoVirtual());
    handle_ = p;
  }
  // @@protoc_insertion_point(field_mutable:exec.bit.control.PlanFragment.handle)
  return handle_;
}
inline void PlanFragment::set_allocated_handle(::exec::bit::FragmentHandle* handle) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(handle_);
  }
  if (handle) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      handle = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, handle, submessage_arena);
    }
    set_has_handle();
  } else {
    clear_has_handle();
  }
  handle_ = handle;
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.PlanFragment.handle)
}

// optional float network_cost = 4;
inline bool PlanFragment::has_network_cost() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void PlanFragment::set_has_network_cost() {
  _has_bits_[0] |= 0x00000100u;
}
inline void PlanFragment::clear_has_network_cost() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void PlanFragment::clear_network_cost() {
  network_cost_ = 0;
  clear_has_network_cost();
}
inline float PlanFragment::network_cost() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.network_cost)
  return network_cost_;
}
inline void PlanFragment::set_network_cost(float value) {
  set_has_network_cost();
  network_cost_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.PlanFragment.network_cost)
}

// optional float cpu_cost = 5;
inline bool PlanFragment::has_cpu_cost() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void PlanFragment::set_has_cpu_cost() {
  _has_bits_[0] |= 0x00000200u;
}
inline void PlanFragment::clear_has_cpu_cost() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void PlanFragment::clear_cpu_cost() {
  cpu_cost_ = 0;
  clear_has_cpu_cost();
}
inline float PlanFragment::cpu_cost() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.cpu_cost)
  return cpu_cost_;
}
inline void PlanFragment::set_cpu_cost(float value) {
  set_has_cpu_cost();
  cpu_cost_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.PlanFragment.cpu_cost)
}

// optional float disk_cost = 6;
inline bool PlanFragment::has_disk_cost() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void PlanFragment::set_has_disk_cost() {
  _has_bits_[0] |= 0x00000400u;
}
inline void PlanFragment::clear_has_disk_cost() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void PlanFragment::clear_disk_cost() {
  disk_cost_ = 0;
  clear_has_disk_cost();
}
inline float PlanFragment::disk_cost() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.disk_cost)
  return disk_cost_;
}
inline void PlanFragment::set_disk_cost(float value) {
  set_has_disk_cost();
  disk_cost_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.PlanFragment.disk_cost)
}

// optional float memory_cost = 7;
inline bool PlanFragment::has_memory_cost() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void PlanFragment::set_has_memory_cost() {
  _has_bits_[0] |= 0x00000800u;
}
inline void PlanFragment::clear_has_memory_cost() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void PlanFragment::clear_memory_cost() {
  memory_cost_ = 0;
  clear_has_memory_cost();
}
inline float PlanFragment::memory_cost() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.memory_cost)
  return memory_cost_;
}
inline void PlanFragment::set_memory_cost(float value) {
  set_has_memory_cost();
  memory_cost_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.PlanFragment.memory_cost)
}

// optional string fragment_json = 8;
inline bool PlanFragment::has_fragment_json() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PlanFragment::set_has_fragment_json() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PlanFragment::clear_has_fragment_json() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PlanFragment::clear_fragment_json() {
  fragment_json_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_fragment_json();
}
inline const ::std::string& PlanFragment::fragment_json() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.fragment_json)
  return fragment_json_.GetNoArena();
}
inline void PlanFragment::set_fragment_json(const ::std::string& value) {
  set_has_fragment_json();
  fragment_json_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exec.bit.control.PlanFragment.fragment_json)
}
#if LANG_CXX11
inline void PlanFragment::set_fragment_json(::std::string&& value) {
  set_has_fragment_json();
  fragment_json_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exec.bit.control.PlanFragment.fragment_json)
}
#endif
inline void PlanFragment::set_fragment_json(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_fragment_json();
  fragment_json_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exec.bit.control.PlanFragment.fragment_json)
}
inline void PlanFragment::set_fragment_json(const char* value, size_t size) {
  set_has_fragment_json();
  fragment_json_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exec.bit.control.PlanFragment.fragment_json)
}
inline ::std::string* PlanFragment::mutable_fragment_json() {
  set_has_fragment_json();
  // @@protoc_insertion_point(field_mutable:exec.bit.control.PlanFragment.fragment_json)
  return fragment_json_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PlanFragment::release_fragment_json() {
  // @@protoc_insertion_point(field_release:exec.bit.control.PlanFragment.fragment_json)
  if (!has_fragment_json()) {
    return NULL;
  }
  clear_has_fragment_json();
  return fragment_json_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PlanFragment::set_allocated_fragment_json(::std::string* fragment_json) {
  if (fragment_json != NULL) {
    set_has_fragment_json();
  } else {
    clear_has_fragment_json();
  }
  fragment_json_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), fragment_json);
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.PlanFragment.fragment_json)
}

// optional bool leaf_fragment = 9;
inline bool PlanFragment::has_leaf_fragment() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void PlanFragment::set_has_leaf_fragment() {
  _has_bits_[0] |= 0x00001000u;
}
inline void PlanFragment::clear_has_leaf_fragment() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void PlanFragment::clear_leaf_fragment() {
  leaf_fragment_ = false;
  clear_has_leaf_fragment();
}
inline bool PlanFragment::leaf_fragment() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.leaf_fragment)
  return leaf_fragment_;
}
inline void PlanFragment::set_leaf_fragment(bool value) {
  set_has_leaf_fragment();
  leaf_fragment_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.PlanFragment.leaf_fragment)
}

// optional .exec.DrillbitEndpoint assignment = 10;
inline bool PlanFragment::has_assignment() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void PlanFragment::set_has_assignment() {
  _has_bits_[0] |= 0x00000010u;
}
inline void PlanFragment::clear_has_assignment() {
  _has_bits_[0] &= ~0x00000010u;
}
inline const ::exec::DrillbitEndpoint& PlanFragment::_internal_assignment() const {
  return *assignment_;
}
inline const ::exec::DrillbitEndpoint& PlanFragment::assignment() const {
  const ::exec::DrillbitEndpoint* p = assignment_;
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.assignment)
  return p != NULL ? *p : *reinterpret_cast<const ::exec::DrillbitEndpoint*>(
      &::exec::_DrillbitEndpoint_default_instance_);
}
inline ::exec::DrillbitEndpoint* PlanFragment::release_assignment() {
  // @@protoc_insertion_point(field_release:exec.bit.control.PlanFragment.assignment)
  clear_has_assignment();
  ::exec::DrillbitEndpoint* temp = assignment_;
  assignment_ = NULL;
  return temp;
}
inline ::exec::DrillbitEndpoint* PlanFragment::mutable_assignment() {
  set_has_assignment();
  if (assignment_ == NULL) {
    auto* p = CreateMaybeMessage<::exec::DrillbitEndpoint>(GetArenaNoVirtual());
    assignment_ = p;
  }
  // @@protoc_insertion_point(field_mutable:exec.bit.control.PlanFragment.assignment)
  return assignment_;
}
inline void PlanFragment::set_allocated_assignment(::exec::DrillbitEndpoint* assignment) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(assignment_);
  }
  if (assignment) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      assignment = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, assignment, submessage_arena);
    }
    set_has_assignment();
  } else {
    clear_has_assignment();
  }
  assignment_ = assignment;
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.PlanFragment.assignment)
}

// optional .exec.DrillbitEndpoint foreman = 11;
inline bool PlanFragment::has_foreman() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void PlanFragment::set_has_foreman() {
  _has_bits_[0] |= 0x00000020u;
}
inline void PlanFragment::clear_has_foreman() {
  _has_bits_[0] &= ~0x00000020u;
}
inline const ::exec::DrillbitEndpoint& PlanFragment::_internal_foreman() const {
  return *foreman_;
}
inline const ::exec::DrillbitEndpoint& PlanFragment::foreman() const {
  const ::exec::DrillbitEndpoint* p = foreman_;
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.foreman)
  return p != NULL ? *p : *reinterpret_cast<const ::exec::DrillbitEndpoint*>(
      &::exec::_DrillbitEndpoint_default_instance_);
}
inline ::exec::DrillbitEndpoint* PlanFragment::release_foreman() {
  // @@protoc_insertion_point(field_release:exec.bit.control.PlanFragment.foreman)
  clear_has_foreman();
  ::exec::DrillbitEndpoint* temp = foreman_;
  foreman_ = NULL;
  return temp;
}
inline ::exec::DrillbitEndpoint* PlanFragment::mutable_foreman() {
  set_has_foreman();
  if (foreman_ == NULL) {
    auto* p = CreateMaybeMessage<::exec::DrillbitEndpoint>(GetArenaNoVirtual());
    foreman_ = p;
  }
  // @@protoc_insertion_point(field_mutable:exec.bit.control.PlanFragment.foreman)
  return foreman_;
}
inline void PlanFragment::set_allocated_foreman(::exec::DrillbitEndpoint* foreman) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(foreman_);
  }
  if (foreman) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      foreman = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, foreman, submessage_arena);
    }
    set_has_foreman();
  } else {
    clear_has_foreman();
  }
  foreman_ = foreman;
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.PlanFragment.foreman)
}

// optional int64 mem_initial = 12 [default = 20000000];
inline bool PlanFragment::has_mem_initial() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void PlanFragment::set_has_mem_initial() {
  _has_bits_[0] |= 0x00002000u;
}
inline void PlanFragment::clear_has_mem_initial() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void PlanFragment::clear_mem_initial() {
  mem_initial_ = GOOGLE_LONGLONG(20000000);
  clear_has_mem_initial();
}
inline ::google::protobuf::int64 PlanFragment::mem_initial() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.mem_initial)
  return mem_initial_;
}
inline void PlanFragment::set_mem_initial(::google::protobuf::int64 value) {
  set_has_mem_initial();
  mem_initial_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.PlanFragment.mem_initial)
}

// optional int64 mem_max = 13 [default = 2000000000];
inline bool PlanFragment::has_mem_max() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void PlanFragment::set_has_mem_max() {
  _has_bits_[0] |= 0x00004000u;
}
inline void PlanFragment::clear_has_mem_max() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void PlanFragment::clear_mem_max() {
  mem_max_ = GOOGLE_LONGLONG(2000000000);
  clear_has_mem_max();
}
inline ::google::protobuf::int64 PlanFragment::mem_max() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.mem_max)
  return mem_max_;
}
inline void PlanFragment::set_mem_max(::google::protobuf::int64 value) {
  set_has_mem_max();
  mem_max_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.PlanFragment.mem_max)
}

// optional .exec.shared.UserCredentials credentials = 14;
inline bool PlanFragment::has_credentials() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void PlanFragment::set_has_credentials() {
  _has_bits_[0] |= 0x00000040u;
}
inline void PlanFragment::clear_has_credentials() {
  _has_bits_[0] &= ~0x00000040u;
}
inline const ::exec::shared::UserCredentials& PlanFragment::_internal_credentials() const {
  return *credentials_;
}
inline const ::exec::shared::UserCredentials& PlanFragment::credentials() const {
  const ::exec::shared::UserCredentials* p = credentials_;
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.credentials)
  return p != NULL ? *p : *reinterpret_cast<const ::exec::shared::UserCredentials*>(
      &::exec::shared::_UserCredentials_default_instance_);
}
inline ::exec::shared::UserCredentials* PlanFragment::release_credentials() {
  // @@protoc_insertion_point(field_release:exec.bit.control.PlanFragment.credentials)
  clear_has_credentials();
  ::exec::shared::UserCredentials* temp = credentials_;
  credentials_ = NULL;
  return temp;
}
inline ::exec::shared::UserCredentials* PlanFragment::mutable_credentials() {
  set_has_credentials();
  if (credentials_ == NULL) {
    auto* p = CreateMaybeMessage<::exec::shared::UserCredentials>(GetArenaNoVirtual());
    credentials_ = p;
  }
  // @@protoc_insertion_point(field_mutable:exec.bit.control.PlanFragment.credentials)
  return credentials_;
}
inline void PlanFragment::set_allocated_credentials(::exec::shared::UserCredentials* credentials) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(credentials_);
  }
  if (credentials) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      credentials = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, credentials, submessage_arena);
    }
    set_has_credentials();
  } else {
    clear_has_credentials();
  }
  credentials_ = credentials;
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.PlanFragment.credentials)
}

// optional string options_json = 15;
inline bool PlanFragment::has_options_json() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PlanFragment::set_has_options_json() {
  _has_bits_[0] |= 0x00000002u;
}
inline void PlanFragment::clear_has_options_json() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void PlanFragment::clear_options_json() {
  options_json_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_options_json();
}
inline const ::std::string& PlanFragment::options_json() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.options_json)
  return options_json_.GetNoArena();
}
inline void PlanFragment::set_options_json(const ::std::string& value) {
  set_has_options_json();
  options_json_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exec.bit.control.PlanFragment.options_json)
}
#if LANG_CXX11
inline void PlanFragment::set_options_json(::std::string&& value) {
  set_has_options_json();
  options_json_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exec.bit.control.PlanFragment.options_json)
}
#endif
inline void PlanFragment::set_options_json(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_options_json();
  options_json_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exec.bit.control.PlanFragment.options_json)
}
inline void PlanFragment::set_options_json(const char* value, size_t size) {
  set_has_options_json();
  options_json_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exec.bit.control.PlanFragment.options_json)
}
inline ::std::string* PlanFragment::mutable_options_json() {
  set_has_options_json();
  // @@protoc_insertion_point(field_mutable:exec.bit.control.PlanFragment.options_json)
  return options_json_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PlanFragment::release_options_json() {
  // @@protoc_insertion_point(field_release:exec.bit.control.PlanFragment.options_json)
  if (!has_options_json()) {
    return NULL;
  }
  clear_has_options_json();
  return options_json_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PlanFragment::set_allocated_options_json(::std::string* options_json) {
  if (options_json != NULL) {
    set_has_options_json();
  } else {
    clear_has_options_json();
  }
  options_json_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), options_json);
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.PlanFragment.options_json)
}

// optional .exec.bit.control.QueryContextInformation context = 16;
inline bool PlanFragment::has_context() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void PlanFragment::set_has_context() {
  _has_bits_[0] |= 0x00000080u;
}
inline void PlanFragment::clear_has_context() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void PlanFragment::clear_context() {
  if (context_ != NULL) context_->Clear();
  clear_has_context();
}
inline const ::exec::bit::control::QueryContextInformation& PlanFragment::_internal_context() const {
  return *context_;
}
inline const ::exec::bit::control::QueryContextInformation& PlanFragment::context() const {
  const ::exec::bit::control::QueryContextInformation* p = context_;
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.context)
  return p != NULL ? *p : *reinterpret_cast<const ::exec::bit::control::QueryContextInformation*>(
      &::exec::bit::control::_QueryContextInformation_default_instance_);
}
inline ::exec::bit::control::QueryContextInformation* PlanFragment::release_context() {
  // @@protoc_insertion_point(field_release:exec.bit.control.PlanFragment.context)
  clear_has_context();
  ::exec::bit::control::QueryContextInformation* temp = context_;
  context_ = NULL;
  return temp;
}
inline ::exec::bit::control::QueryContextInformation* PlanFragment::mutable_context() {
  set_has_context();
  if (context_ == NULL) {
    auto* p = CreateMaybeMessage<::exec::bit::control::QueryContextInformation>(GetArenaNoVirtual());
    context_ = p;
  }
  // @@protoc_insertion_point(field_mutable:exec.bit.control.PlanFragment.context)
  return context_;
}
inline void PlanFragment::set_allocated_context(::exec::bit::control::QueryContextInformation* context) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete context_;
  }
  if (context) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      context = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, context, submessage_arena);
    }
    set_has_context();
  } else {
    clear_has_context();
  }
  context_ = context;
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.PlanFragment.context)
}

// repeated .exec.bit.control.Collector collector = 17;
inline int PlanFragment::collector_size() const {
  return collector_.size();
}
inline void PlanFragment::clear_collector() {
  collector_.Clear();
}
inline ::exec::bit::control::Collector* PlanFragment::mutable_collector(int index) {
  // @@protoc_insertion_point(field_mutable:exec.bit.control.PlanFragment.collector)
  return collector_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::Collector >*
PlanFragment::mutable_collector() {
  // @@protoc_insertion_point(field_mutable_list:exec.bit.control.PlanFragment.collector)
  return &collector_;
}
inline const ::exec::bit::control::Collector& PlanFragment::collector(int index) const {
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.collector)
  return collector_.Get(index);
}
inline ::exec::bit::control::Collector* PlanFragment::add_collector() {
  // @@protoc_insertion_point(field_add:exec.bit.control.PlanFragment.collector)
  return collector_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::Collector >&
PlanFragment::collector() const {
  // @@protoc_insertion_point(field_list:exec.bit.control.PlanFragment.collector)
  return collector_;
}

// optional string assignedEndpointUUID = 18;
inline bool PlanFragment::has_assignedendpointuuid() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void PlanFragment::set_has_assignedendpointuuid() {
  _has_bits_[0] |= 0x00000004u;
}
inline void PlanFragment::clear_has_assignedendpointuuid() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void PlanFragment::clear_assignedendpointuuid() {
  assignedendpointuuid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_assignedendpointuuid();
}
inline const ::std::string& PlanFragment::assignedendpointuuid() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.PlanFragment.assignedEndpointUUID)
  return assignedendpointuuid_.GetNoArena();
}
inline void PlanFragment::set_assignedendpointuuid(const ::std::string& value) {
  set_has_assignedendpointuuid();
  assignedendpointuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exec.bit.control.PlanFragment.assignedEndpointUUID)
}
#if LANG_CXX11
inline void PlanFragment::set_assignedendpointuuid(::std::string&& value) {
  set_has_assignedendpointuuid();
  assignedendpointuuid_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exec.bit.control.PlanFragment.assignedEndpointUUID)
}
#endif
inline void PlanFragment::set_assignedendpointuuid(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_assignedendpointuuid();
  assignedendpointuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exec.bit.control.PlanFragment.assignedEndpointUUID)
}
inline void PlanFragment::set_assignedendpointuuid(const char* value, size_t size) {
  set_has_assignedendpointuuid();
  assignedendpointuuid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exec.bit.control.PlanFragment.assignedEndpointUUID)
}
inline ::std::string* PlanFragment::mutable_assignedendpointuuid() {
  set_has_assignedendpointuuid();
  // @@protoc_insertion_point(field_mutable:exec.bit.control.PlanFragment.assignedEndpointUUID)
  return assignedendpointuuid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* PlanFragment::release_assignedendpointuuid() {
  // @@protoc_insertion_point(field_release:exec.bit.control.PlanFragment.assignedEndpointUUID)
  if (!has_assignedendpointuuid()) {
    return NULL;
  }
  clear_has_assignedendpointuuid();
  return assignedendpointuuid_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void PlanFragment::set_allocated_assignedendpointuuid(::std::string* assignedendpointuuid) {
  if (assignedendpointuuid != NULL) {
    set_has_assignedendpointuuid();
  } else {
    clear_has_assignedendpointuuid();
  }
  assignedendpointuuid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), assignedendpointuuid);
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.PlanFragment.assignedEndpointUUID)
}

// -------------------------------------------------------------------

// Collector

// optional int32 opposite_major_fragment_id = 1;
inline bool Collector::has_opposite_major_fragment_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Collector::set_has_opposite_major_fragment_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Collector::clear_has_opposite_major_fragment_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Collector::clear_opposite_major_fragment_id() {
  opposite_major_fragment_id_ = 0;
  clear_has_opposite_major_fragment_id();
}
inline ::google::protobuf::int32 Collector::opposite_major_fragment_id() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.Collector.opposite_major_fragment_id)
  return opposite_major_fragment_id_;
}
inline void Collector::set_opposite_major_fragment_id(::google::protobuf::int32 value) {
  set_has_opposite_major_fragment_id();
  opposite_major_fragment_id_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.Collector.opposite_major_fragment_id)
}

// repeated int32 incoming_minor_fragment = 2 [packed = true];
inline int Collector::incoming_minor_fragment_size() const {
  return incoming_minor_fragment_.size();
}
inline void Collector::clear_incoming_minor_fragment() {
  incoming_minor_fragment_.Clear();
}
inline ::google::protobuf::int32 Collector::incoming_minor_fragment(int index) const {
  // @@protoc_insertion_point(field_get:exec.bit.control.Collector.incoming_minor_fragment)
  return incoming_minor_fragment_.Get(index);
}
inline void Collector::set_incoming_minor_fragment(int index, ::google::protobuf::int32 value) {
  incoming_minor_fragment_.Set(index, value);
  // @@protoc_insertion_point(field_set:exec.bit.control.Collector.incoming_minor_fragment)
}
inline void Collector::add_incoming_minor_fragment(::google::protobuf::int32 value) {
  incoming_minor_fragment_.Add(value);
  // @@protoc_insertion_point(field_add:exec.bit.control.Collector.incoming_minor_fragment)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
Collector::incoming_minor_fragment() const {
  // @@protoc_insertion_point(field_list:exec.bit.control.Collector.incoming_minor_fragment)
  return incoming_minor_fragment_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
Collector::mutable_incoming_minor_fragment() {
  // @@protoc_insertion_point(field_mutable_list:exec.bit.control.Collector.incoming_minor_fragment)
  return &incoming_minor_fragment_;
}

// optional bool supports_out_of_order = 3;
inline bool Collector::has_supports_out_of_order() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Collector::set_has_supports_out_of_order() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Collector::clear_has_supports_out_of_order() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Collector::clear_supports_out_of_order() {
  supports_out_of_order_ = false;
  clear_has_supports_out_of_order();
}
inline bool Collector::supports_out_of_order() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.Collector.supports_out_of_order)
  return supports_out_of_order_;
}
inline void Collector::set_supports_out_of_order(bool value) {
  set_has_supports_out_of_order();
  supports_out_of_order_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.Collector.supports_out_of_order)
}

// optional bool is_spooling = 4;
inline bool Collector::has_is_spooling() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Collector::set_has_is_spooling() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Collector::clear_has_is_spooling() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Collector::clear_is_spooling() {
  is_spooling_ = false;
  clear_has_is_spooling();
}
inline bool Collector::is_spooling() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.Collector.is_spooling)
  return is_spooling_;
}
inline void Collector::set_is_spooling(bool value) {
  set_has_is_spooling();
  is_spooling_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.Collector.is_spooling)
}

// -------------------------------------------------------------------

// QueryContextInformation

// optional int64 query_start_time = 1;
inline bool QueryContextInformation::has_query_start_time() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void QueryContextInformation::set_has_query_start_time() {
  _has_bits_[0] |= 0x00000004u;
}
inline void QueryContextInformation::clear_has_query_start_time() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void QueryContextInformation::clear_query_start_time() {
  query_start_time_ = GOOGLE_LONGLONG(0);
  clear_has_query_start_time();
}
inline ::google::protobuf::int64 QueryContextInformation::query_start_time() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.QueryContextInformation.query_start_time)
  return query_start_time_;
}
inline void QueryContextInformation::set_query_start_time(::google::protobuf::int64 value) {
  set_has_query_start_time();
  query_start_time_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.QueryContextInformation.query_start_time)
}

// optional int32 time_zone = 2;
inline bool QueryContextInformation::has_time_zone() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void QueryContextInformation::set_has_time_zone() {
  _has_bits_[0] |= 0x00000008u;
}
inline void QueryContextInformation::clear_has_time_zone() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void QueryContextInformation::clear_time_zone() {
  time_zone_ = 0;
  clear_has_time_zone();
}
inline ::google::protobuf::int32 QueryContextInformation::time_zone() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.QueryContextInformation.time_zone)
  return time_zone_;
}
inline void QueryContextInformation::set_time_zone(::google::protobuf::int32 value) {
  set_has_time_zone();
  time_zone_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.QueryContextInformation.time_zone)
}

// optional string default_schema_name = 3;
inline bool QueryContextInformation::has_default_schema_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void QueryContextInformation::set_has_default_schema_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void QueryContextInformation::clear_has_default_schema_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void QueryContextInformation::clear_default_schema_name() {
  default_schema_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_default_schema_name();
}
inline const ::std::string& QueryContextInformation::default_schema_name() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.QueryContextInformation.default_schema_name)
  return default_schema_name_.GetNoArena();
}
inline void QueryContextInformation::set_default_schema_name(const ::std::string& value) {
  set_has_default_schema_name();
  default_schema_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exec.bit.control.QueryContextInformation.default_schema_name)
}
#if LANG_CXX11
inline void QueryContextInformation::set_default_schema_name(::std::string&& value) {
  set_has_default_schema_name();
  default_schema_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exec.bit.control.QueryContextInformation.default_schema_name)
}
#endif
inline void QueryContextInformation::set_default_schema_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_default_schema_name();
  default_schema_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exec.bit.control.QueryContextInformation.default_schema_name)
}
inline void QueryContextInformation::set_default_schema_name(const char* value, size_t size) {
  set_has_default_schema_name();
  default_schema_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exec.bit.control.QueryContextInformation.default_schema_name)
}
inline ::std::string* QueryContextInformation::mutable_default_schema_name() {
  set_has_default_schema_name();
  // @@protoc_insertion_point(field_mutable:exec.bit.control.QueryContextInformation.default_schema_name)
  return default_schema_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* QueryContextInformation::release_default_schema_name() {
  // @@protoc_insertion_point(field_release:exec.bit.control.QueryContextInformation.default_schema_name)
  if (!has_default_schema_name()) {
    return NULL;
  }
  clear_has_default_schema_name();
  return default_schema_name_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void QueryContextInformation::set_allocated_default_schema_name(::std::string* default_schema_name) {
  if (default_schema_name != NULL) {
    set_has_default_schema_name();
  } else {
    clear_has_default_schema_name();
  }
  default_schema_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), default_schema_name);
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.QueryContextInformation.default_schema_name)
}

// optional string session_id = 4;
inline bool QueryContextInformation::has_session_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void QueryContextInformation::set_has_session_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void QueryContextInformation::clear_has_session_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void QueryContextInformation::clear_session_id() {
  session_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_session_id();
}
inline const ::std::string& QueryContextInformation::session_id() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.QueryContextInformation.session_id)
  return session_id_.GetNoArena();
}
inline void QueryContextInformation::set_session_id(const ::std::string& value) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:exec.bit.control.QueryContextInformation.session_id)
}
#if LANG_CXX11
inline void QueryContextInformation::set_session_id(::std::string&& value) {
  set_has_session_id();
  session_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:exec.bit.control.QueryContextInformation.session_id)
}
#endif
inline void QueryContextInformation::set_session_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:exec.bit.control.QueryContextInformation.session_id)
}
inline void QueryContextInformation::set_session_id(const char* value, size_t size) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:exec.bit.control.QueryContextInformation.session_id)
}
inline ::std::string* QueryContextInformation::mutable_session_id() {
  set_has_session_id();
  // @@protoc_insertion_point(field_mutable:exec.bit.control.QueryContextInformation.session_id)
  return session_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* QueryContextInformation::release_session_id() {
  // @@protoc_insertion_point(field_release:exec.bit.control.QueryContextInformation.session_id)
  if (!has_session_id()) {
    return NULL;
  }
  clear_has_session_id();
  return session_id_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void QueryContextInformation::set_allocated_session_id(::std::string* session_id) {
  if (session_id != NULL) {
    set_has_session_id();
  } else {
    clear_has_session_id();
  }
  session_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), session_id);
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.QueryContextInformation.session_id)
}

// -------------------------------------------------------------------

// WorkQueueStatus

// optional .exec.DrillbitEndpoint endpoint = 1;
inline bool WorkQueueStatus::has_endpoint() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WorkQueueStatus::set_has_endpoint() {
  _has_bits_[0] |= 0x00000001u;
}
inline void WorkQueueStatus::clear_has_endpoint() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::exec::DrillbitEndpoint& WorkQueueStatus::_internal_endpoint() const {
  return *endpoint_;
}
inline const ::exec::DrillbitEndpoint& WorkQueueStatus::endpoint() const {
  const ::exec::DrillbitEndpoint* p = endpoint_;
  // @@protoc_insertion_point(field_get:exec.bit.control.WorkQueueStatus.endpoint)
  return p != NULL ? *p : *reinterpret_cast<const ::exec::DrillbitEndpoint*>(
      &::exec::_DrillbitEndpoint_default_instance_);
}
inline ::exec::DrillbitEndpoint* WorkQueueStatus::release_endpoint() {
  // @@protoc_insertion_point(field_release:exec.bit.control.WorkQueueStatus.endpoint)
  clear_has_endpoint();
  ::exec::DrillbitEndpoint* temp = endpoint_;
  endpoint_ = NULL;
  return temp;
}
inline ::exec::DrillbitEndpoint* WorkQueueStatus::mutable_endpoint() {
  set_has_endpoint();
  if (endpoint_ == NULL) {
    auto* p = CreateMaybeMessage<::exec::DrillbitEndpoint>(GetArenaNoVirtual());
    endpoint_ = p;
  }
  // @@protoc_insertion_point(field_mutable:exec.bit.control.WorkQueueStatus.endpoint)
  return endpoint_;
}
inline void WorkQueueStatus::set_allocated_endpoint(::exec::DrillbitEndpoint* endpoint) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(endpoint_);
  }
  if (endpoint) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      endpoint = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, endpoint, submessage_arena);
    }
    set_has_endpoint();
  } else {
    clear_has_endpoint();
  }
  endpoint_ = endpoint;
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.WorkQueueStatus.endpoint)
}

// optional int32 queue_length = 2;
inline bool WorkQueueStatus::has_queue_length() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void WorkQueueStatus::set_has_queue_length() {
  _has_bits_[0] |= 0x00000004u;
}
inline void WorkQueueStatus::clear_has_queue_length() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void WorkQueueStatus::clear_queue_length() {
  queue_length_ = 0;
  clear_has_queue_length();
}
inline ::google::protobuf::int32 WorkQueueStatus::queue_length() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.WorkQueueStatus.queue_length)
  return queue_length_;
}
inline void WorkQueueStatus::set_queue_length(::google::protobuf::int32 value) {
  set_has_queue_length();
  queue_length_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.WorkQueueStatus.queue_length)
}

// optional int64 report_time = 3;
inline bool WorkQueueStatus::has_report_time() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void WorkQueueStatus::set_has_report_time() {
  _has_bits_[0] |= 0x00000002u;
}
inline void WorkQueueStatus::clear_has_report_time() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void WorkQueueStatus::clear_report_time() {
  report_time_ = GOOGLE_LONGLONG(0);
  clear_has_report_time();
}
inline ::google::protobuf::int64 WorkQueueStatus::report_time() const {
  // @@protoc_insertion_point(field_get:exec.bit.control.WorkQueueStatus.report_time)
  return report_time_;
}
inline void WorkQueueStatus::set_report_time(::google::protobuf::int64 value) {
  set_has_report_time();
  report_time_ = value;
  // @@protoc_insertion_point(field_set:exec.bit.control.WorkQueueStatus.report_time)
}

// -------------------------------------------------------------------

// FinishedReceiver

// optional .exec.bit.FragmentHandle receiver = 1;
inline bool FinishedReceiver::has_receiver() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FinishedReceiver::set_has_receiver() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FinishedReceiver::clear_has_receiver() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::exec::bit::FragmentHandle& FinishedReceiver::_internal_receiver() const {
  return *receiver_;
}
inline const ::exec::bit::FragmentHandle& FinishedReceiver::receiver() const {
  const ::exec::bit::FragmentHandle* p = receiver_;
  // @@protoc_insertion_point(field_get:exec.bit.control.FinishedReceiver.receiver)
  return p != NULL ? *p : *reinterpret_cast<const ::exec::bit::FragmentHandle*>(
      &::exec::bit::_FragmentHandle_default_instance_);
}
inline ::exec::bit::FragmentHandle* FinishedReceiver::release_receiver() {
  // @@protoc_insertion_point(field_release:exec.bit.control.FinishedReceiver.receiver)
  clear_has_receiver();
  ::exec::bit::FragmentHandle* temp = receiver_;
  receiver_ = NULL;
  return temp;
}
inline ::exec::bit::FragmentHandle* FinishedReceiver::mutable_receiver() {
  set_has_receiver();
  if (receiver_ == NULL) {
    auto* p = CreateMaybeMessage<::exec::bit::FragmentHandle>(GetArenaNoVirtual());
    receiver_ = p;
  }
  // @@protoc_insertion_point(field_mutable:exec.bit.control.FinishedReceiver.receiver)
  return receiver_;
}
inline void FinishedReceiver::set_allocated_receiver(::exec::bit::FragmentHandle* receiver) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(receiver_);
  }
  if (receiver) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      receiver = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, receiver, submessage_arena);
    }
    set_has_receiver();
  } else {
    clear_has_receiver();
  }
  receiver_ = receiver;
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.FinishedReceiver.receiver)
}

// optional .exec.bit.FragmentHandle sender = 2;
inline bool FinishedReceiver::has_sender() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FinishedReceiver::set_has_sender() {
  _has_bits_[0] |= 0x00000002u;
}
inline void FinishedReceiver::clear_has_sender() {
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::exec::bit::FragmentHandle& FinishedReceiver::_internal_sender() const {
  return *sender_;
}
inline const ::exec::bit::FragmentHandle& FinishedReceiver::sender() const {
  const ::exec::bit::FragmentHandle* p = sender_;
  // @@protoc_insertion_point(field_get:exec.bit.control.FinishedReceiver.sender)
  return p != NULL ? *p : *reinterpret_cast<const ::exec::bit::FragmentHandle*>(
      &::exec::bit::_FragmentHandle_default_instance_);
}
inline ::exec::bit::FragmentHandle* FinishedReceiver::release_sender() {
  // @@protoc_insertion_point(field_release:exec.bit.control.FinishedReceiver.sender)
  clear_has_sender();
  ::exec::bit::FragmentHandle* temp = sender_;
  sender_ = NULL;
  return temp;
}
inline ::exec::bit::FragmentHandle* FinishedReceiver::mutable_sender() {
  set_has_sender();
  if (sender_ == NULL) {
    auto* p = CreateMaybeMessage<::exec::bit::FragmentHandle>(GetArenaNoVirtual());
    sender_ = p;
  }
  // @@protoc_insertion_point(field_mutable:exec.bit.control.FinishedReceiver.sender)
  return sender_;
}
inline void FinishedReceiver::set_allocated_sender(::exec::bit::FragmentHandle* sender) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(sender_);
  }
  if (sender) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      sender = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, sender, submessage_arena);
    }
    set_has_sender();
  } else {
    clear_has_sender();
  }
  sender_ = sender;
  // @@protoc_insertion_point(field_set_allocated:exec.bit.control.FinishedReceiver.sender)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace control
}  // namespace bit
}  // namespace exec

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::exec::bit::control::RpcType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::bit::control::RpcType>() {
  return ::exec::bit::control::RpcType_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_BitControl_2eproto