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

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

#ifndef PROTOBUF_User_2eproto__INCLUDED
#define PROTOBUF_User_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 2005000
#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 2005000 < 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/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "SchemaDef.pb.h"
#include "UserBitShared.pb.h"
// @@protoc_insertion_point(includes)

namespace exec {
namespace user {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_User_2eproto();
void protobuf_AssignDesc_User_2eproto();
void protobuf_ShutdownFile_User_2eproto();

class Property;
class UserProperties;
class UserToBitHandshake;
class RequestResults;
class RunQuery;
class BitToUserHandshake;

enum RpcType {
  HANDSHAKE = 0,
  ACK = 1,
  GOODBYE = 2,
  RUN_QUERY = 3,
  CANCEL_QUERY = 4,
  REQUEST_RESULTS = 5,
  RESUME_PAUSED_QUERY = 11,
  QUERY_DATA = 6,
  QUERY_HANDLE = 7,
  REQ_META_FUNCTIONS = 8,
  RESP_FUNCTION_LIST = 9,
  QUERY_RESULT = 10
};
bool RpcType_IsValid(int value);
const RpcType RpcType_MIN = HANDSHAKE;
const RpcType RpcType_MAX = RESUME_PAUSED_QUERY;
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);
}
enum QueryResultsMode {
  STREAM_FULL = 1
};
bool QueryResultsMode_IsValid(int value);
const QueryResultsMode QueryResultsMode_MIN = STREAM_FULL;
const QueryResultsMode QueryResultsMode_MAX = STREAM_FULL;
const int QueryResultsMode_ARRAYSIZE = QueryResultsMode_MAX + 1;

const ::google::protobuf::EnumDescriptor* QueryResultsMode_descriptor();
inline const ::std::string& QueryResultsMode_Name(QueryResultsMode value) {
  return ::google::protobuf::internal::NameOfEnum(
    QueryResultsMode_descriptor(), value);
}
inline bool QueryResultsMode_Parse(
    const ::std::string& name, QueryResultsMode* value) {
  return ::google::protobuf::internal::ParseNamedEnum<QueryResultsMode>(
    QueryResultsMode_descriptor(), name, value);
}
enum HandshakeStatus {
  SUCCESS = 1,
  RPC_VERSION_MISMATCH = 2,
  AUTH_FAILED = 3,
  UNKNOWN_FAILURE = 4
};
bool HandshakeStatus_IsValid(int value);
const HandshakeStatus HandshakeStatus_MIN = SUCCESS;
const HandshakeStatus HandshakeStatus_MAX = UNKNOWN_FAILURE;
const int HandshakeStatus_ARRAYSIZE = HandshakeStatus_MAX + 1;

const ::google::protobuf::EnumDescriptor* HandshakeStatus_descriptor();
inline const ::std::string& HandshakeStatus_Name(HandshakeStatus value) {
  return ::google::protobuf::internal::NameOfEnum(
    HandshakeStatus_descriptor(), value);
}
inline bool HandshakeStatus_Parse(
    const ::std::string& name, HandshakeStatus* value) {
  return ::google::protobuf::internal::ParseNamedEnum<HandshakeStatus>(
    HandshakeStatus_descriptor(), name, value);
}
// ===================================================================

class Property : public ::google::protobuf::Message {
 public:
  Property();
  virtual ~Property();

  Property(const Property& from);

  inline Property& operator=(const Property& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

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

  void Swap(Property* other);

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

  Property* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Property& from);
  void MergeFrom(const Property& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

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

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

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

  // required string key = 1;
  inline bool has_key() const;
  inline void clear_key();
  static const int kKeyFieldNumber = 1;
  inline const ::std::string& key() const;
  inline void set_key(const ::std::string& value);
  inline void set_key(const char* value);
  inline void set_key(const char* value, size_t size);
  inline ::std::string* mutable_key();
  inline ::std::string* release_key();
  inline void set_allocated_key(::std::string* key);

  // required string value = 2;
  inline bool has_value() const;
  inline void clear_value();
  static const int kValueFieldNumber = 2;
  inline const ::std::string& value() const;
  inline void set_value(const ::std::string& value);
  inline void set_value(const char* value);
  inline void set_value(const char* value, size_t size);
  inline ::std::string* mutable_value();
  inline ::std::string* release_value();
  inline void set_allocated_value(::std::string* value);

  // @@protoc_insertion_point(class_scope:exec.user.Property)
 private:
  inline void set_has_key();
  inline void clear_has_key();
  inline void set_has_value();
  inline void clear_has_value();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* key_;
  ::std::string* value_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static Property* default_instance_;
};
// -------------------------------------------------------------------

class UserProperties : public ::google::protobuf::Message {
 public:
  UserProperties();
  virtual ~UserProperties();

  UserProperties(const UserProperties& from);

  inline UserProperties& operator=(const UserProperties& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

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

  void Swap(UserProperties* other);

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

  UserProperties* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UserProperties& from);
  void MergeFrom(const UserProperties& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

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

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

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

  // repeated .exec.user.Property properties = 1;
  inline int properties_size() const;
  inline void clear_properties();
  static const int kPropertiesFieldNumber = 1;
  inline const ::exec::user::Property& properties(int index) const;
  inline ::exec::user::Property* mutable_properties(int index);
  inline ::exec::user::Property* add_properties();
  inline const ::google::protobuf::RepeatedPtrField< ::exec::user::Property >&
      properties() const;
  inline ::google::protobuf::RepeatedPtrField< ::exec::user::Property >*
      mutable_properties();

  // @@protoc_insertion_point(class_scope:exec.user.UserProperties)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::exec::user::Property > properties_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static UserProperties* default_instance_;
};
// -------------------------------------------------------------------

class UserToBitHandshake : public ::google::protobuf::Message {
 public:
  UserToBitHandshake();
  virtual ~UserToBitHandshake();

  UserToBitHandshake(const UserToBitHandshake& from);

  inline UserToBitHandshake& operator=(const UserToBitHandshake& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

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

  void Swap(UserToBitHandshake* other);

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

  UserToBitHandshake* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UserToBitHandshake& from);
  void MergeFrom(const UserToBitHandshake& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

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

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

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

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

  // optional bool support_listening = 2;
  inline bool has_support_listening() const;
  inline void clear_support_listening();
  static const int kSupportListeningFieldNumber = 2;
  inline bool support_listening() const;
  inline void set_support_listening(bool value);

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

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

  // optional .exec.user.UserProperties properties = 5;
  inline bool has_properties() const;
  inline void clear_properties();
  static const int kPropertiesFieldNumber = 5;
  inline const ::exec::user::UserProperties& properties() const;
  inline ::exec::user::UserProperties* mutable_properties();
  inline ::exec::user::UserProperties* release_properties();
  inline void set_allocated_properties(::exec::user::UserProperties* properties);

  // optional bool support_complex_types = 6 [default = false];
  inline bool has_support_complex_types() const;
  inline void clear_support_complex_types();
  static const int kSupportComplexTypesFieldNumber = 6;
  inline bool support_complex_types() const;
  inline void set_support_complex_types(bool value);

  // optional bool support_timeout = 7 [default = false];
  inline bool has_support_timeout() const;
  inline void clear_support_timeout();
  static const int kSupportTimeoutFieldNumber = 7;
  inline bool support_timeout() const;
  inline void set_support_timeout(bool value);

  // @@protoc_insertion_point(class_scope:exec.user.UserToBitHandshake)
 private:
  inline void set_has_channel();
  inline void clear_has_channel();
  inline void set_has_support_listening();
  inline void clear_has_support_listening();
  inline void set_has_rpc_version();
  inline void clear_has_rpc_version();
  inline void set_has_credentials();
  inline void clear_has_credentials();
  inline void set_has_properties();
  inline void clear_has_properties();
  inline void set_has_support_complex_types();
  inline void clear_has_support_complex_types();
  inline void set_has_support_timeout();
  inline void clear_has_support_timeout();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int channel_;
  ::google::protobuf::int32 rpc_version_;
  ::exec::shared::UserCredentials* credentials_;
  ::exec::user::UserProperties* properties_;
  bool support_listening_;
  bool support_complex_types_;
  bool support_timeout_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static UserToBitHandshake* default_instance_;
};
// -------------------------------------------------------------------

class RequestResults : public ::google::protobuf::Message {
 public:
  RequestResults();
  virtual ~RequestResults();

  RequestResults(const RequestResults& from);

  inline RequestResults& operator=(const RequestResults& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

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

  void Swap(RequestResults* other);

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

  RequestResults* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RequestResults& from);
  void MergeFrom(const RequestResults& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

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

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

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

  // optional .exec.shared.QueryId query_id = 1;
  inline bool has_query_id() const;
  inline void clear_query_id();
  static const int kQueryIdFieldNumber = 1;
  inline const ::exec::shared::QueryId& query_id() const;
  inline ::exec::shared::QueryId* mutable_query_id();
  inline ::exec::shared::QueryId* release_query_id();
  inline void set_allocated_query_id(::exec::shared::QueryId* query_id);

  // optional int32 maximum_responses = 2;
  inline bool has_maximum_responses() const;
  inline void clear_maximum_responses();
  static const int kMaximumResponsesFieldNumber = 2;
  inline ::google::protobuf::int32 maximum_responses() const;
  inline void set_maximum_responses(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:exec.user.RequestResults)
 private:
  inline void set_has_query_id();
  inline void clear_has_query_id();
  inline void set_has_maximum_responses();
  inline void clear_has_maximum_responses();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::exec::shared::QueryId* query_id_;
  ::google::protobuf::int32 maximum_responses_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static RequestResults* default_instance_;
};
// -------------------------------------------------------------------

class RunQuery : public ::google::protobuf::Message {
 public:
  RunQuery();
  virtual ~RunQuery();

  RunQuery(const RunQuery& from);

  inline RunQuery& operator=(const RunQuery& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

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

  void Swap(RunQuery* other);

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

  RunQuery* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RunQuery& from);
  void MergeFrom(const RunQuery& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

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

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

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

  // optional .exec.user.QueryResultsMode results_mode = 1;
  inline bool has_results_mode() const;
  inline void clear_results_mode();
  static const int kResultsModeFieldNumber = 1;
  inline ::exec::user::QueryResultsMode results_mode() const;
  inline void set_results_mode(::exec::user::QueryResultsMode value);

  // optional .exec.shared.QueryType type = 2;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 2;
  inline ::exec::shared::QueryType type() const;
  inline void set_type(::exec::shared::QueryType value);

  // optional string plan = 3;
  inline bool has_plan() const;
  inline void clear_plan();
  static const int kPlanFieldNumber = 3;
  inline const ::std::string& plan() const;
  inline void set_plan(const ::std::string& value);
  inline void set_plan(const char* value);
  inline void set_plan(const char* value, size_t size);
  inline ::std::string* mutable_plan();
  inline ::std::string* release_plan();
  inline void set_allocated_plan(::std::string* plan);

  // @@protoc_insertion_point(class_scope:exec.user.RunQuery)
 private:
  inline void set_has_results_mode();
  inline void clear_has_results_mode();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_plan();
  inline void clear_has_plan();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  int results_mode_;
  int type_;
  ::std::string* plan_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static RunQuery* default_instance_;
};
// -------------------------------------------------------------------

class BitToUserHandshake : public ::google::protobuf::Message {
 public:
  BitToUserHandshake();
  virtual ~BitToUserHandshake();

  BitToUserHandshake(const BitToUserHandshake& from);

  inline BitToUserHandshake& operator=(const BitToUserHandshake& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

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

  void Swap(BitToUserHandshake* other);

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

  BitToUserHandshake* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BitToUserHandshake& from);
  void MergeFrom(const BitToUserHandshake& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

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

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

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

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

  // optional .exec.user.HandshakeStatus status = 3;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 3;
  inline ::exec::user::HandshakeStatus status() const;
  inline void set_status(::exec::user::HandshakeStatus value);

  // optional string errorId = 4;
  inline bool has_errorid() const;
  inline void clear_errorid();
  static const int kErrorIdFieldNumber = 4;
  inline const ::std::string& errorid() const;
  inline void set_errorid(const ::std::string& value);
  inline void set_errorid(const char* value);
  inline void set_errorid(const char* value, size_t size);
  inline ::std::string* mutable_errorid();
  inline ::std::string* release_errorid();
  inline void set_allocated_errorid(::std::string* errorid);

  // optional string errorMessage = 5;
  inline bool has_errormessage() const;
  inline void clear_errormessage();
  static const int kErrorMessageFieldNumber = 5;
  inline const ::std::string& errormessage() const;
  inline void set_errormessage(const ::std::string& value);
  inline void set_errormessage(const char* value);
  inline void set_errormessage(const char* value, size_t size);
  inline ::std::string* mutable_errormessage();
  inline ::std::string* release_errormessage();
  inline void set_allocated_errormessage(::std::string* errormessage);

  // @@protoc_insertion_point(class_scope:exec.user.BitToUserHandshake)
 private:
  inline void set_has_rpc_version();
  inline void clear_has_rpc_version();
  inline void set_has_status();
  inline void clear_has_status();
  inline void set_has_errorid();
  inline void clear_has_errorid();
  inline void set_has_errormessage();
  inline void clear_has_errormessage();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 rpc_version_;
  int status_;
  ::std::string* errorid_;
  ::std::string* errormessage_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_User_2eproto();
  friend void protobuf_AssignDesc_User_2eproto();
  friend void protobuf_ShutdownFile_User_2eproto();

  void InitAsDefaultInstance();
  static BitToUserHandshake* default_instance_;
};
// ===================================================================


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

// Property

// required string key = 1;
inline bool Property::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Property::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Property::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Property::clear_key() {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    key_->clear();
  }
  clear_has_key();
}
inline const ::std::string& Property::key() const {
  return *key_;
}
inline void Property::set_key(const ::std::string& value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(value);
}
inline void Property::set_key(const char* value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(value);
}
inline void Property::set_key(const char* value, size_t size) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  key_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Property::mutable_key() {
  set_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    key_ = new ::std::string;
  }
  return key_;
}
inline ::std::string* Property::release_key() {
  clear_has_key();
  if (key_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = key_;
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Property::set_allocated_key(::std::string* key) {
  if (key_ != &::google::protobuf::internal::kEmptyString) {
    delete key_;
  }
  if (key) {
    set_has_key();
    key_ = key;
  } else {
    clear_has_key();
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// required string value = 2;
inline bool Property::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Property::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Property::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Property::clear_value() {
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    value_->clear();
  }
  clear_has_value();
}
inline const ::std::string& Property::value() const {
  return *value_;
}
inline void Property::set_value(const ::std::string& value) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(value);
}
inline void Property::set_value(const char* value) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(value);
}
inline void Property::set_value(const char* value, size_t size) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Property::mutable_value() {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  return value_;
}
inline ::std::string* Property::release_value() {
  clear_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = value_;
    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void Property::set_allocated_value(::std::string* value) {
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    delete value_;
  }
  if (value) {
    set_has_value();
    value_ = value;
  } else {
    clear_has_value();
    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// UserProperties

// repeated .exec.user.Property properties = 1;
inline int UserProperties::properties_size() const {
  return properties_.size();
}
inline void UserProperties::clear_properties() {
  properties_.Clear();
}
inline const ::exec::user::Property& UserProperties::properties(int index) const {
  return properties_.Get(index);
}
inline ::exec::user::Property* UserProperties::mutable_properties(int index) {
  return properties_.Mutable(index);
}
inline ::exec::user::Property* UserProperties::add_properties() {
  return properties_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::exec::user::Property >&
UserProperties::properties() const {
  return properties_;
}
inline ::google::protobuf::RepeatedPtrField< ::exec::user::Property >*
UserProperties::mutable_properties() {
  return &properties_;
}

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

// UserToBitHandshake

// optional .exec.shared.RpcChannel channel = 1 [default = USER];
inline bool UserToBitHandshake::has_channel() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void UserToBitHandshake::set_has_channel() {
  _has_bits_[0] |= 0x00000001u;
}
inline void UserToBitHandshake::clear_has_channel() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void UserToBitHandshake::clear_channel() {
  channel_ = 2;
  clear_has_channel();
}
inline ::exec::shared::RpcChannel UserToBitHandshake::channel() const {
  return static_cast< ::exec::shared::RpcChannel >(channel_);
}
inline void UserToBitHandshake::set_channel(::exec::shared::RpcChannel value) {
  assert(::exec::shared::RpcChannel_IsValid(value));
  set_has_channel();
  channel_ = value;
}

// optional bool support_listening = 2;
inline bool UserToBitHandshake::has_support_listening() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void UserToBitHandshake::set_has_support_listening() {
  _has_bits_[0] |= 0x00000002u;
}
inline void UserToBitHandshake::clear_has_support_listening() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void UserToBitHandshake::clear_support_listening() {
  support_listening_ = false;
  clear_has_support_listening();
}
inline bool UserToBitHandshake::support_listening() const {
  return support_listening_;
}
inline void UserToBitHandshake::set_support_listening(bool value) {
  set_has_support_listening();
  support_listening_ = value;
}

// optional int32 rpc_version = 3;
inline bool UserToBitHandshake::has_rpc_version() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void UserToBitHandshake::set_has_rpc_version() {
  _has_bits_[0] |= 0x00000004u;
}
inline void UserToBitHandshake::clear_has_rpc_version() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void UserToBitHandshake::clear_rpc_version() {
  rpc_version_ = 0;
  clear_has_rpc_version();
}
inline ::google::protobuf::int32 UserToBitHandshake::rpc_version() const {
  return rpc_version_;
}
inline void UserToBitHandshake::set_rpc_version(::google::protobuf::int32 value) {
  set_has_rpc_version();
  rpc_version_ = value;
}

// optional .exec.shared.UserCredentials credentials = 4;
inline bool UserToBitHandshake::has_credentials() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void UserToBitHandshake::set_has_credentials() {
  _has_bits_[0] |= 0x00000008u;
}
inline void UserToBitHandshake::clear_has_credentials() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void UserToBitHandshake::clear_credentials() {
  if (credentials_ != NULL) credentials_->::exec::shared::UserCredentials::Clear();
  clear_has_credentials();
}
inline const ::exec::shared::UserCredentials& UserToBitHandshake::credentials() const {
  return credentials_ != NULL ? *credentials_ : *default_instance_->credentials_;
}
inline ::exec::shared::UserCredentials* UserToBitHandshake::mutable_credentials() {
  set_has_credentials();
  if (credentials_ == NULL) credentials_ = new ::exec::shared::UserCredentials;
  return credentials_;
}
inline ::exec::shared::UserCredentials* UserToBitHandshake::release_credentials() {
  clear_has_credentials();
  ::exec::shared::UserCredentials* temp = credentials_;
  credentials_ = NULL;
  return temp;
}
inline void UserToBitHandshake::set_allocated_credentials(::exec::shared::UserCredentials* credentials) {
  delete credentials_;
  credentials_ = credentials;
  if (credentials) {
    set_has_credentials();
  } else {
    clear_has_credentials();
  }
}

// optional .exec.user.UserProperties properties = 5;
inline bool UserToBitHandshake::has_properties() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void UserToBitHandshake::set_has_properties() {
  _has_bits_[0] |= 0x00000010u;
}
inline void UserToBitHandshake::clear_has_properties() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void UserToBitHandshake::clear_properties() {
  if (properties_ != NULL) properties_->::exec::user::UserProperties::Clear();
  clear_has_properties();
}
inline const ::exec::user::UserProperties& UserToBitHandshake::properties() const {
  return properties_ != NULL ? *properties_ : *default_instance_->properties_;
}
inline ::exec::user::UserProperties* UserToBitHandshake::mutable_properties() {
  set_has_properties();
  if (properties_ == NULL) properties_ = new ::exec::user::UserProperties;
  return properties_;
}
inline ::exec::user::UserProperties* UserToBitHandshake::release_properties() {
  clear_has_properties();
  ::exec::user::UserProperties* temp = properties_;
  properties_ = NULL;
  return temp;
}
inline void UserToBitHandshake::set_allocated_properties(::exec::user::UserProperties* properties) {
  delete properties_;
  properties_ = properties;
  if (properties) {
    set_has_properties();
  } else {
    clear_has_properties();
  }
}

// optional bool support_complex_types = 6 [default = false];
inline bool UserToBitHandshake::has_support_complex_types() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void UserToBitHandshake::set_has_support_complex_types() {
  _has_bits_[0] |= 0x00000020u;
}
inline void UserToBitHandshake::clear_has_support_complex_types() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void UserToBitHandshake::clear_support_complex_types() {
  support_complex_types_ = false;
  clear_has_support_complex_types();
}
inline bool UserToBitHandshake::support_complex_types() const {
  return support_complex_types_;
}
inline void UserToBitHandshake::set_support_complex_types(bool value) {
  set_has_support_complex_types();
  support_complex_types_ = value;
}

// optional bool support_timeout = 7 [default = false];
inline bool UserToBitHandshake::has_support_timeout() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void UserToBitHandshake::set_has_support_timeout() {
  _has_bits_[0] |= 0x00000040u;
}
inline void UserToBitHandshake::clear_has_support_timeout() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void UserToBitHandshake::clear_support_timeout() {
  support_timeout_ = false;
  clear_has_support_timeout();
}
inline bool UserToBitHandshake::support_timeout() const {
  return support_timeout_;
}
inline void UserToBitHandshake::set_support_timeout(bool value) {
  set_has_support_timeout();
  support_timeout_ = value;
}

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

// RequestResults

// optional .exec.shared.QueryId query_id = 1;
inline bool RequestResults::has_query_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RequestResults::set_has_query_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RequestResults::clear_has_query_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RequestResults::clear_query_id() {
  if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear();
  clear_has_query_id();
}
inline const ::exec::shared::QueryId& RequestResults::query_id() const {
  return query_id_ != NULL ? *query_id_ : *default_instance_->query_id_;
}
inline ::exec::shared::QueryId* RequestResults::mutable_query_id() {
  set_has_query_id();
  if (query_id_ == NULL) query_id_ = new ::exec::shared::QueryId;
  return query_id_;
}
inline ::exec::shared::QueryId* RequestResults::release_query_id() {
  clear_has_query_id();
  ::exec::shared::QueryId* temp = query_id_;
  query_id_ = NULL;
  return temp;
}
inline void RequestResults::set_allocated_query_id(::exec::shared::QueryId* query_id) {
  delete query_id_;
  query_id_ = query_id;
  if (query_id) {
    set_has_query_id();
  } else {
    clear_has_query_id();
  }
}

// optional int32 maximum_responses = 2;
inline bool RequestResults::has_maximum_responses() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RequestResults::set_has_maximum_responses() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RequestResults::clear_has_maximum_responses() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RequestResults::clear_maximum_responses() {
  maximum_responses_ = 0;
  clear_has_maximum_responses();
}
inline ::google::protobuf::int32 RequestResults::maximum_responses() const {
  return maximum_responses_;
}
inline void RequestResults::set_maximum_responses(::google::protobuf::int32 value) {
  set_has_maximum_responses();
  maximum_responses_ = value;
}

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

// RunQuery

// optional .exec.user.QueryResultsMode results_mode = 1;
inline bool RunQuery::has_results_mode() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RunQuery::set_has_results_mode() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RunQuery::clear_has_results_mode() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RunQuery::clear_results_mode() {
  results_mode_ = 1;
  clear_has_results_mode();
}
inline ::exec::user::QueryResultsMode RunQuery::results_mode() const {
  return static_cast< ::exec::user::QueryResultsMode >(results_mode_);
}
inline void RunQuery::set_results_mode(::exec::user::QueryResultsMode value) {
  assert(::exec::user::QueryResultsMode_IsValid(value));
  set_has_results_mode();
  results_mode_ = value;
}

// optional .exec.shared.QueryType type = 2;
inline bool RunQuery::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RunQuery::set_has_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RunQuery::clear_has_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RunQuery::clear_type() {
  type_ = 1;
  clear_has_type();
}
inline ::exec::shared::QueryType RunQuery::type() const {
  return static_cast< ::exec::shared::QueryType >(type_);
}
inline void RunQuery::set_type(::exec::shared::QueryType value) {
  assert(::exec::shared::QueryType_IsValid(value));
  set_has_type();
  type_ = value;
}

// optional string plan = 3;
inline bool RunQuery::has_plan() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RunQuery::set_has_plan() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RunQuery::clear_has_plan() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void RunQuery::clear_plan() {
  if (plan_ != &::google::protobuf::internal::kEmptyString) {
    plan_->clear();
  }
  clear_has_plan();
}
inline const ::std::string& RunQuery::plan() const {
  return *plan_;
}
inline void RunQuery::set_plan(const ::std::string& value) {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  plan_->assign(value);
}
inline void RunQuery::set_plan(const char* value) {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  plan_->assign(value);
}
inline void RunQuery::set_plan(const char* value, size_t size) {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  plan_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RunQuery::mutable_plan() {
  set_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    plan_ = new ::std::string;
  }
  return plan_;
}
inline ::std::string* RunQuery::release_plan() {
  clear_has_plan();
  if (plan_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = plan_;
    plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void RunQuery::set_allocated_plan(::std::string* plan) {
  if (plan_ != &::google::protobuf::internal::kEmptyString) {
    delete plan_;
  }
  if (plan) {
    set_has_plan();
    plan_ = plan;
  } else {
    clear_has_plan();
    plan_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

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

// BitToUserHandshake

// optional int32 rpc_version = 2;
inline bool BitToUserHandshake::has_rpc_version() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BitToUserHandshake::set_has_rpc_version() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BitToUserHandshake::clear_has_rpc_version() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BitToUserHandshake::clear_rpc_version() {
  rpc_version_ = 0;
  clear_has_rpc_version();
}
inline ::google::protobuf::int32 BitToUserHandshake::rpc_version() const {
  return rpc_version_;
}
inline void BitToUserHandshake::set_rpc_version(::google::protobuf::int32 value) {
  set_has_rpc_version();
  rpc_version_ = value;
}

// optional .exec.user.HandshakeStatus status = 3;
inline bool BitToUserHandshake::has_status() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BitToUserHandshake::set_has_status() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BitToUserHandshake::clear_has_status() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BitToUserHandshake::clear_status() {
  status_ = 1;
  clear_has_status();
}
inline ::exec::user::HandshakeStatus BitToUserHandshake::status() const {
  return static_cast< ::exec::user::HandshakeStatus >(status_);
}
inline void BitToUserHandshake::set_status(::exec::user::HandshakeStatus value) {
  assert(::exec::user::HandshakeStatus_IsValid(value));
  set_has_status();
  status_ = value;
}

// optional string errorId = 4;
inline bool BitToUserHandshake::has_errorid() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BitToUserHandshake::set_has_errorid() {
  _has_bits_[0] |= 0x00000004u;
}
inline void BitToUserHandshake::clear_has_errorid() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void BitToUserHandshake::clear_errorid() {
  if (errorid_ != &::google::protobuf::internal::kEmptyString) {
    errorid_->clear();
  }
  clear_has_errorid();
}
inline const ::std::string& BitToUserHandshake::errorid() const {
  return *errorid_;
}
inline void BitToUserHandshake::set_errorid(const ::std::string& value) {
  set_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    errorid_ = new ::std::string;
  }
  errorid_->assign(value);
}
inline void BitToUserHandshake::set_errorid(const char* value) {
  set_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    errorid_ = new ::std::string;
  }
  errorid_->assign(value);
}
inline void BitToUserHandshake::set_errorid(const char* value, size_t size) {
  set_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    errorid_ = new ::std::string;
  }
  errorid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* BitToUserHandshake::mutable_errorid() {
  set_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    errorid_ = new ::std::string;
  }
  return errorid_;
}
inline ::std::string* BitToUserHandshake::release_errorid() {
  clear_has_errorid();
  if (errorid_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = errorid_;
    errorid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void BitToUserHandshake::set_allocated_errorid(::std::string* errorid) {
  if (errorid_ != &::google::protobuf::internal::kEmptyString) {
    delete errorid_;
  }
  if (errorid) {
    set_has_errorid();
    errorid_ = errorid;
  } else {
    clear_has_errorid();
    errorid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional string errorMessage = 5;
inline bool BitToUserHandshake::has_errormessage() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BitToUserHandshake::set_has_errormessage() {
  _has_bits_[0] |= 0x00000008u;
}
inline void BitToUserHandshake::clear_has_errormessage() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void BitToUserHandshake::clear_errormessage() {
  if (errormessage_ != &::google::protobuf::internal::kEmptyString) {
    errormessage_->clear();
  }
  clear_has_errormessage();
}
inline const ::std::string& BitToUserHandshake::errormessage() const {
  return *errormessage_;
}
inline void BitToUserHandshake::set_errormessage(const ::std::string& value) {
  set_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    errormessage_ = new ::std::string;
  }
  errormessage_->assign(value);
}
inline void BitToUserHandshake::set_errormessage(const char* value) {
  set_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    errormessage_ = new ::std::string;
  }
  errormessage_->assign(value);
}
inline void BitToUserHandshake::set_errormessage(const char* value, size_t size) {
  set_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    errormessage_ = new ::std::string;
  }
  errormessage_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* BitToUserHandshake::mutable_errormessage() {
  set_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    errormessage_ = new ::std::string;
  }
  return errormessage_;
}
inline ::std::string* BitToUserHandshake::release_errormessage() {
  clear_has_errormessage();
  if (errormessage_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = errormessage_;
    errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void BitToUserHandshake::set_allocated_errormessage(::std::string* errormessage) {
  if (errormessage_ != &::google::protobuf::internal::kEmptyString) {
    delete errormessage_;
  }
  if (errormessage) {
    set_has_errormessage();
    errormessage_ = errormessage;
  } else {
    clear_has_errormessage();
    errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace user
}  // namespace exec

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::RpcType>() {
  return ::exec::user::RpcType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::QueryResultsMode>() {
  return ::exec::user::QueryResultsMode_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::HandshakeStatus>() {
  return ::exec::user::HandshakeStatus_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_User_2eproto__INCLUDED