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

#ifndef PROTOBUF_RpcMessage_2eproto__INCLUDED
#define PROTOBUF_RpcMessage_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 2003000
#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 2003000 < 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/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_message_reflection.h>
// @@protoc_insertion_point(includes)

namespace ProtoBufRemote {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_RpcMessage_2eproto();
void protobuf_AssignDesc_RpcMessage_2eproto();
void protobuf_ShutdownFile_RpcMessage_2eproto();

class RpcMessage;
class RpcMessage_Call;
class RpcMessage_Result;
class RpcMessage_Parameter;

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

class RpcMessage_Call : public ::google::protobuf::Message {
 public:
  RpcMessage_Call();
  virtual ~RpcMessage_Call();
  
  RpcMessage_Call(const RpcMessage_Call& from);
  
  inline RpcMessage_Call& operator=(const RpcMessage_Call& 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 RpcMessage_Call& default_instance();
  
  void Swap(RpcMessage_Call* other);
  
  // implements Message ----------------------------------------------
  
  RpcMessage_Call* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RpcMessage_Call& from);
  void MergeFrom(const RpcMessage_Call& 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 service = 1;
  inline bool has_service() const;
  inline void clear_service();
  static const int kServiceFieldNumber = 1;
  inline const ::std::string& service() const;
  inline void set_service(const ::std::string& value);
  inline void set_service(const char* value);
  inline void set_service(const char* value, size_t size);
  inline ::std::string* mutable_service();
  
  // required string method = 2;
  inline bool has_method() const;
  inline void clear_method();
  static const int kMethodFieldNumber = 2;
  inline const ::std::string& method() const;
  inline void set_method(const ::std::string& value);
  inline void set_method(const char* value);
  inline void set_method(const char* value, size_t size);
  inline ::std::string* mutable_method();
  
  // repeated .ProtoBufRemote.RpcMessage.Parameter parameters = 3;
  inline int parameters_size() const;
  inline void clear_parameters();
  static const int kParametersFieldNumber = 3;
  inline const ::ProtoBufRemote::RpcMessage_Parameter& parameters(int index) const;
  inline ::ProtoBufRemote::RpcMessage_Parameter* mutable_parameters(int index);
  inline ::ProtoBufRemote::RpcMessage_Parameter* add_parameters();
  inline const ::google::protobuf::RepeatedPtrField< ::ProtoBufRemote::RpcMessage_Parameter >&
      parameters() const;
  inline ::google::protobuf::RepeatedPtrField< ::ProtoBufRemote::RpcMessage_Parameter >*
      mutable_parameters();
  
  // required bool expects_result = 4;
  inline bool has_expects_result() const;
  inline void clear_expects_result();
  static const int kExpectsResultFieldNumber = 4;
  inline bool expects_result() const;
  inline void set_expects_result(bool value);
  
  // @@protoc_insertion_point(class_scope:ProtoBufRemote.RpcMessage.Call)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* service_;
  static const ::std::string _default_service_;
  ::std::string* method_;
  static const ::std::string _default_method_;
  ::google::protobuf::RepeatedPtrField< ::ProtoBufRemote::RpcMessage_Parameter > parameters_;
  bool expects_result_;
  friend void  protobuf_AddDesc_RpcMessage_2eproto();
  friend void protobuf_AssignDesc_RpcMessage_2eproto();
  friend void protobuf_ShutdownFile_RpcMessage_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static RpcMessage_Call* default_instance_;
};
// -------------------------------------------------------------------

class RpcMessage_Result : public ::google::protobuf::Message {
 public:
  RpcMessage_Result();
  virtual ~RpcMessage_Result();
  
  RpcMessage_Result(const RpcMessage_Result& from);
  
  inline RpcMessage_Result& operator=(const RpcMessage_Result& 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 RpcMessage_Result& default_instance();
  
  void Swap(RpcMessage_Result* other);
  
  // implements Message ----------------------------------------------
  
  RpcMessage_Result* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RpcMessage_Result& from);
  void MergeFrom(const RpcMessage_Result& 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 bool is_failed = 1;
  inline bool has_is_failed() const;
  inline void clear_is_failed();
  static const int kIsFailedFieldNumber = 1;
  inline bool is_failed() const;
  inline void set_is_failed(bool value);
  
  // optional string error_message = 2;
  inline bool has_error_message() const;
  inline void clear_error_message();
  static const int kErrorMessageFieldNumber = 2;
  inline const ::std::string& error_message() const;
  inline void set_error_message(const ::std::string& value);
  inline void set_error_message(const char* value);
  inline void set_error_message(const char* value, size_t size);
  inline ::std::string* mutable_error_message();
  
  // optional .ProtoBufRemote.RpcMessage.Parameter call_result = 3;
  inline bool has_call_result() const;
  inline void clear_call_result();
  static const int kCallResultFieldNumber = 3;
  inline const ::ProtoBufRemote::RpcMessage_Parameter& call_result() const;
  inline ::ProtoBufRemote::RpcMessage_Parameter* mutable_call_result();
  
  // @@protoc_insertion_point(class_scope:ProtoBufRemote.RpcMessage.Result)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  bool is_failed_;
  ::std::string* error_message_;
  static const ::std::string _default_error_message_;
  ::ProtoBufRemote::RpcMessage_Parameter* call_result_;
  friend void  protobuf_AddDesc_RpcMessage_2eproto();
  friend void protobuf_AssignDesc_RpcMessage_2eproto();
  friend void protobuf_ShutdownFile_RpcMessage_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static RpcMessage_Result* default_instance_;
};
// -------------------------------------------------------------------

class RpcMessage_Parameter : public ::google::protobuf::Message {
 public:
  RpcMessage_Parameter();
  virtual ~RpcMessage_Parameter();
  
  RpcMessage_Parameter(const RpcMessage_Parameter& from);
  
  inline RpcMessage_Parameter& operator=(const RpcMessage_Parameter& 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 RpcMessage_Parameter& default_instance();
  
  void Swap(RpcMessage_Parameter* other);
  
  // implements Message ----------------------------------------------
  
  RpcMessage_Parameter* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RpcMessage_Parameter& from);
  void MergeFrom(const RpcMessage_Parameter& 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 bytes proto_param = 1;
  inline bool has_proto_param() const;
  inline void clear_proto_param();
  static const int kProtoParamFieldNumber = 1;
  inline const ::std::string& proto_param() const;
  inline void set_proto_param(const ::std::string& value);
  inline void set_proto_param(const char* value);
  inline void set_proto_param(const void* value, size_t size);
  inline ::std::string* mutable_proto_param();
  
  // optional string string_param = 2;
  inline bool has_string_param() const;
  inline void clear_string_param();
  static const int kStringParamFieldNumber = 2;
  inline const ::std::string& string_param() const;
  inline void set_string_param(const ::std::string& value);
  inline void set_string_param(const char* value);
  inline void set_string_param(const char* value, size_t size);
  inline ::std::string* mutable_string_param();
  
  // optional sint32 int_param = 3;
  inline bool has_int_param() const;
  inline void clear_int_param();
  static const int kIntParamFieldNumber = 3;
  inline ::google::protobuf::int32 int_param() const;
  inline void set_int_param(::google::protobuf::int32 value);
  
  // optional uint32 uint_param = 4;
  inline bool has_uint_param() const;
  inline void clear_uint_param();
  static const int kUintParamFieldNumber = 4;
  inline ::google::protobuf::uint32 uint_param() const;
  inline void set_uint_param(::google::protobuf::uint32 value);
  
  // optional sint64 int64_param = 5;
  inline bool has_int64_param() const;
  inline void clear_int64_param();
  static const int kInt64ParamFieldNumber = 5;
  inline ::google::protobuf::int64 int64_param() const;
  inline void set_int64_param(::google::protobuf::int64 value);
  
  // optional uint64 uint64_param = 6;
  inline bool has_uint64_param() const;
  inline void clear_uint64_param();
  static const int kUint64ParamFieldNumber = 6;
  inline ::google::protobuf::uint64 uint64_param() const;
  inline void set_uint64_param(::google::protobuf::uint64 value);
  
  // optional bool bool_param = 7;
  inline bool has_bool_param() const;
  inline void clear_bool_param();
  static const int kBoolParamFieldNumber = 7;
  inline bool bool_param() const;
  inline void set_bool_param(bool value);
  
  // optional float float_param = 8;
  inline bool has_float_param() const;
  inline void clear_float_param();
  static const int kFloatParamFieldNumber = 8;
  inline float float_param() const;
  inline void set_float_param(float value);
  
  // optional double double_param = 9;
  inline bool has_double_param() const;
  inline void clear_double_param();
  static const int kDoubleParamFieldNumber = 9;
  inline double double_param() const;
  inline void set_double_param(double value);
  
  // optional bool is_null = 10;
  inline bool has_is_null() const;
  inline void clear_is_null();
  static const int kIsNullFieldNumber = 10;
  inline bool is_null() const;
  inline void set_is_null(bool value);
  
  // @@protoc_insertion_point(class_scope:ProtoBufRemote.RpcMessage.Parameter)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* proto_param_;
  static const ::std::string _default_proto_param_;
  ::std::string* string_param_;
  static const ::std::string _default_string_param_;
  ::google::protobuf::int32 int_param_;
  ::google::protobuf::uint32 uint_param_;
  ::google::protobuf::int64 int64_param_;
  ::google::protobuf::uint64 uint64_param_;
  bool bool_param_;
  float float_param_;
  double double_param_;
  bool is_null_;
  friend void  protobuf_AddDesc_RpcMessage_2eproto();
  friend void protobuf_AssignDesc_RpcMessage_2eproto();
  friend void protobuf_ShutdownFile_RpcMessage_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(10 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static RpcMessage_Parameter* default_instance_;
};
// -------------------------------------------------------------------

class RpcMessage : public ::google::protobuf::Message {
 public:
  RpcMessage();
  virtual ~RpcMessage();
  
  RpcMessage(const RpcMessage& from);
  
  inline RpcMessage& operator=(const RpcMessage& 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 RpcMessage& default_instance();
  
  void Swap(RpcMessage* other);
  
  // implements Message ----------------------------------------------
  
  RpcMessage* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RpcMessage& from);
  void MergeFrom(const RpcMessage& 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 ----------------------------------------------------
  
  typedef RpcMessage_Call Call;
  typedef RpcMessage_Result Result;
  typedef RpcMessage_Parameter Parameter;
  
  // accessors -------------------------------------------------------
  
  // required int32 id = 1;
  inline bool has_id() const;
  inline void clear_id();
  static const int kIdFieldNumber = 1;
  inline ::google::protobuf::int32 id() const;
  inline void set_id(::google::protobuf::int32 value);
  
  // optional .ProtoBufRemote.RpcMessage.Call call_message = 2;
  inline bool has_call_message() const;
  inline void clear_call_message();
  static const int kCallMessageFieldNumber = 2;
  inline const ::ProtoBufRemote::RpcMessage_Call& call_message() const;
  inline ::ProtoBufRemote::RpcMessage_Call* mutable_call_message();
  
  // optional .ProtoBufRemote.RpcMessage.Result result_message = 3;
  inline bool has_result_message() const;
  inline void clear_result_message();
  static const int kResultMessageFieldNumber = 3;
  inline const ::ProtoBufRemote::RpcMessage_Result& result_message() const;
  inline ::ProtoBufRemote::RpcMessage_Result* mutable_result_message();
  
  // @@protoc_insertion_point(class_scope:ProtoBufRemote.RpcMessage)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::int32 id_;
  ::ProtoBufRemote::RpcMessage_Call* call_message_;
  ::ProtoBufRemote::RpcMessage_Result* result_message_;
  friend void  protobuf_AddDesc_RpcMessage_2eproto();
  friend void protobuf_AssignDesc_RpcMessage_2eproto();
  friend void protobuf_ShutdownFile_RpcMessage_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static RpcMessage* default_instance_;
};
// ===================================================================


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

// RpcMessage_Call

// required string service = 1;
inline bool RpcMessage_Call::has_service() const {
  return _has_bit(0);
}
inline void RpcMessage_Call::clear_service() {
  if (service_ != &_default_service_) {
    service_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& RpcMessage_Call::service() const {
  return *service_;
}
inline void RpcMessage_Call::set_service(const ::std::string& value) {
  _set_bit(0);
  if (service_ == &_default_service_) {
    service_ = new ::std::string;
  }
  service_->assign(value);
}
inline void RpcMessage_Call::set_service(const char* value) {
  _set_bit(0);
  if (service_ == &_default_service_) {
    service_ = new ::std::string;
  }
  service_->assign(value);
}
inline void RpcMessage_Call::set_service(const char* value, size_t size) {
  _set_bit(0);
  if (service_ == &_default_service_) {
    service_ = new ::std::string;
  }
  service_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RpcMessage_Call::mutable_service() {
  _set_bit(0);
  if (service_ == &_default_service_) {
    service_ = new ::std::string;
  }
  return service_;
}

// required string method = 2;
inline bool RpcMessage_Call::has_method() const {
  return _has_bit(1);
}
inline void RpcMessage_Call::clear_method() {
  if (method_ != &_default_method_) {
    method_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& RpcMessage_Call::method() const {
  return *method_;
}
inline void RpcMessage_Call::set_method(const ::std::string& value) {
  _set_bit(1);
  if (method_ == &_default_method_) {
    method_ = new ::std::string;
  }
  method_->assign(value);
}
inline void RpcMessage_Call::set_method(const char* value) {
  _set_bit(1);
  if (method_ == &_default_method_) {
    method_ = new ::std::string;
  }
  method_->assign(value);
}
inline void RpcMessage_Call::set_method(const char* value, size_t size) {
  _set_bit(1);
  if (method_ == &_default_method_) {
    method_ = new ::std::string;
  }
  method_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RpcMessage_Call::mutable_method() {
  _set_bit(1);
  if (method_ == &_default_method_) {
    method_ = new ::std::string;
  }
  return method_;
}

// repeated .ProtoBufRemote.RpcMessage.Parameter parameters = 3;
inline int RpcMessage_Call::parameters_size() const {
  return parameters_.size();
}
inline void RpcMessage_Call::clear_parameters() {
  parameters_.Clear();
}
inline const ::ProtoBufRemote::RpcMessage_Parameter& RpcMessage_Call::parameters(int index) const {
  return parameters_.Get(index);
}
inline ::ProtoBufRemote::RpcMessage_Parameter* RpcMessage_Call::mutable_parameters(int index) {
  return parameters_.Mutable(index);
}
inline ::ProtoBufRemote::RpcMessage_Parameter* RpcMessage_Call::add_parameters() {
  return parameters_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::ProtoBufRemote::RpcMessage_Parameter >&
RpcMessage_Call::parameters() const {
  return parameters_;
}
inline ::google::protobuf::RepeatedPtrField< ::ProtoBufRemote::RpcMessage_Parameter >*
RpcMessage_Call::mutable_parameters() {
  return &parameters_;
}

// required bool expects_result = 4;
inline bool RpcMessage_Call::has_expects_result() const {
  return _has_bit(3);
}
inline void RpcMessage_Call::clear_expects_result() {
  expects_result_ = false;
  _clear_bit(3);
}
inline bool RpcMessage_Call::expects_result() const {
  return expects_result_;
}
inline void RpcMessage_Call::set_expects_result(bool value) {
  _set_bit(3);
  expects_result_ = value;
}

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

// RpcMessage_Result

// optional bool is_failed = 1;
inline bool RpcMessage_Result::has_is_failed() const {
  return _has_bit(0);
}
inline void RpcMessage_Result::clear_is_failed() {
  is_failed_ = false;
  _clear_bit(0);
}
inline bool RpcMessage_Result::is_failed() const {
  return is_failed_;
}
inline void RpcMessage_Result::set_is_failed(bool value) {
  _set_bit(0);
  is_failed_ = value;
}

// optional string error_message = 2;
inline bool RpcMessage_Result::has_error_message() const {
  return _has_bit(1);
}
inline void RpcMessage_Result::clear_error_message() {
  if (error_message_ != &_default_error_message_) {
    error_message_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& RpcMessage_Result::error_message() const {
  return *error_message_;
}
inline void RpcMessage_Result::set_error_message(const ::std::string& value) {
  _set_bit(1);
  if (error_message_ == &_default_error_message_) {
    error_message_ = new ::std::string;
  }
  error_message_->assign(value);
}
inline void RpcMessage_Result::set_error_message(const char* value) {
  _set_bit(1);
  if (error_message_ == &_default_error_message_) {
    error_message_ = new ::std::string;
  }
  error_message_->assign(value);
}
inline void RpcMessage_Result::set_error_message(const char* value, size_t size) {
  _set_bit(1);
  if (error_message_ == &_default_error_message_) {
    error_message_ = new ::std::string;
  }
  error_message_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RpcMessage_Result::mutable_error_message() {
  _set_bit(1);
  if (error_message_ == &_default_error_message_) {
    error_message_ = new ::std::string;
  }
  return error_message_;
}

// optional .ProtoBufRemote.RpcMessage.Parameter call_result = 3;
inline bool RpcMessage_Result::has_call_result() const {
  return _has_bit(2);
}
inline void RpcMessage_Result::clear_call_result() {
  if (call_result_ != NULL) call_result_->::ProtoBufRemote::RpcMessage_Parameter::Clear();
  _clear_bit(2);
}
inline const ::ProtoBufRemote::RpcMessage_Parameter& RpcMessage_Result::call_result() const {
  return call_result_ != NULL ? *call_result_ : *default_instance_->call_result_;
}
inline ::ProtoBufRemote::RpcMessage_Parameter* RpcMessage_Result::mutable_call_result() {
  _set_bit(2);
  if (call_result_ == NULL) call_result_ = new ::ProtoBufRemote::RpcMessage_Parameter;
  return call_result_;
}

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

// RpcMessage_Parameter

// optional bytes proto_param = 1;
inline bool RpcMessage_Parameter::has_proto_param() const {
  return _has_bit(0);
}
inline void RpcMessage_Parameter::clear_proto_param() {
  if (proto_param_ != &_default_proto_param_) {
    proto_param_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& RpcMessage_Parameter::proto_param() const {
  return *proto_param_;
}
inline void RpcMessage_Parameter::set_proto_param(const ::std::string& value) {
  _set_bit(0);
  if (proto_param_ == &_default_proto_param_) {
    proto_param_ = new ::std::string;
  }
  proto_param_->assign(value);
}
inline void RpcMessage_Parameter::set_proto_param(const char* value) {
  _set_bit(0);
  if (proto_param_ == &_default_proto_param_) {
    proto_param_ = new ::std::string;
  }
  proto_param_->assign(value);
}
inline void RpcMessage_Parameter::set_proto_param(const void* value, size_t size) {
  _set_bit(0);
  if (proto_param_ == &_default_proto_param_) {
    proto_param_ = new ::std::string;
  }
  proto_param_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RpcMessage_Parameter::mutable_proto_param() {
  _set_bit(0);
  if (proto_param_ == &_default_proto_param_) {
    proto_param_ = new ::std::string;
  }
  return proto_param_;
}

// optional string string_param = 2;
inline bool RpcMessage_Parameter::has_string_param() const {
  return _has_bit(1);
}
inline void RpcMessage_Parameter::clear_string_param() {
  if (string_param_ != &_default_string_param_) {
    string_param_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& RpcMessage_Parameter::string_param() const {
  return *string_param_;
}
inline void RpcMessage_Parameter::set_string_param(const ::std::string& value) {
  _set_bit(1);
  if (string_param_ == &_default_string_param_) {
    string_param_ = new ::std::string;
  }
  string_param_->assign(value);
}
inline void RpcMessage_Parameter::set_string_param(const char* value) {
  _set_bit(1);
  if (string_param_ == &_default_string_param_) {
    string_param_ = new ::std::string;
  }
  string_param_->assign(value);
}
inline void RpcMessage_Parameter::set_string_param(const char* value, size_t size) {
  _set_bit(1);
  if (string_param_ == &_default_string_param_) {
    string_param_ = new ::std::string;
  }
  string_param_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RpcMessage_Parameter::mutable_string_param() {
  _set_bit(1);
  if (string_param_ == &_default_string_param_) {
    string_param_ = new ::std::string;
  }
  return string_param_;
}

// optional sint32 int_param = 3;
inline bool RpcMessage_Parameter::has_int_param() const {
  return _has_bit(2);
}
inline void RpcMessage_Parameter::clear_int_param() {
  int_param_ = 0;
  _clear_bit(2);
}
inline ::google::protobuf::int32 RpcMessage_Parameter::int_param() const {
  return int_param_;
}
inline void RpcMessage_Parameter::set_int_param(::google::protobuf::int32 value) {
  _set_bit(2);
  int_param_ = value;
}

// optional uint32 uint_param = 4;
inline bool RpcMessage_Parameter::has_uint_param() const {
  return _has_bit(3);
}
inline void RpcMessage_Parameter::clear_uint_param() {
  uint_param_ = 0u;
  _clear_bit(3);
}
inline ::google::protobuf::uint32 RpcMessage_Parameter::uint_param() const {
  return uint_param_;
}
inline void RpcMessage_Parameter::set_uint_param(::google::protobuf::uint32 value) {
  _set_bit(3);
  uint_param_ = value;
}

// optional sint64 int64_param = 5;
inline bool RpcMessage_Parameter::has_int64_param() const {
  return _has_bit(4);
}
inline void RpcMessage_Parameter::clear_int64_param() {
  int64_param_ = GOOGLE_LONGLONG(0);
  _clear_bit(4);
}
inline ::google::protobuf::int64 RpcMessage_Parameter::int64_param() const {
  return int64_param_;
}
inline void RpcMessage_Parameter::set_int64_param(::google::protobuf::int64 value) {
  _set_bit(4);
  int64_param_ = value;
}

// optional uint64 uint64_param = 6;
inline bool RpcMessage_Parameter::has_uint64_param() const {
  return _has_bit(5);
}
inline void RpcMessage_Parameter::clear_uint64_param() {
  uint64_param_ = GOOGLE_ULONGLONG(0);
  _clear_bit(5);
}
inline ::google::protobuf::uint64 RpcMessage_Parameter::uint64_param() const {
  return uint64_param_;
}
inline void RpcMessage_Parameter::set_uint64_param(::google::protobuf::uint64 value) {
  _set_bit(5);
  uint64_param_ = value;
}

// optional bool bool_param = 7;
inline bool RpcMessage_Parameter::has_bool_param() const {
  return _has_bit(6);
}
inline void RpcMessage_Parameter::clear_bool_param() {
  bool_param_ = false;
  _clear_bit(6);
}
inline bool RpcMessage_Parameter::bool_param() const {
  return bool_param_;
}
inline void RpcMessage_Parameter::set_bool_param(bool value) {
  _set_bit(6);
  bool_param_ = value;
}

// optional float float_param = 8;
inline bool RpcMessage_Parameter::has_float_param() const {
  return _has_bit(7);
}
inline void RpcMessage_Parameter::clear_float_param() {
  float_param_ = 0;
  _clear_bit(7);
}
inline float RpcMessage_Parameter::float_param() const {
  return float_param_;
}
inline void RpcMessage_Parameter::set_float_param(float value) {
  _set_bit(7);
  float_param_ = value;
}

// optional double double_param = 9;
inline bool RpcMessage_Parameter::has_double_param() const {
  return _has_bit(8);
}
inline void RpcMessage_Parameter::clear_double_param() {
  double_param_ = 0;
  _clear_bit(8);
}
inline double RpcMessage_Parameter::double_param() const {
  return double_param_;
}
inline void RpcMessage_Parameter::set_double_param(double value) {
  _set_bit(8);
  double_param_ = value;
}

// optional bool is_null = 10;
inline bool RpcMessage_Parameter::has_is_null() const {
  return _has_bit(9);
}
inline void RpcMessage_Parameter::clear_is_null() {
  is_null_ = false;
  _clear_bit(9);
}
inline bool RpcMessage_Parameter::is_null() const {
  return is_null_;
}
inline void RpcMessage_Parameter::set_is_null(bool value) {
  _set_bit(9);
  is_null_ = value;
}

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

// RpcMessage

// required int32 id = 1;
inline bool RpcMessage::has_id() const {
  return _has_bit(0);
}
inline void RpcMessage::clear_id() {
  id_ = 0;
  _clear_bit(0);
}
inline ::google::protobuf::int32 RpcMessage::id() const {
  return id_;
}
inline void RpcMessage::set_id(::google::protobuf::int32 value) {
  _set_bit(0);
  id_ = value;
}

// optional .ProtoBufRemote.RpcMessage.Call call_message = 2;
inline bool RpcMessage::has_call_message() const {
  return _has_bit(1);
}
inline void RpcMessage::clear_call_message() {
  if (call_message_ != NULL) call_message_->::ProtoBufRemote::RpcMessage_Call::Clear();
  _clear_bit(1);
}
inline const ::ProtoBufRemote::RpcMessage_Call& RpcMessage::call_message() const {
  return call_message_ != NULL ? *call_message_ : *default_instance_->call_message_;
}
inline ::ProtoBufRemote::RpcMessage_Call* RpcMessage::mutable_call_message() {
  _set_bit(1);
  if (call_message_ == NULL) call_message_ = new ::ProtoBufRemote::RpcMessage_Call;
  return call_message_;
}

// optional .ProtoBufRemote.RpcMessage.Result result_message = 3;
inline bool RpcMessage::has_result_message() const {
  return _has_bit(2);
}
inline void RpcMessage::clear_result_message() {
  if (result_message_ != NULL) result_message_->::ProtoBufRemote::RpcMessage_Result::Clear();
  _clear_bit(2);
}
inline const ::ProtoBufRemote::RpcMessage_Result& RpcMessage::result_message() const {
  return result_message_ != NULL ? *result_message_ : *default_instance_->result_message_;
}
inline ::ProtoBufRemote::RpcMessage_Result* RpcMessage::mutable_result_message() {
  _set_bit(2);
  if (result_message_ == NULL) result_message_ = new ::ProtoBufRemote::RpcMessage_Result;
  return result_message_;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace ProtoBufRemote

#ifndef SWIG
namespace google {
namespace protobuf {


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

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_RpcMessage_2eproto__INCLUDED