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

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

#include <algorithm>

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

namespace coprocess {

namespace {

const ::google::protobuf::Descriptor* MiniRequestObject_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  MiniRequestObject_reflection_ = NULL;
const ::google::protobuf::Descriptor* MiniRequestObject_HeadersEntry_descriptor_ = NULL;
const ::google::protobuf::Descriptor* MiniRequestObject_SetHeadersEntry_descriptor_ = NULL;
const ::google::protobuf::Descriptor* MiniRequestObject_ParamsEntry_descriptor_ = NULL;
const ::google::protobuf::Descriptor* MiniRequestObject_AddParamsEntry_descriptor_ = NULL;
const ::google::protobuf::Descriptor* MiniRequestObject_ExtendedParamsEntry_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_coprocess_5fmini_5frequest_5fobject_2eproto() GOOGLE_ATTRIBUTE_COLD;
void protobuf_AssignDesc_coprocess_5fmini_5frequest_5fobject_2eproto() {
  protobuf_AddDesc_coprocess_5fmini_5frequest_5fobject_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "coprocess_mini_request_object.proto");
  GOOGLE_CHECK(file != NULL);
  MiniRequestObject_descriptor_ = file->message_type(0);
  static const int MiniRequestObject_offsets_[10] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MiniRequestObject, headers_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MiniRequestObject, set_headers_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MiniRequestObject, delete_headers_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MiniRequestObject, body_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MiniRequestObject, url_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MiniRequestObject, params_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MiniRequestObject, add_params_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MiniRequestObject, extended_params_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MiniRequestObject, delete_params_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MiniRequestObject, return_overrides_),
  };
  MiniRequestObject_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      MiniRequestObject_descriptor_,
      MiniRequestObject::internal_default_instance(),
      MiniRequestObject_offsets_,
      -1,
      -1,
      -1,
      sizeof(MiniRequestObject),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MiniRequestObject, _internal_metadata_));
  MiniRequestObject_HeadersEntry_descriptor_ = MiniRequestObject_descriptor_->nested_type(0);
  MiniRequestObject_SetHeadersEntry_descriptor_ = MiniRequestObject_descriptor_->nested_type(1);
  MiniRequestObject_ParamsEntry_descriptor_ = MiniRequestObject_descriptor_->nested_type(2);
  MiniRequestObject_AddParamsEntry_descriptor_ = MiniRequestObject_descriptor_->nested_type(3);
  MiniRequestObject_ExtendedParamsEntry_descriptor_ = MiniRequestObject_descriptor_->nested_type(4);
}

namespace {

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

void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD;
void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      MiniRequestObject_descriptor_, MiniRequestObject::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
        MiniRequestObject_HeadersEntry_descriptor_,
        ::google::protobuf::internal::MapEntry<
            ::std::string,
            ::std::string,
            ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
            ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
            0>::CreateDefaultInstance(
                MiniRequestObject_HeadersEntry_descriptor_));
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
        MiniRequestObject_SetHeadersEntry_descriptor_,
        ::google::protobuf::internal::MapEntry<
            ::std::string,
            ::std::string,
            ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
            ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
            0>::CreateDefaultInstance(
                MiniRequestObject_SetHeadersEntry_descriptor_));
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
        MiniRequestObject_ParamsEntry_descriptor_,
        ::google::protobuf::internal::MapEntry<
            ::std::string,
            ::std::string,
            ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
            ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
            0>::CreateDefaultInstance(
                MiniRequestObject_ParamsEntry_descriptor_));
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
        MiniRequestObject_AddParamsEntry_descriptor_,
        ::google::protobuf::internal::MapEntry<
            ::std::string,
            ::std::string,
            ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
            ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
            0>::CreateDefaultInstance(
                MiniRequestObject_AddParamsEntry_descriptor_));
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
        MiniRequestObject_ExtendedParamsEntry_descriptor_,
        ::google::protobuf::internal::MapEntry<
            ::std::string,
            ::std::string,
            ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
            ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
            0>::CreateDefaultInstance(
                MiniRequestObject_ExtendedParamsEntry_descriptor_));
}

}  // namespace

void protobuf_ShutdownFile_coprocess_5fmini_5frequest_5fobject_2eproto() {
  MiniRequestObject_default_instance_.Shutdown();
  delete MiniRequestObject_reflection_;
}

void protobuf_InitDefaults_coprocess_5fmini_5frequest_5fobject_2eproto_impl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::coprocess::protobuf_InitDefaults_coprocess_5freturn_5foverrides_2eproto();
  ::google::protobuf::internal::GetEmptyString();
  MiniRequestObject_default_instance_.DefaultConstruct();
  ::google::protobuf::internal::GetEmptyString();
  ::google::protobuf::internal::GetEmptyString();
  ::google::protobuf::internal::GetEmptyString();
  MiniRequestObject_default_instance_.get_mutable()->InitAsDefaultInstance();
}

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_coprocess_5fmini_5frequest_5fobject_2eproto_once_);
void protobuf_InitDefaults_coprocess_5fmini_5frequest_5fobject_2eproto() {
  ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_coprocess_5fmini_5frequest_5fobject_2eproto_once_,
                 &protobuf_InitDefaults_coprocess_5fmini_5frequest_5fobject_2eproto_impl);
}
void protobuf_AddDesc_coprocess_5fmini_5frequest_5fobject_2eproto_impl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  protobuf_InitDefaults_coprocess_5fmini_5frequest_5fobject_2eproto();
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n#coprocess_mini_request_object.proto\022\tc"
    "oprocess\032 coprocess_return_overrides.pro"
    "to\"\323\005\n\021MiniRequestObject\022:\n\007headers\030\001 \003("
    "\0132).coprocess.MiniRequestObject.HeadersE"
    "ntry\022A\n\013set_headers\030\002 \003(\0132,.coprocess.Mi"
    "niRequestObject.SetHeadersEntry\022\026\n\016delet"
    "e_headers\030\003 \003(\t\022\014\n\004body\030\004 \001(\t\022\013\n\003url\030\005 \001"
    "(\t\0228\n\006params\030\006 \003(\0132(.coprocess.MiniReque"
    "stObject.ParamsEntry\022\?\n\nadd_params\030\007 \003(\013"
    "2+.coprocess.MiniRequestObject.AddParams"
    "Entry\022I\n\017extended_params\030\010 \003(\01320.coproce"
    "ss.MiniRequestObject.ExtendedParamsEntry"
    "\022\025\n\rdelete_params\030\t \003(\t\0224\n\020return_overri"
    "des\030\n \001(\0132\032.coprocess.ReturnOverrides\032.\n"
    "\014HeadersEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001("
    "\t:\0028\001\0321\n\017SetHeadersEntry\022\013\n\003key\030\001 \001(\t\022\r\n"
    "\005value\030\002 \001(\t:\0028\001\032-\n\013ParamsEntry\022\013\n\003key\030\001"
    " \001(\t\022\r\n\005value\030\002 \001(\t:\0028\001\0320\n\016AddParamsEntr"
    "y\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\t:\0028\001\0325\n\023Ext"
    "endedParamsEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002"
    " \001(\t:\0028\001b\006proto3", 816);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "coprocess_mini_request_object.proto", &protobuf_RegisterTypes);
  ::coprocess::protobuf_AddDesc_coprocess_5freturn_5foverrides_2eproto();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_coprocess_5fmini_5frequest_5fobject_2eproto);
}

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_coprocess_5fmini_5frequest_5fobject_2eproto_once_);
void protobuf_AddDesc_coprocess_5fmini_5frequest_5fobject_2eproto() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_coprocess_5fmini_5frequest_5fobject_2eproto_once_,
                 &protobuf_AddDesc_coprocess_5fmini_5frequest_5fobject_2eproto_impl);
}
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_coprocess_5fmini_5frequest_5fobject_2eproto {
  StaticDescriptorInitializer_coprocess_5fmini_5frequest_5fobject_2eproto() {
    protobuf_AddDesc_coprocess_5fmini_5frequest_5fobject_2eproto();
  }
} static_descriptor_initializer_coprocess_5fmini_5frequest_5fobject_2eproto_;

namespace {

static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN;
static void MergeFromFail(int line) {
  ::google::protobuf::internal::MergeFromFail(__FILE__, line);
}

}  // namespace


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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int MiniRequestObject::kHeadersFieldNumber;
const int MiniRequestObject::kSetHeadersFieldNumber;
const int MiniRequestObject::kDeleteHeadersFieldNumber;
const int MiniRequestObject::kBodyFieldNumber;
const int MiniRequestObject::kUrlFieldNumber;
const int MiniRequestObject::kParamsFieldNumber;
const int MiniRequestObject::kAddParamsFieldNumber;
const int MiniRequestObject::kExtendedParamsFieldNumber;
const int MiniRequestObject::kDeleteParamsFieldNumber;
const int MiniRequestObject::kReturnOverridesFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

MiniRequestObject::MiniRequestObject()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_coprocess_5fmini_5frequest_5fobject_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:coprocess.MiniRequestObject)
}

void MiniRequestObject::InitAsDefaultInstance() {
  return_overrides_ = const_cast< ::coprocess::ReturnOverrides*>(
      ::coprocess::ReturnOverrides::internal_default_instance());
}

MiniRequestObject::MiniRequestObject(const MiniRequestObject& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:coprocess.MiniRequestObject)
}

void MiniRequestObject::SharedCtor() {
  headers_.SetAssignDescriptorCallback(
      protobuf_AssignDescriptorsOnce);
  headers_.SetEntryDescriptor(
      &::coprocess::MiniRequestObject_HeadersEntry_descriptor_);
  set_headers_.SetAssignDescriptorCallback(
      protobuf_AssignDescriptorsOnce);
  set_headers_.SetEntryDescriptor(
      &::coprocess::MiniRequestObject_SetHeadersEntry_descriptor_);
  params_.SetAssignDescriptorCallback(
      protobuf_AssignDescriptorsOnce);
  params_.SetEntryDescriptor(
      &::coprocess::MiniRequestObject_ParamsEntry_descriptor_);
  add_params_.SetAssignDescriptorCallback(
      protobuf_AssignDescriptorsOnce);
  add_params_.SetEntryDescriptor(
      &::coprocess::MiniRequestObject_AddParamsEntry_descriptor_);
  extended_params_.SetAssignDescriptorCallback(
      protobuf_AssignDescriptorsOnce);
  extended_params_.SetEntryDescriptor(
      &::coprocess::MiniRequestObject_ExtendedParamsEntry_descriptor_);
  body_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  url_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  return_overrides_ = NULL;
  _cached_size_ = 0;
}

MiniRequestObject::~MiniRequestObject() {
  // @@protoc_insertion_point(destructor:coprocess.MiniRequestObject)
  SharedDtor();
}

void MiniRequestObject::SharedDtor() {
  body_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  url_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != &MiniRequestObject_default_instance_.get()) {
    delete return_overrides_;
  }
}

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

const MiniRequestObject& MiniRequestObject::default_instance() {
  protobuf_InitDefaults_coprocess_5fmini_5frequest_5fobject_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<MiniRequestObject> MiniRequestObject_default_instance_;

MiniRequestObject* MiniRequestObject::New(::google::protobuf::Arena* arena) const {
  MiniRequestObject* n = new MiniRequestObject;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void MiniRequestObject::Clear() {
// @@protoc_insertion_point(message_clear_start:coprocess.MiniRequestObject)
  body_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  url_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (GetArenaNoVirtual() == NULL && return_overrides_ != NULL) delete return_overrides_;
  return_overrides_ = NULL;
  headers_.Clear();
  set_headers_.Clear();
  delete_headers_.Clear();
  params_.Clear();
  add_params_.Clear();
  extended_params_.Clear();
  delete_params_.Clear();
}

bool MiniRequestObject::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:coprocess.MiniRequestObject)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // map<string, string> headers = 1;
      case 1: {
        if (tag == 10) {
          DO_(input->IncrementRecursionDepth());
         parse_loop_headers:
          MiniRequestObject_HeadersEntry::Parser< ::google::protobuf::internal::MapField<
              ::std::string, ::std::string,
              ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
              ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
              0 >,
            ::google::protobuf::Map< ::std::string, ::std::string > > parser(&headers_);
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
              input, &parser));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            parser.key().data(), parser.key().length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.HeadersEntry.key"));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            parser.value().data(), parser.value().length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.HeadersEntry.value"));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_loop_headers;
        if (input->ExpectTag(18)) goto parse_loop_set_headers;
        input->UnsafeDecrementRecursionDepth();
        break;
      }

      // map<string, string> set_headers = 2;
      case 2: {
        if (tag == 18) {
          DO_(input->IncrementRecursionDepth());
         parse_loop_set_headers:
          MiniRequestObject_SetHeadersEntry::Parser< ::google::protobuf::internal::MapField<
              ::std::string, ::std::string,
              ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
              ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
              0 >,
            ::google::protobuf::Map< ::std::string, ::std::string > > parser(&set_headers_);
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
              input, &parser));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            parser.key().data(), parser.key().length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.SetHeadersEntry.key"));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            parser.value().data(), parser.value().length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.SetHeadersEntry.value"));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_loop_set_headers;
        input->UnsafeDecrementRecursionDepth();
        if (input->ExpectTag(26)) goto parse_delete_headers;
        break;
      }

      // repeated string delete_headers = 3;
      case 3: {
        if (tag == 26) {
         parse_delete_headers:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_delete_headers()));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            this->delete_headers(this->delete_headers_size() - 1).data(),
            this->delete_headers(this->delete_headers_size() - 1).length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.delete_headers"));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_delete_headers;
        if (input->ExpectTag(34)) goto parse_body;
        break;
      }

      // optional string body = 4;
      case 4: {
        if (tag == 34) {
         parse_body:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_body()));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            this->body().data(), this->body().length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.body"));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_url;
        break;
      }

      // optional string url = 5;
      case 5: {
        if (tag == 42) {
         parse_url:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_url()));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            this->url().data(), this->url().length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.url"));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_params;
        break;
      }

      // map<string, string> params = 6;
      case 6: {
        if (tag == 50) {
         parse_params:
          DO_(input->IncrementRecursionDepth());
         parse_loop_params:
          MiniRequestObject_ParamsEntry::Parser< ::google::protobuf::internal::MapField<
              ::std::string, ::std::string,
              ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
              ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
              0 >,
            ::google::protobuf::Map< ::std::string, ::std::string > > parser(&params_);
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
              input, &parser));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            parser.key().data(), parser.key().length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.ParamsEntry.key"));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            parser.value().data(), parser.value().length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.ParamsEntry.value"));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_loop_params;
        if (input->ExpectTag(58)) goto parse_loop_add_params;
        input->UnsafeDecrementRecursionDepth();
        break;
      }

      // map<string, string> add_params = 7;
      case 7: {
        if (tag == 58) {
          DO_(input->IncrementRecursionDepth());
         parse_loop_add_params:
          MiniRequestObject_AddParamsEntry::Parser< ::google::protobuf::internal::MapField<
              ::std::string, ::std::string,
              ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
              ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
              0 >,
            ::google::protobuf::Map< ::std::string, ::std::string > > parser(&add_params_);
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
              input, &parser));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            parser.key().data(), parser.key().length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.AddParamsEntry.key"));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            parser.value().data(), parser.value().length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.AddParamsEntry.value"));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(58)) goto parse_loop_add_params;
        if (input->ExpectTag(66)) goto parse_loop_extended_params;
        input->UnsafeDecrementRecursionDepth();
        break;
      }

      // map<string, string> extended_params = 8;
      case 8: {
        if (tag == 66) {
          DO_(input->IncrementRecursionDepth());
         parse_loop_extended_params:
          MiniRequestObject_ExtendedParamsEntry::Parser< ::google::protobuf::internal::MapField<
              ::std::string, ::std::string,
              ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
              ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
              0 >,
            ::google::protobuf::Map< ::std::string, ::std::string > > parser(&extended_params_);
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
              input, &parser));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            parser.key().data(), parser.key().length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.ExtendedParamsEntry.key"));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            parser.value().data(), parser.value().length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.ExtendedParamsEntry.value"));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(66)) goto parse_loop_extended_params;
        input->UnsafeDecrementRecursionDepth();
        if (input->ExpectTag(74)) goto parse_delete_params;
        break;
      }

      // repeated string delete_params = 9;
      case 9: {
        if (tag == 74) {
         parse_delete_params:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_delete_params()));
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
            this->delete_params(this->delete_params_size() - 1).data(),
            this->delete_params(this->delete_params_size() - 1).length(),
            ::google::protobuf::internal::WireFormatLite::PARSE,
            "coprocess.MiniRequestObject.delete_params"));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(74)) goto parse_delete_params;
        if (input->ExpectTag(82)) goto parse_return_overrides;
        break;
      }

      // optional .coprocess.ReturnOverrides return_overrides = 10;
      case 10: {
        if (tag == 82) {
         parse_return_overrides:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_return_overrides()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:coprocess.MiniRequestObject)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:coprocess.MiniRequestObject)
  return false;
#undef DO_
}

void MiniRequestObject::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:coprocess.MiniRequestObject)
  // map<string, string> headers = 1;
  if (!this->headers().empty()) {
    typedef ::google::protobuf::Map< ::std::string, ::std::string >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::google::protobuf::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), p->first.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.HeadersEntry.key");
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->second.data(), p->second.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.HeadersEntry.value");
      }
    };

    if (output->IsSerializationDeterminstic() &&
        this->headers().size() > 1) {
      ::google::protobuf::scoped_array<SortItem> items(
          new SortItem[this->headers().size()]);
      typedef ::google::protobuf::Map< ::std::string, ::std::string >::size_type size_type;
      size_type n = 0;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->headers().begin();
          it != this->headers().end(); ++it, ++n) {
        items[n] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[n], Less());
      ::google::protobuf::scoped_ptr<MiniRequestObject_HeadersEntry> entry;
      for (size_type i = 0; i < n; i++) {
        entry.reset(headers_.NewEntryWrapper(
            items[i]->first, items[i]->second));
        ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
            1, *entry, output);
        Utf8Check::Check(items[i]);
      }
    } else {
      ::google::protobuf::scoped_ptr<MiniRequestObject_HeadersEntry> entry;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->headers().begin();
          it != this->headers().end(); ++it) {
        entry.reset(headers_.NewEntryWrapper(
            it->first, it->second));
        ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
            1, *entry, output);
        Utf8Check::Check(&*it);
      }
    }
  }

  // map<string, string> set_headers = 2;
  if (!this->set_headers().empty()) {
    typedef ::google::protobuf::Map< ::std::string, ::std::string >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::google::protobuf::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), p->first.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.SetHeadersEntry.key");
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->second.data(), p->second.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.SetHeadersEntry.value");
      }
    };

    if (output->IsSerializationDeterminstic() &&
        this->set_headers().size() > 1) {
      ::google::protobuf::scoped_array<SortItem> items(
          new SortItem[this->set_headers().size()]);
      typedef ::google::protobuf::Map< ::std::string, ::std::string >::size_type size_type;
      size_type n = 0;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->set_headers().begin();
          it != this->set_headers().end(); ++it, ++n) {
        items[n] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[n], Less());
      ::google::protobuf::scoped_ptr<MiniRequestObject_SetHeadersEntry> entry;
      for (size_type i = 0; i < n; i++) {
        entry.reset(set_headers_.NewEntryWrapper(
            items[i]->first, items[i]->second));
        ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
            2, *entry, output);
        Utf8Check::Check(items[i]);
      }
    } else {
      ::google::protobuf::scoped_ptr<MiniRequestObject_SetHeadersEntry> entry;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->set_headers().begin();
          it != this->set_headers().end(); ++it) {
        entry.reset(set_headers_.NewEntryWrapper(
            it->first, it->second));
        ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
            2, *entry, output);
        Utf8Check::Check(&*it);
      }
    }
  }

  // repeated string delete_headers = 3;
  for (int i = 0; i < this->delete_headers_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
      this->delete_headers(i).data(), this->delete_headers(i).length(),
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
      "coprocess.MiniRequestObject.delete_headers");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      3, this->delete_headers(i), output);
  }

  // optional string body = 4;
  if (this->body().size() > 0) {
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
      this->body().data(), this->body().length(),
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
      "coprocess.MiniRequestObject.body");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->body(), output);
  }

  // optional string url = 5;
  if (this->url().size() > 0) {
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
      this->url().data(), this->url().length(),
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
      "coprocess.MiniRequestObject.url");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->url(), output);
  }

  // map<string, string> params = 6;
  if (!this->params().empty()) {
    typedef ::google::protobuf::Map< ::std::string, ::std::string >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::google::protobuf::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), p->first.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.ParamsEntry.key");
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->second.data(), p->second.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.ParamsEntry.value");
      }
    };

    if (output->IsSerializationDeterminstic() &&
        this->params().size() > 1) {
      ::google::protobuf::scoped_array<SortItem> items(
          new SortItem[this->params().size()]);
      typedef ::google::protobuf::Map< ::std::string, ::std::string >::size_type size_type;
      size_type n = 0;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->params().begin();
          it != this->params().end(); ++it, ++n) {
        items[n] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[n], Less());
      ::google::protobuf::scoped_ptr<MiniRequestObject_ParamsEntry> entry;
      for (size_type i = 0; i < n; i++) {
        entry.reset(params_.NewEntryWrapper(
            items[i]->first, items[i]->second));
        ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
            6, *entry, output);
        Utf8Check::Check(items[i]);
      }
    } else {
      ::google::protobuf::scoped_ptr<MiniRequestObject_ParamsEntry> entry;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->params().begin();
          it != this->params().end(); ++it) {
        entry.reset(params_.NewEntryWrapper(
            it->first, it->second));
        ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
            6, *entry, output);
        Utf8Check::Check(&*it);
      }
    }
  }

  // map<string, string> add_params = 7;
  if (!this->add_params().empty()) {
    typedef ::google::protobuf::Map< ::std::string, ::std::string >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::google::protobuf::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), p->first.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.AddParamsEntry.key");
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->second.data(), p->second.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.AddParamsEntry.value");
      }
    };

    if (output->IsSerializationDeterminstic() &&
        this->add_params().size() > 1) {
      ::google::protobuf::scoped_array<SortItem> items(
          new SortItem[this->add_params().size()]);
      typedef ::google::protobuf::Map< ::std::string, ::std::string >::size_type size_type;
      size_type n = 0;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->add_params().begin();
          it != this->add_params().end(); ++it, ++n) {
        items[n] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[n], Less());
      ::google::protobuf::scoped_ptr<MiniRequestObject_AddParamsEntry> entry;
      for (size_type i = 0; i < n; i++) {
        entry.reset(add_params_.NewEntryWrapper(
            items[i]->first, items[i]->second));
        ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
            7, *entry, output);
        Utf8Check::Check(items[i]);
      }
    } else {
      ::google::protobuf::scoped_ptr<MiniRequestObject_AddParamsEntry> entry;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->add_params().begin();
          it != this->add_params().end(); ++it) {
        entry.reset(add_params_.NewEntryWrapper(
            it->first, it->second));
        ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
            7, *entry, output);
        Utf8Check::Check(&*it);
      }
    }
  }

  // map<string, string> extended_params = 8;
  if (!this->extended_params().empty()) {
    typedef ::google::protobuf::Map< ::std::string, ::std::string >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::google::protobuf::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), p->first.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.ExtendedParamsEntry.key");
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->second.data(), p->second.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.ExtendedParamsEntry.value");
      }
    };

    if (output->IsSerializationDeterminstic() &&
        this->extended_params().size() > 1) {
      ::google::protobuf::scoped_array<SortItem> items(
          new SortItem[this->extended_params().size()]);
      typedef ::google::protobuf::Map< ::std::string, ::std::string >::size_type size_type;
      size_type n = 0;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->extended_params().begin();
          it != this->extended_params().end(); ++it, ++n) {
        items[n] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[n], Less());
      ::google::protobuf::scoped_ptr<MiniRequestObject_ExtendedParamsEntry> entry;
      for (size_type i = 0; i < n; i++) {
        entry.reset(extended_params_.NewEntryWrapper(
            items[i]->first, items[i]->second));
        ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
            8, *entry, output);
        Utf8Check::Check(items[i]);
      }
    } else {
      ::google::protobuf::scoped_ptr<MiniRequestObject_ExtendedParamsEntry> entry;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->extended_params().begin();
          it != this->extended_params().end(); ++it) {
        entry.reset(extended_params_.NewEntryWrapper(
            it->first, it->second));
        ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
            8, *entry, output);
        Utf8Check::Check(&*it);
      }
    }
  }

  // repeated string delete_params = 9;
  for (int i = 0; i < this->delete_params_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
      this->delete_params(i).data(), this->delete_params(i).length(),
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
      "coprocess.MiniRequestObject.delete_params");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      9, this->delete_params(i), output);
  }

  // optional .coprocess.ReturnOverrides return_overrides = 10;
  if (this->has_return_overrides()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      10, *this->return_overrides_, output);
  }

  // @@protoc_insertion_point(serialize_end:coprocess.MiniRequestObject)
}

::google::protobuf::uint8* MiniRequestObject::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:coprocess.MiniRequestObject)
  // map<string, string> headers = 1;
  if (!this->headers().empty()) {
    typedef ::google::protobuf::Map< ::std::string, ::std::string >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::google::protobuf::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), p->first.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.HeadersEntry.key");
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->second.data(), p->second.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.HeadersEntry.value");
      }
    };

    if (deterministic &&
        this->headers().size() > 1) {
      ::google::protobuf::scoped_array<SortItem> items(
          new SortItem[this->headers().size()]);
      typedef ::google::protobuf::Map< ::std::string, ::std::string >::size_type size_type;
      size_type n = 0;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->headers().begin();
          it != this->headers().end(); ++it, ++n) {
        items[n] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[n], Less());
      ::google::protobuf::scoped_ptr<MiniRequestObject_HeadersEntry> entry;
      for (size_type i = 0; i < n; i++) {
        entry.reset(headers_.NewEntryWrapper(
            items[i]->first, items[i]->second));
        target = ::google::protobuf::internal::WireFormatLite::
                   InternalWriteMessageNoVirtualToArray(
                       1, *entry, deterministic, target);
;
        Utf8Check::Check(items[i]);
      }
    } else {
      ::google::protobuf::scoped_ptr<MiniRequestObject_HeadersEntry> entry;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->headers().begin();
          it != this->headers().end(); ++it) {
        entry.reset(headers_.NewEntryWrapper(
            it->first, it->second));
        target = ::google::protobuf::internal::WireFormatLite::
                   InternalWriteMessageNoVirtualToArray(
                       1, *entry, deterministic, target);
;
        Utf8Check::Check(&*it);
      }
    }
  }

  // map<string, string> set_headers = 2;
  if (!this->set_headers().empty()) {
    typedef ::google::protobuf::Map< ::std::string, ::std::string >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::google::protobuf::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), p->first.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.SetHeadersEntry.key");
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->second.data(), p->second.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.SetHeadersEntry.value");
      }
    };

    if (deterministic &&
        this->set_headers().size() > 1) {
      ::google::protobuf::scoped_array<SortItem> items(
          new SortItem[this->set_headers().size()]);
      typedef ::google::protobuf::Map< ::std::string, ::std::string >::size_type size_type;
      size_type n = 0;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->set_headers().begin();
          it != this->set_headers().end(); ++it, ++n) {
        items[n] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[n], Less());
      ::google::protobuf::scoped_ptr<MiniRequestObject_SetHeadersEntry> entry;
      for (size_type i = 0; i < n; i++) {
        entry.reset(set_headers_.NewEntryWrapper(
            items[i]->first, items[i]->second));
        target = ::google::protobuf::internal::WireFormatLite::
                   InternalWriteMessageNoVirtualToArray(
                       2, *entry, deterministic, target);
;
        Utf8Check::Check(items[i]);
      }
    } else {
      ::google::protobuf::scoped_ptr<MiniRequestObject_SetHeadersEntry> entry;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->set_headers().begin();
          it != this->set_headers().end(); ++it) {
        entry.reset(set_headers_.NewEntryWrapper(
            it->first, it->second));
        target = ::google::protobuf::internal::WireFormatLite::
                   InternalWriteMessageNoVirtualToArray(
                       2, *entry, deterministic, target);
;
        Utf8Check::Check(&*it);
      }
    }
  }

  // repeated string delete_headers = 3;
  for (int i = 0; i < this->delete_headers_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
      this->delete_headers(i).data(), this->delete_headers(i).length(),
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
      "coprocess.MiniRequestObject.delete_headers");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(3, this->delete_headers(i), target);
  }

  // optional string body = 4;
  if (this->body().size() > 0) {
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
      this->body().data(), this->body().length(),
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
      "coprocess.MiniRequestObject.body");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->body(), target);
  }

  // optional string url = 5;
  if (this->url().size() > 0) {
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
      this->url().data(), this->url().length(),
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
      "coprocess.MiniRequestObject.url");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        5, this->url(), target);
  }

  // map<string, string> params = 6;
  if (!this->params().empty()) {
    typedef ::google::protobuf::Map< ::std::string, ::std::string >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::google::protobuf::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), p->first.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.ParamsEntry.key");
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->second.data(), p->second.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.ParamsEntry.value");
      }
    };

    if (deterministic &&
        this->params().size() > 1) {
      ::google::protobuf::scoped_array<SortItem> items(
          new SortItem[this->params().size()]);
      typedef ::google::protobuf::Map< ::std::string, ::std::string >::size_type size_type;
      size_type n = 0;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->params().begin();
          it != this->params().end(); ++it, ++n) {
        items[n] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[n], Less());
      ::google::protobuf::scoped_ptr<MiniRequestObject_ParamsEntry> entry;
      for (size_type i = 0; i < n; i++) {
        entry.reset(params_.NewEntryWrapper(
            items[i]->first, items[i]->second));
        target = ::google::protobuf::internal::WireFormatLite::
                   InternalWriteMessageNoVirtualToArray(
                       6, *entry, deterministic, target);
;
        Utf8Check::Check(items[i]);
      }
    } else {
      ::google::protobuf::scoped_ptr<MiniRequestObject_ParamsEntry> entry;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->params().begin();
          it != this->params().end(); ++it) {
        entry.reset(params_.NewEntryWrapper(
            it->first, it->second));
        target = ::google::protobuf::internal::WireFormatLite::
                   InternalWriteMessageNoVirtualToArray(
                       6, *entry, deterministic, target);
;
        Utf8Check::Check(&*it);
      }
    }
  }

  // map<string, string> add_params = 7;
  if (!this->add_params().empty()) {
    typedef ::google::protobuf::Map< ::std::string, ::std::string >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::google::protobuf::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), p->first.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.AddParamsEntry.key");
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->second.data(), p->second.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.AddParamsEntry.value");
      }
    };

    if (deterministic &&
        this->add_params().size() > 1) {
      ::google::protobuf::scoped_array<SortItem> items(
          new SortItem[this->add_params().size()]);
      typedef ::google::protobuf::Map< ::std::string, ::std::string >::size_type size_type;
      size_type n = 0;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->add_params().begin();
          it != this->add_params().end(); ++it, ++n) {
        items[n] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[n], Less());
      ::google::protobuf::scoped_ptr<MiniRequestObject_AddParamsEntry> entry;
      for (size_type i = 0; i < n; i++) {
        entry.reset(add_params_.NewEntryWrapper(
            items[i]->first, items[i]->second));
        target = ::google::protobuf::internal::WireFormatLite::
                   InternalWriteMessageNoVirtualToArray(
                       7, *entry, deterministic, target);
;
        Utf8Check::Check(items[i]);
      }
    } else {
      ::google::protobuf::scoped_ptr<MiniRequestObject_AddParamsEntry> entry;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->add_params().begin();
          it != this->add_params().end(); ++it) {
        entry.reset(add_params_.NewEntryWrapper(
            it->first, it->second));
        target = ::google::protobuf::internal::WireFormatLite::
                   InternalWriteMessageNoVirtualToArray(
                       7, *entry, deterministic, target);
;
        Utf8Check::Check(&*it);
      }
    }
  }

  // map<string, string> extended_params = 8;
  if (!this->extended_params().empty()) {
    typedef ::google::protobuf::Map< ::std::string, ::std::string >::const_pointer
        ConstPtr;
    typedef ConstPtr SortItem;
    typedef ::google::protobuf::internal::CompareByDerefFirst<SortItem> Less;
    struct Utf8Check {
      static void Check(ConstPtr p) {
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->first.data(), p->first.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.ExtendedParamsEntry.key");
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          p->second.data(), p->second.length(),
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
          "coprocess.MiniRequestObject.ExtendedParamsEntry.value");
      }
    };

    if (deterministic &&
        this->extended_params().size() > 1) {
      ::google::protobuf::scoped_array<SortItem> items(
          new SortItem[this->extended_params().size()]);
      typedef ::google::protobuf::Map< ::std::string, ::std::string >::size_type size_type;
      size_type n = 0;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->extended_params().begin();
          it != this->extended_params().end(); ++it, ++n) {
        items[n] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[n], Less());
      ::google::protobuf::scoped_ptr<MiniRequestObject_ExtendedParamsEntry> entry;
      for (size_type i = 0; i < n; i++) {
        entry.reset(extended_params_.NewEntryWrapper(
            items[i]->first, items[i]->second));
        target = ::google::protobuf::internal::WireFormatLite::
                   InternalWriteMessageNoVirtualToArray(
                       8, *entry, deterministic, target);
;
        Utf8Check::Check(items[i]);
      }
    } else {
      ::google::protobuf::scoped_ptr<MiniRequestObject_ExtendedParamsEntry> entry;
      for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
          it = this->extended_params().begin();
          it != this->extended_params().end(); ++it) {
        entry.reset(extended_params_.NewEntryWrapper(
            it->first, it->second));
        target = ::google::protobuf::internal::WireFormatLite::
                   InternalWriteMessageNoVirtualToArray(
                       8, *entry, deterministic, target);
;
        Utf8Check::Check(&*it);
      }
    }
  }

  // repeated string delete_params = 9;
  for (int i = 0; i < this->delete_params_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
      this->delete_params(i).data(), this->delete_params(i).length(),
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
      "coprocess.MiniRequestObject.delete_params");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(9, this->delete_params(i), target);
  }

  // optional .coprocess.ReturnOverrides return_overrides = 10;
  if (this->has_return_overrides()) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageNoVirtualToArray(
        10, *this->return_overrides_, false, target);
  }

  // @@protoc_insertion_point(serialize_to_array_end:coprocess.MiniRequestObject)
  return target;
}

size_t MiniRequestObject::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:coprocess.MiniRequestObject)
  size_t total_size = 0;

  // optional string body = 4;
  if (this->body().size() > 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->body());
  }

  // optional string url = 5;
  if (this->url().size() > 0) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->url());
  }

  // optional .coprocess.ReturnOverrides return_overrides = 10;
  if (this->has_return_overrides()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->return_overrides_);
  }

  // map<string, string> headers = 1;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->headers_size());
  {
    ::google::protobuf::scoped_ptr<MiniRequestObject_HeadersEntry> entry;
    for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
        it = this->headers().begin();
        it != this->headers().end(); ++it) {
      entry.reset(headers_.NewEntryWrapper(it->first, it->second));
      total_size += ::google::protobuf::internal::WireFormatLite::
          MessageSizeNoVirtual(*entry);
    }
  }

  // map<string, string> set_headers = 2;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->set_headers_size());
  {
    ::google::protobuf::scoped_ptr<MiniRequestObject_SetHeadersEntry> entry;
    for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
        it = this->set_headers().begin();
        it != this->set_headers().end(); ++it) {
      entry.reset(set_headers_.NewEntryWrapper(it->first, it->second));
      total_size += ::google::protobuf::internal::WireFormatLite::
          MessageSizeNoVirtual(*entry);
    }
  }

  // repeated string delete_headers = 3;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->delete_headers_size());
  for (int i = 0; i < this->delete_headers_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->delete_headers(i));
  }

  // map<string, string> params = 6;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->params_size());
  {
    ::google::protobuf::scoped_ptr<MiniRequestObject_ParamsEntry> entry;
    for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
        it = this->params().begin();
        it != this->params().end(); ++it) {
      entry.reset(params_.NewEntryWrapper(it->first, it->second));
      total_size += ::google::protobuf::internal::WireFormatLite::
          MessageSizeNoVirtual(*entry);
    }
  }

  // map<string, string> add_params = 7;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->add_params_size());
  {
    ::google::protobuf::scoped_ptr<MiniRequestObject_AddParamsEntry> entry;
    for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
        it = this->add_params().begin();
        it != this->add_params().end(); ++it) {
      entry.reset(add_params_.NewEntryWrapper(it->first, it->second));
      total_size += ::google::protobuf::internal::WireFormatLite::
          MessageSizeNoVirtual(*entry);
    }
  }

  // map<string, string> extended_params = 8;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->extended_params_size());
  {
    ::google::protobuf::scoped_ptr<MiniRequestObject_ExtendedParamsEntry> entry;
    for (::google::protobuf::Map< ::std::string, ::std::string >::const_iterator
        it = this->extended_params().begin();
        it != this->extended_params().end(); ++it) {
      entry.reset(extended_params_.NewEntryWrapper(it->first, it->second));
      total_size += ::google::protobuf::internal::WireFormatLite::
          MessageSizeNoVirtual(*entry);
    }
  }

  // repeated string delete_params = 9;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->delete_params_size());
  for (int i = 0; i < this->delete_params_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->delete_params(i));
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void MiniRequestObject::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:coprocess.MiniRequestObject)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const MiniRequestObject* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const MiniRequestObject>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:coprocess.MiniRequestObject)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:coprocess.MiniRequestObject)
    UnsafeMergeFrom(*source);
  }
}

void MiniRequestObject::MergeFrom(const MiniRequestObject& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:coprocess.MiniRequestObject)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void MiniRequestObject::UnsafeMergeFrom(const MiniRequestObject& from) {
  GOOGLE_DCHECK(&from != this);
  headers_.MergeFrom(from.headers_);
  set_headers_.MergeFrom(from.set_headers_);
  delete_headers_.UnsafeMergeFrom(from.delete_headers_);
  params_.MergeFrom(from.params_);
  add_params_.MergeFrom(from.add_params_);
  extended_params_.MergeFrom(from.extended_params_);
  delete_params_.UnsafeMergeFrom(from.delete_params_);
  if (from.body().size() > 0) {

    body_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.body_);
  }
  if (from.url().size() > 0) {

    url_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.url_);
  }
  if (from.has_return_overrides()) {
    mutable_return_overrides()->::coprocess::ReturnOverrides::MergeFrom(from.return_overrides());
  }
}

void MiniRequestObject::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:coprocess.MiniRequestObject)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MiniRequestObject::CopyFrom(const MiniRequestObject& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:coprocess.MiniRequestObject)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool MiniRequestObject::IsInitialized() const {

  return true;
}

void MiniRequestObject::Swap(MiniRequestObject* other) {
  if (other == this) return;
  InternalSwap(other);
}
void MiniRequestObject::InternalSwap(MiniRequestObject* other) {
  headers_.Swap(&other->headers_);
  set_headers_.Swap(&other->set_headers_);
  delete_headers_.UnsafeArenaSwap(&other->delete_headers_);
  body_.Swap(&other->body_);
  url_.Swap(&other->url_);
  params_.Swap(&other->params_);
  add_params_.Swap(&other->add_params_);
  extended_params_.Swap(&other->extended_params_);
  delete_params_.UnsafeArenaSwap(&other->delete_params_);
  std::swap(return_overrides_, other->return_overrides_);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata MiniRequestObject::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = MiniRequestObject_descriptor_;
  metadata.reflection = MiniRequestObject_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// MiniRequestObject

// map<string, string> headers = 1;
int MiniRequestObject::headers_size() const {
  return headers_.size();
}
void MiniRequestObject::clear_headers() {
  headers_.Clear();
}
 const ::google::protobuf::Map< ::std::string, ::std::string >&
MiniRequestObject::headers() const {
  // @@protoc_insertion_point(field_map:coprocess.MiniRequestObject.headers)
  return headers_.GetMap();
}
 ::google::protobuf::Map< ::std::string, ::std::string >*
MiniRequestObject::mutable_headers() {
  // @@protoc_insertion_point(field_mutable_map:coprocess.MiniRequestObject.headers)
  return headers_.MutableMap();
}

// map<string, string> set_headers = 2;
int MiniRequestObject::set_headers_size() const {
  return set_headers_.size();
}
void MiniRequestObject::clear_set_headers() {
  set_headers_.Clear();
}
 const ::google::protobuf::Map< ::std::string, ::std::string >&
MiniRequestObject::set_headers() const {
  // @@protoc_insertion_point(field_map:coprocess.MiniRequestObject.set_headers)
  return set_headers_.GetMap();
}
 ::google::protobuf::Map< ::std::string, ::std::string >*
MiniRequestObject::mutable_set_headers() {
  // @@protoc_insertion_point(field_mutable_map:coprocess.MiniRequestObject.set_headers)
  return set_headers_.MutableMap();
}

// repeated string delete_headers = 3;
int MiniRequestObject::delete_headers_size() const {
  return delete_headers_.size();
}
void MiniRequestObject::clear_delete_headers() {
  delete_headers_.Clear();
}
const ::std::string& MiniRequestObject::delete_headers(int index) const {
  // @@protoc_insertion_point(field_get:coprocess.MiniRequestObject.delete_headers)
  return delete_headers_.Get(index);
}
::std::string* MiniRequestObject::mutable_delete_headers(int index) {
  // @@protoc_insertion_point(field_mutable:coprocess.MiniRequestObject.delete_headers)
  return delete_headers_.Mutable(index);
}
void MiniRequestObject::set_delete_headers(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:coprocess.MiniRequestObject.delete_headers)
  delete_headers_.Mutable(index)->assign(value);
}
void MiniRequestObject::set_delete_headers(int index, const char* value) {
  delete_headers_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:coprocess.MiniRequestObject.delete_headers)
}
void MiniRequestObject::set_delete_headers(int index, const char* value, size_t size) {
  delete_headers_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:coprocess.MiniRequestObject.delete_headers)
}
::std::string* MiniRequestObject::add_delete_headers() {
  // @@protoc_insertion_point(field_add_mutable:coprocess.MiniRequestObject.delete_headers)
  return delete_headers_.Add();
}
void MiniRequestObject::add_delete_headers(const ::std::string& value) {
  delete_headers_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:coprocess.MiniRequestObject.delete_headers)
}
void MiniRequestObject::add_delete_headers(const char* value) {
  delete_headers_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:coprocess.MiniRequestObject.delete_headers)
}
void MiniRequestObject::add_delete_headers(const char* value, size_t size) {
  delete_headers_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:coprocess.MiniRequestObject.delete_headers)
}
const ::google::protobuf::RepeatedPtrField< ::std::string>&
MiniRequestObject::delete_headers() const {
  // @@protoc_insertion_point(field_list:coprocess.MiniRequestObject.delete_headers)
  return delete_headers_;
}
::google::protobuf::RepeatedPtrField< ::std::string>*
MiniRequestObject::mutable_delete_headers() {
  // @@protoc_insertion_point(field_mutable_list:coprocess.MiniRequestObject.delete_headers)
  return &delete_headers_;
}

// optional string body = 4;
void MiniRequestObject::clear_body() {
  body_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
const ::std::string& MiniRequestObject::body() const {
  // @@protoc_insertion_point(field_get:coprocess.MiniRequestObject.body)
  return body_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void MiniRequestObject::set_body(const ::std::string& value) {
  
  body_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:coprocess.MiniRequestObject.body)
}
void MiniRequestObject::set_body(const char* value) {
  
  body_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:coprocess.MiniRequestObject.body)
}
void MiniRequestObject::set_body(const char* value, size_t size) {
  
  body_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:coprocess.MiniRequestObject.body)
}
::std::string* MiniRequestObject::mutable_body() {
  
  // @@protoc_insertion_point(field_mutable:coprocess.MiniRequestObject.body)
  return body_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* MiniRequestObject::release_body() {
  // @@protoc_insertion_point(field_release:coprocess.MiniRequestObject.body)
  
  return body_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void MiniRequestObject::set_allocated_body(::std::string* body) {
  if (body != NULL) {
    
  } else {
    
  }
  body_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), body);
  // @@protoc_insertion_point(field_set_allocated:coprocess.MiniRequestObject.body)
}

// optional string url = 5;
void MiniRequestObject::clear_url() {
  url_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
const ::std::string& MiniRequestObject::url() const {
  // @@protoc_insertion_point(field_get:coprocess.MiniRequestObject.url)
  return url_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void MiniRequestObject::set_url(const ::std::string& value) {
  
  url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:coprocess.MiniRequestObject.url)
}
void MiniRequestObject::set_url(const char* value) {
  
  url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:coprocess.MiniRequestObject.url)
}
void MiniRequestObject::set_url(const char* value, size_t size) {
  
  url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:coprocess.MiniRequestObject.url)
}
::std::string* MiniRequestObject::mutable_url() {
  
  // @@protoc_insertion_point(field_mutable:coprocess.MiniRequestObject.url)
  return url_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* MiniRequestObject::release_url() {
  // @@protoc_insertion_point(field_release:coprocess.MiniRequestObject.url)
  
  return url_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void MiniRequestObject::set_allocated_url(::std::string* url) {
  if (url != NULL) {
    
  } else {
    
  }
  url_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), url);
  // @@protoc_insertion_point(field_set_allocated:coprocess.MiniRequestObject.url)
}

// map<string, string> params = 6;
int MiniRequestObject::params_size() const {
  return params_.size();
}
void MiniRequestObject::clear_params() {
  params_.Clear();
}
 const ::google::protobuf::Map< ::std::string, ::std::string >&
MiniRequestObject::params() const {
  // @@protoc_insertion_point(field_map:coprocess.MiniRequestObject.params)
  return params_.GetMap();
}
 ::google::protobuf::Map< ::std::string, ::std::string >*
MiniRequestObject::mutable_params() {
  // @@protoc_insertion_point(field_mutable_map:coprocess.MiniRequestObject.params)
  return params_.MutableMap();
}

// map<string, string> add_params = 7;
int MiniRequestObject::add_params_size() const {
  return add_params_.size();
}
void MiniRequestObject::clear_add_params() {
  add_params_.Clear();
}
 const ::google::protobuf::Map< ::std::string, ::std::string >&
MiniRequestObject::add_params() const {
  // @@protoc_insertion_point(field_map:coprocess.MiniRequestObject.add_params)
  return add_params_.GetMap();
}
 ::google::protobuf::Map< ::std::string, ::std::string >*
MiniRequestObject::mutable_add_params() {
  // @@protoc_insertion_point(field_mutable_map:coprocess.MiniRequestObject.add_params)
  return add_params_.MutableMap();
}

// map<string, string> extended_params = 8;
int MiniRequestObject::extended_params_size() const {
  return extended_params_.size();
}
void MiniRequestObject::clear_extended_params() {
  extended_params_.Clear();
}
 const ::google::protobuf::Map< ::std::string, ::std::string >&
MiniRequestObject::extended_params() const {
  // @@protoc_insertion_point(field_map:coprocess.MiniRequestObject.extended_params)
  return extended_params_.GetMap();
}
 ::google::protobuf::Map< ::std::string, ::std::string >*
MiniRequestObject::mutable_extended_params() {
  // @@protoc_insertion_point(field_mutable_map:coprocess.MiniRequestObject.extended_params)
  return extended_params_.MutableMap();
}

// repeated string delete_params = 9;
int MiniRequestObject::delete_params_size() const {
  return delete_params_.size();
}
void MiniRequestObject::clear_delete_params() {
  delete_params_.Clear();
}
const ::std::string& MiniRequestObject::delete_params(int index) const {
  // @@protoc_insertion_point(field_get:coprocess.MiniRequestObject.delete_params)
  return delete_params_.Get(index);
}
::std::string* MiniRequestObject::mutable_delete_params(int index) {
  // @@protoc_insertion_point(field_mutable:coprocess.MiniRequestObject.delete_params)
  return delete_params_.Mutable(index);
}
void MiniRequestObject::set_delete_params(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:coprocess.MiniRequestObject.delete_params)
  delete_params_.Mutable(index)->assign(value);
}
void MiniRequestObject::set_delete_params(int index, const char* value) {
  delete_params_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:coprocess.MiniRequestObject.delete_params)
}
void MiniRequestObject::set_delete_params(int index, const char* value, size_t size) {
  delete_params_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:coprocess.MiniRequestObject.delete_params)
}
::std::string* MiniRequestObject::add_delete_params() {
  // @@protoc_insertion_point(field_add_mutable:coprocess.MiniRequestObject.delete_params)
  return delete_params_.Add();
}
void MiniRequestObject::add_delete_params(const ::std::string& value) {
  delete_params_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:coprocess.MiniRequestObject.delete_params)
}
void MiniRequestObject::add_delete_params(const char* value) {
  delete_params_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:coprocess.MiniRequestObject.delete_params)
}
void MiniRequestObject::add_delete_params(const char* value, size_t size) {
  delete_params_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:coprocess.MiniRequestObject.delete_params)
}
const ::google::protobuf::RepeatedPtrField< ::std::string>&
MiniRequestObject::delete_params() const {
  // @@protoc_insertion_point(field_list:coprocess.MiniRequestObject.delete_params)
  return delete_params_;
}
::google::protobuf::RepeatedPtrField< ::std::string>*
MiniRequestObject::mutable_delete_params() {
  // @@protoc_insertion_point(field_mutable_list:coprocess.MiniRequestObject.delete_params)
  return &delete_params_;
}

// optional .coprocess.ReturnOverrides return_overrides = 10;
bool MiniRequestObject::has_return_overrides() const {
  return this != internal_default_instance() && return_overrides_ != NULL;
}
void MiniRequestObject::clear_return_overrides() {
  if (GetArenaNoVirtual() == NULL && return_overrides_ != NULL) delete return_overrides_;
  return_overrides_ = NULL;
}
const ::coprocess::ReturnOverrides& MiniRequestObject::return_overrides() const {
  // @@protoc_insertion_point(field_get:coprocess.MiniRequestObject.return_overrides)
  return return_overrides_ != NULL ? *return_overrides_
                         : *::coprocess::ReturnOverrides::internal_default_instance();
}
::coprocess::ReturnOverrides* MiniRequestObject::mutable_return_overrides() {
  
  if (return_overrides_ == NULL) {
    return_overrides_ = new ::coprocess::ReturnOverrides;
  }
  // @@protoc_insertion_point(field_mutable:coprocess.MiniRequestObject.return_overrides)
  return return_overrides_;
}
::coprocess::ReturnOverrides* MiniRequestObject::release_return_overrides() {
  // @@protoc_insertion_point(field_release:coprocess.MiniRequestObject.return_overrides)
  
  ::coprocess::ReturnOverrides* temp = return_overrides_;
  return_overrides_ = NULL;
  return temp;
}
void MiniRequestObject::set_allocated_return_overrides(::coprocess::ReturnOverrides* return_overrides) {
  delete return_overrides_;
  return_overrides_ = return_overrides;
  if (return_overrides) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:coprocess.MiniRequestObject.return_overrides)
}

inline const MiniRequestObject* MiniRequestObject::internal_default_instance() {
  return &MiniRequestObject_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// @@protoc_insertion_point(namespace_scope)

}  // namespace coprocess

// @@protoc_insertion_point(global_scope)
