xtreemfs/cpp/generated/pbrpc/RPC.pb.cc

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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "pbrpc/RPC.pb.h"

#include <algorithm>

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

namespace xtreemfs {
namespace pbrpc {

namespace {

const ::google::protobuf::Descriptor* UserCredentials_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  UserCredentials_reflection_ = NULL;
const ::google::protobuf::Descriptor* AuthPassword_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  AuthPassword_reflection_ = NULL;
const ::google::protobuf::Descriptor* Auth_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Auth_reflection_ = NULL;
const ::google::protobuf::Descriptor* RPCHeader_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  RPCHeader_reflection_ = NULL;
const ::google::protobuf::Descriptor* RPCHeader_RequestHeader_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  RPCHeader_RequestHeader_reflection_ = NULL;
const ::google::protobuf::Descriptor* RPCHeader_ErrorResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  RPCHeader_ErrorResponse_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* MessageType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* AuthType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ErrorType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* POSIXErrno_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_pbrpc_2fRPC_2eproto() {
  protobuf_AddDesc_pbrpc_2fRPC_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "pbrpc/RPC.proto");
  GOOGLE_CHECK(file != NULL);
  UserCredentials_descriptor_ = file->message_type(0);
  static const int UserCredentials_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, username_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, groups_),
  };
  UserCredentials_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      UserCredentials_descriptor_,
      UserCredentials::default_instance_,
      UserCredentials_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserCredentials, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(UserCredentials));
  AuthPassword_descriptor_ = file->message_type(1);
  static const int AuthPassword_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthPassword, password_),
  };
  AuthPassword_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      AuthPassword_descriptor_,
      AuthPassword::default_instance_,
      AuthPassword_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthPassword, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthPassword, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(AuthPassword));
  Auth_descriptor_ = file->message_type(2);
  static const int Auth_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, auth_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, auth_passwd_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, auth_data_),
  };
  Auth_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Auth_descriptor_,
      Auth::default_instance_,
      Auth_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Auth, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Auth));
  RPCHeader_descriptor_ = file->message_type(3);
  static const int RPCHeader_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, call_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, message_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, request_header_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, error_response_),
  };
  RPCHeader_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      RPCHeader_descriptor_,
      RPCHeader::default_instance_,
      RPCHeader_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(RPCHeader));
  RPCHeader_RequestHeader_descriptor_ = RPCHeader_descriptor_->nested_type(0);
  static const int RPCHeader_RequestHeader_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, interface_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, proc_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, user_creds_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, auth_data_),
  };
  RPCHeader_RequestHeader_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      RPCHeader_RequestHeader_descriptor_,
      RPCHeader_RequestHeader::default_instance_,
      RPCHeader_RequestHeader_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_RequestHeader, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(RPCHeader_RequestHeader));
  RPCHeader_ErrorResponse_descriptor_ = RPCHeader_descriptor_->nested_type(1);
  static const int RPCHeader_ErrorResponse_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, error_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, posix_errno_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, error_message_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, debug_info_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, redirect_to_server_uuid_),
  };
  RPCHeader_ErrorResponse_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      RPCHeader_ErrorResponse_descriptor_,
      RPCHeader_ErrorResponse::default_instance_,
      RPCHeader_ErrorResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCHeader_ErrorResponse, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(RPCHeader_ErrorResponse));
  MessageType_descriptor_ = file->enum_type(0);
  AuthType_descriptor_ = file->enum_type(1);
  ErrorType_descriptor_ = file->enum_type(2);
  POSIXErrno_descriptor_ = file->enum_type(3);
}

namespace {

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

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    UserCredentials_descriptor_, &UserCredentials::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    AuthPassword_descriptor_, &AuthPassword::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Auth_descriptor_, &Auth::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    RPCHeader_descriptor_, &RPCHeader::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    RPCHeader_RequestHeader_descriptor_, &RPCHeader_RequestHeader::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    RPCHeader_ErrorResponse_descriptor_, &RPCHeader_ErrorResponse::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_pbrpc_2fRPC_2eproto() {
  delete UserCredentials::default_instance_;
  delete UserCredentials_reflection_;
  delete AuthPassword::default_instance_;
  delete AuthPassword_reflection_;
  delete Auth::default_instance_;
  delete Auth_reflection_;
  delete RPCHeader::default_instance_;
  delete RPCHeader_reflection_;
  delete RPCHeader_RequestHeader::default_instance_;
  delete RPCHeader_RequestHeader_reflection_;
  delete RPCHeader_ErrorResponse::default_instance_;
  delete RPCHeader_ErrorResponse_reflection_;
}

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

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\017pbrpc/RPC.proto\022\016xtreemfs.pbrpc\"3\n\017Use"
    "rCredentials\022\020\n\010username\030\001 \002(\t\022\016\n\006groups"
    "\030\002 \003(\t\" \n\014AuthPassword\022\020\n\010password\030\001 \002(\t"
    "\"y\n\004Auth\022+\n\tauth_type\030\001 \002(\0162\030.xtreemfs.p"
    "brpc.AuthType\0221\n\013auth_passwd\030\003 \001(\0132\034.xtr"
    "eemfs.pbrpc.AuthPassword\022\021\n\tauth_data\030\002 "
    "\001(\014\"\270\004\n\tRPCHeader\022\017\n\007call_id\030\001 \002(\007\0221\n\014me"
    "ssage_type\030\002 \002(\0162\033.xtreemfs.pbrpc.Messag"
    "eType\022\?\n\016request_header\030\003 \001(\0132\'.xtreemfs"
    ".pbrpc.RPCHeader.RequestHeader\022\?\n\016error_"
    "response\030\004 \001(\0132\'.xtreemfs.pbrpc.RPCHeade"
    "r.ErrorResponse\032\224\001\n\rRequestHeader\022\024\n\014int"
    "erface_id\030\001 \002(\007\022\017\n\007proc_id\030\002 \002(\007\0223\n\nuser"
    "_creds\030\003 \002(\0132\037.xtreemfs.pbrpc.UserCreden"
    "tials\022\'\n\tauth_data\030\004 \002(\0132\024.xtreemfs.pbrp"
    "c.Auth\032\315\001\n\rErrorResponse\022-\n\nerror_type\030\001"
    " \002(\0162\031.xtreemfs.pbrpc.ErrorType\022A\n\013posix"
    "_errno\030\002 \001(\0162\032.xtreemfs.pbrpc.POSIXErrno"
    ":\020POSIX_ERROR_NONE\022\025\n\rerror_message\030\003 \001("
    "\t\022\022\n\ndebug_info\030\004 \001(\t\022\037\n\027redirect_to_ser"
    "ver_uuid\030\005 \001(\t*P\n\013MessageType\022\017\n\013RPC_REQ"
    "UEST\020\000\022\030\n\024RPC_RESPONSE_SUCCESS\020\001\022\026\n\022RPC_"
    "RESPONSE_ERROR\020\002*,\n\010AuthType\022\r\n\tAUTH_NON"
    "E\020\000\022\021\n\rAUTH_PASSWORD\020\001*\261\001\n\tErrorType\022\030\n\024"
    "INVALID_INTERFACE_ID\020\001\022\023\n\017INVALID_PROC_I"
    "D\020\002\022\020\n\014GARBAGE_ARGS\020\003\022\017\n\013AUTH_FAILED\020\004\022\031"
    "\n\025INTERNAL_SERVER_ERROR\020\005\022\t\n\005ERRNO\020\006\022\014\n\010"
    "REDIRECT\020\007\022\020\n\014INVALID_VIEW\020\010\022\014\n\010IO_ERROR"
    "\020d*\212\003\n\nPOSIXErrno\022\025\n\020POSIX_ERROR_NONE\020\217N"
    "\022\025\n\021POSIX_ERROR_EPERM\020\001\022\026\n\022POSIX_ERROR_E"
    "NOENT\020\002\022\025\n\021POSIX_ERROR_EINTR\020\004\022\023\n\017POSIX_"
    "ERROR_EIO\020\005\022\026\n\022POSIX_ERROR_EAGAIN\020\013\022\026\n\022P"
    "OSIX_ERROR_EACCES\020\r\022\026\n\022POSIX_ERROR_EEXIS"
    "T\020\021\022\025\n\021POSIX_ERROR_EXDEV\020\022\022\026\n\022POSIX_ERRO"
    "R_ENODEV\020\023\022\027\n\023POSIX_ERROR_ENOTDIR\020\024\022\026\n\022P"
    "OSIX_ERROR_EISDIR\020\025\022\026\n\022POSIX_ERROR_EINVA"
    "L\020\026\022\026\n\022POSIX_ERROR_ENOSPC\020\034\022\031\n\025POSIX_ERR"
    "OR_ENOTEMPTY\020\'\022\027\n\023POSIX_ERROR_ENODATA\020=B"
    "3\n1org.xtreemfs.foundation.pbrpc.generat"
    "edinterfaces", 1572);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "pbrpc/RPC.proto", &protobuf_RegisterTypes);
  UserCredentials::default_instance_ = new UserCredentials();
  AuthPassword::default_instance_ = new AuthPassword();
  Auth::default_instance_ = new Auth();
  RPCHeader::default_instance_ = new RPCHeader();
  RPCHeader_RequestHeader::default_instance_ = new RPCHeader_RequestHeader();
  RPCHeader_ErrorResponse::default_instance_ = new RPCHeader_ErrorResponse();
  UserCredentials::default_instance_->InitAsDefaultInstance();
  AuthPassword::default_instance_->InitAsDefaultInstance();
  Auth::default_instance_->InitAsDefaultInstance();
  RPCHeader::default_instance_->InitAsDefaultInstance();
  RPCHeader_RequestHeader::default_instance_->InitAsDefaultInstance();
  RPCHeader_ErrorResponse::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_pbrpc_2fRPC_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_pbrpc_2fRPC_2eproto {
  StaticDescriptorInitializer_pbrpc_2fRPC_2eproto() {
    protobuf_AddDesc_pbrpc_2fRPC_2eproto();
  }
} static_descriptor_initializer_pbrpc_2fRPC_2eproto_;
const ::google::protobuf::EnumDescriptor* MessageType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return MessageType_descriptor_;
}
bool MessageType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* AuthType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return AuthType_descriptor_;
}
bool AuthType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* ErrorType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ErrorType_descriptor_;
}
bool ErrorType_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 100:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* POSIXErrno_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return POSIXErrno_descriptor_;
}
bool POSIXErrno_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 4:
    case 5:
    case 11:
    case 13:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 28:
    case 39:
    case 61:
    case 9999:
      return true;
    default:
      return false;
  }
}


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

#ifndef _MSC_VER
const int UserCredentials::kUsernameFieldNumber;
const int UserCredentials::kGroupsFieldNumber;
#endif  // !_MSC_VER

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

void UserCredentials::InitAsDefaultInstance() {
}

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

void UserCredentials::SharedCtor() {
  _cached_size_ = 0;
  username_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void UserCredentials::SharedDtor() {
  if (username_ != &::google::protobuf::internal::kEmptyString) {
    delete username_;
  }
  if (this != default_instance_) {
  }
}

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

const UserCredentials& UserCredentials::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
  return *default_instance_;
}

UserCredentials* UserCredentials::default_instance_ = NULL;

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

void UserCredentials::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_username()) {
      if (username_ != &::google::protobuf::internal::kEmptyString) {
        username_->clear();
      }
    }
  }
  groups_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool UserCredentials::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string username = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_username()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->username().data(), this->username().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_groups;
        break;
      }

      // repeated string groups = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_groups:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_groups()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->groups(this->groups_size() - 1).data(),
            this->groups(this->groups_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_groups;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void UserCredentials::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string username = 1;
  if (has_username()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->username().data(), this->username().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->username(), output);
  }

  // repeated string groups = 2;
  for (int i = 0; i < this->groups_size(); i++) {
  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
    this->groups(i).data(), this->groups(i).length(),
    ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->groups(i), output);
  }

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

::google::protobuf::uint8* UserCredentials::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required string username = 1;
  if (has_username()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->username().data(), this->username().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->username(), target);
  }

  // repeated string groups = 2;
  for (int i = 0; i < this->groups_size(); i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->groups(i).data(), this->groups(i).length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(2, this->groups(i), target);
  }

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

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

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

  }
  // repeated string groups = 2;
  total_size += 1 * this->groups_size();
  for (int i = 0; i < this->groups_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->groups(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void UserCredentials::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const UserCredentials* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const UserCredentials*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void UserCredentials::MergeFrom(const UserCredentials& from) {
  GOOGLE_CHECK_NE(&from, this);
  groups_.MergeFrom(from.groups_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_username()) {
      set_username(from.username());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool UserCredentials::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void UserCredentials::Swap(UserCredentials* other) {
  if (other != this) {
    std::swap(username_, other->username_);
    groups_.Swap(&other->groups_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata UserCredentials::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = UserCredentials_descriptor_;
  metadata.reflection = UserCredentials_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int AuthPassword::kPasswordFieldNumber;
#endif  // !_MSC_VER

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

void AuthPassword::InitAsDefaultInstance() {
}

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

void AuthPassword::SharedCtor() {
  _cached_size_ = 0;
  password_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void AuthPassword::SharedDtor() {
  if (password_ != &::google::protobuf::internal::kEmptyString) {
    delete password_;
  }
  if (this != default_instance_) {
  }
}

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

const AuthPassword& AuthPassword::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
  return *default_instance_;
}

AuthPassword* AuthPassword::default_instance_ = NULL;

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

void AuthPassword::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_password()) {
      if (password_ != &::google::protobuf::internal::kEmptyString) {
        password_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool AuthPassword::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string password = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_password()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->password().data(), this->password().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void AuthPassword::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string password = 1;
  if (has_password()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->password().data(), this->password().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->password(), output);
  }

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

::google::protobuf::uint8* AuthPassword::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required string password = 1;
  if (has_password()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->password().data(), this->password().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->password(), target);
  }

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

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

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

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AuthPassword::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const AuthPassword* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const AuthPassword*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void AuthPassword::MergeFrom(const AuthPassword& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_password()) {
      set_password(from.password());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool AuthPassword::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void AuthPassword::Swap(AuthPassword* other) {
  if (other != this) {
    std::swap(password_, other->password_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata AuthPassword::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = AuthPassword_descriptor_;
  metadata.reflection = AuthPassword_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Auth::kAuthTypeFieldNumber;
const int Auth::kAuthPasswdFieldNumber;
const int Auth::kAuthDataFieldNumber;
#endif  // !_MSC_VER

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

void Auth::InitAsDefaultInstance() {
  auth_passwd_ = const_cast< ::xtreemfs::pbrpc::AuthPassword*>(&::xtreemfs::pbrpc::AuthPassword::default_instance());
}

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

void Auth::SharedCtor() {
  _cached_size_ = 0;
  auth_type_ = 0;
  auth_passwd_ = NULL;
  auth_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void Auth::SharedDtor() {
  if (auth_data_ != &::google::protobuf::internal::kEmptyString) {
    delete auth_data_;
  }
  if (this != default_instance_) {
    delete auth_passwd_;
  }
}

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

const Auth& Auth::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
  return *default_instance_;
}

Auth* Auth::default_instance_ = NULL;

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

void Auth::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    auth_type_ = 0;
    if (has_auth_passwd()) {
      if (auth_passwd_ != NULL) auth_passwd_->::xtreemfs::pbrpc::AuthPassword::Clear();
    }
    if (has_auth_data()) {
      if (auth_data_ != &::google::protobuf::internal::kEmptyString) {
        auth_data_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Auth::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .xtreemfs.pbrpc.AuthType auth_type = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::xtreemfs::pbrpc::AuthType_IsValid(value)) {
            set_auth_type(static_cast< ::xtreemfs::pbrpc::AuthType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_auth_data;
        break;
      }

      // optional bytes auth_data = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_auth_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_auth_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_auth_passwd;
        break;
      }

      // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_auth_passwd:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_auth_passwd()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void Auth::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.AuthType auth_type = 1;
  if (has_auth_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->auth_type(), output);
  }

  // optional bytes auth_data = 2;
  if (has_auth_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      2, this->auth_data(), output);
  }

  // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
  if (has_auth_passwd()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->auth_passwd(), output);
  }

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

::google::protobuf::uint8* Auth::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.AuthType auth_type = 1;
  if (has_auth_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->auth_type(), target);
  }

  // optional bytes auth_data = 2;
  if (has_auth_data()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->auth_data(), target);
  }

  // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
  if (has_auth_passwd()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->auth_passwd(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .xtreemfs.pbrpc.AuthType auth_type = 1;
    if (has_auth_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->auth_type());
    }

    // optional .xtreemfs.pbrpc.AuthPassword auth_passwd = 3;
    if (has_auth_passwd()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->auth_passwd());
    }

    // optional bytes auth_data = 2;
    if (has_auth_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->auth_data());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Auth::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Auth* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Auth*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Auth::MergeFrom(const Auth& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_auth_type()) {
      set_auth_type(from.auth_type());
    }
    if (from.has_auth_passwd()) {
      mutable_auth_passwd()->::xtreemfs::pbrpc::AuthPassword::MergeFrom(from.auth_passwd());
    }
    if (from.has_auth_data()) {
      set_auth_data(from.auth_data());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool Auth::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_auth_passwd()) {
    if (!this->auth_passwd().IsInitialized()) return false;
  }
  return true;
}

void Auth::Swap(Auth* other) {
  if (other != this) {
    std::swap(auth_type_, other->auth_type_);
    std::swap(auth_passwd_, other->auth_passwd_);
    std::swap(auth_data_, other->auth_data_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata Auth::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Auth_descriptor_;
  metadata.reflection = Auth_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int RPCHeader_RequestHeader::kInterfaceIdFieldNumber;
const int RPCHeader_RequestHeader::kProcIdFieldNumber;
const int RPCHeader_RequestHeader::kUserCredsFieldNumber;
const int RPCHeader_RequestHeader::kAuthDataFieldNumber;
#endif  // !_MSC_VER

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

void RPCHeader_RequestHeader::InitAsDefaultInstance() {
  user_creds_ = const_cast< ::xtreemfs::pbrpc::UserCredentials*>(&::xtreemfs::pbrpc::UserCredentials::default_instance());
  auth_data_ = const_cast< ::xtreemfs::pbrpc::Auth*>(&::xtreemfs::pbrpc::Auth::default_instance());
}

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

void RPCHeader_RequestHeader::SharedCtor() {
  _cached_size_ = 0;
  interface_id_ = 0u;
  proc_id_ = 0u;
  user_creds_ = NULL;
  auth_data_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void RPCHeader_RequestHeader::SharedDtor() {
  if (this != default_instance_) {
    delete user_creds_;
    delete auth_data_;
  }
}

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

const RPCHeader_RequestHeader& RPCHeader_RequestHeader::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
  return *default_instance_;
}

RPCHeader_RequestHeader* RPCHeader_RequestHeader::default_instance_ = NULL;

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

void RPCHeader_RequestHeader::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    interface_id_ = 0u;
    proc_id_ = 0u;
    if (has_user_creds()) {
      if (user_creds_ != NULL) user_creds_->::xtreemfs::pbrpc::UserCredentials::Clear();
    }
    if (has_auth_data()) {
      if (auth_data_ != NULL) auth_data_->::xtreemfs::pbrpc::Auth::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool RPCHeader_RequestHeader::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required fixed32 interface_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &interface_id_)));
          set_has_interface_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(21)) goto parse_proc_id;
        break;
      }

      // required fixed32 proc_id = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_proc_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &proc_id_)));
          set_has_proc_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_user_creds;
        break;
      }

      // required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_user_creds:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_user_creds()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_auth_data;
        break;
      }

      // required .xtreemfs.pbrpc.Auth auth_data = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_auth_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_auth_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void RPCHeader_RequestHeader::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed32 interface_id = 1;
  if (has_interface_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->interface_id(), output);
  }

  // required fixed32 proc_id = 2;
  if (has_proc_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->proc_id(), output);
  }

  // required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
  if (has_user_creds()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->user_creds(), output);
  }

  // required .xtreemfs.pbrpc.Auth auth_data = 4;
  if (has_auth_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->auth_data(), output);
  }

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

::google::protobuf::uint8* RPCHeader_RequestHeader::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required fixed32 interface_id = 1;
  if (has_interface_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->interface_id(), target);
  }

  // required fixed32 proc_id = 2;
  if (has_proc_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->proc_id(), target);
  }

  // required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
  if (has_user_creds()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->user_creds(), target);
  }

  // required .xtreemfs.pbrpc.Auth auth_data = 4;
  if (has_auth_data()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->auth_data(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required fixed32 interface_id = 1;
    if (has_interface_id()) {
      total_size += 1 + 4;
    }

    // required fixed32 proc_id = 2;
    if (has_proc_id()) {
      total_size += 1 + 4;
    }

    // required .xtreemfs.pbrpc.UserCredentials user_creds = 3;
    if (has_user_creds()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->user_creds());
    }

    // required .xtreemfs.pbrpc.Auth auth_data = 4;
    if (has_auth_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->auth_data());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RPCHeader_RequestHeader::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const RPCHeader_RequestHeader* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const RPCHeader_RequestHeader*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void RPCHeader_RequestHeader::MergeFrom(const RPCHeader_RequestHeader& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_interface_id()) {
      set_interface_id(from.interface_id());
    }
    if (from.has_proc_id()) {
      set_proc_id(from.proc_id());
    }
    if (from.has_user_creds()) {
      mutable_user_creds()->::xtreemfs::pbrpc::UserCredentials::MergeFrom(from.user_creds());
    }
    if (from.has_auth_data()) {
      mutable_auth_data()->::xtreemfs::pbrpc::Auth::MergeFrom(from.auth_data());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool RPCHeader_RequestHeader::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;

  if (has_user_creds()) {
    if (!this->user_creds().IsInitialized()) return false;
  }
  if (has_auth_data()) {
    if (!this->auth_data().IsInitialized()) return false;
  }
  return true;
}

void RPCHeader_RequestHeader::Swap(RPCHeader_RequestHeader* other) {
  if (other != this) {
    std::swap(interface_id_, other->interface_id_);
    std::swap(proc_id_, other->proc_id_);
    std::swap(user_creds_, other->user_creds_);
    std::swap(auth_data_, other->auth_data_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata RPCHeader_RequestHeader::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = RPCHeader_RequestHeader_descriptor_;
  metadata.reflection = RPCHeader_RequestHeader_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int RPCHeader_ErrorResponse::kErrorTypeFieldNumber;
const int RPCHeader_ErrorResponse::kPosixErrnoFieldNumber;
const int RPCHeader_ErrorResponse::kErrorMessageFieldNumber;
const int RPCHeader_ErrorResponse::kDebugInfoFieldNumber;
const int RPCHeader_ErrorResponse::kRedirectToServerUuidFieldNumber;
#endif  // !_MSC_VER

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

void RPCHeader_ErrorResponse::InitAsDefaultInstance() {
}

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

void RPCHeader_ErrorResponse::SharedCtor() {
  _cached_size_ = 0;
  error_type_ = 1;
  posix_errno_ = 9999;
  error_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  debug_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  redirect_to_server_uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void RPCHeader_ErrorResponse::SharedDtor() {
  if (error_message_ != &::google::protobuf::internal::kEmptyString) {
    delete error_message_;
  }
  if (debug_info_ != &::google::protobuf::internal::kEmptyString) {
    delete debug_info_;
  }
  if (redirect_to_server_uuid_ != &::google::protobuf::internal::kEmptyString) {
    delete redirect_to_server_uuid_;
  }
  if (this != default_instance_) {
  }
}

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

const RPCHeader_ErrorResponse& RPCHeader_ErrorResponse::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
  return *default_instance_;
}

RPCHeader_ErrorResponse* RPCHeader_ErrorResponse::default_instance_ = NULL;

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

void RPCHeader_ErrorResponse::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    error_type_ = 1;
    posix_errno_ = 9999;
    if (has_error_message()) {
      if (error_message_ != &::google::protobuf::internal::kEmptyString) {
        error_message_->clear();
      }
    }
    if (has_debug_info()) {
      if (debug_info_ != &::google::protobuf::internal::kEmptyString) {
        debug_info_->clear();
      }
    }
    if (has_redirect_to_server_uuid()) {
      if (redirect_to_server_uuid_ != &::google::protobuf::internal::kEmptyString) {
        redirect_to_server_uuid_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool RPCHeader_ErrorResponse::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .xtreemfs.pbrpc.ErrorType error_type = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::xtreemfs::pbrpc::ErrorType_IsValid(value)) {
            set_error_type(static_cast< ::xtreemfs::pbrpc::ErrorType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_posix_errno;
        break;
      }

      // optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE];
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_posix_errno:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::xtreemfs::pbrpc::POSIXErrno_IsValid(value)) {
            set_posix_errno(static_cast< ::xtreemfs::pbrpc::POSIXErrno >(value));
          } else {
            mutable_unknown_fields()->AddVarint(2, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_error_message;
        break;
      }

      // optional string error_message = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_error_message:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_error_message()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->error_message().data(), this->error_message().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_debug_info;
        break;
      }

      // optional string debug_info = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_debug_info:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_debug_info()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->debug_info().data(), this->debug_info().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_redirect_to_server_uuid;
        break;
      }

      // optional string redirect_to_server_uuid = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_redirect_to_server_uuid:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_redirect_to_server_uuid()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->redirect_to_server_uuid().data(), this->redirect_to_server_uuid().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void RPCHeader_ErrorResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.ErrorType error_type = 1;
  if (has_error_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->error_type(), output);
  }

  // optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE];
  if (has_posix_errno()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->posix_errno(), output);
  }

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

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

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

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

::google::protobuf::uint8* RPCHeader_ErrorResponse::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.ErrorType error_type = 1;
  if (has_error_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->error_type(), target);
  }

  // optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE];
  if (has_posix_errno()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->posix_errno(), target);
  }

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

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

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

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .xtreemfs.pbrpc.ErrorType error_type = 1;
    if (has_error_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->error_type());
    }

    // optional .xtreemfs.pbrpc.POSIXErrno posix_errno = 2 [default = POSIX_ERROR_NONE];
    if (has_posix_errno()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->posix_errno());
    }

    // optional string error_message = 3;
    if (has_error_message()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->error_message());
    }

    // optional string debug_info = 4;
    if (has_debug_info()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->debug_info());
    }

    // optional string redirect_to_server_uuid = 5;
    if (has_redirect_to_server_uuid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->redirect_to_server_uuid());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RPCHeader_ErrorResponse::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const RPCHeader_ErrorResponse* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const RPCHeader_ErrorResponse*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void RPCHeader_ErrorResponse::MergeFrom(const RPCHeader_ErrorResponse& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_error_type()) {
      set_error_type(from.error_type());
    }
    if (from.has_posix_errno()) {
      set_posix_errno(from.posix_errno());
    }
    if (from.has_error_message()) {
      set_error_message(from.error_message());
    }
    if (from.has_debug_info()) {
      set_debug_info(from.debug_info());
    }
    if (from.has_redirect_to_server_uuid()) {
      set_redirect_to_server_uuid(from.redirect_to_server_uuid());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool RPCHeader_ErrorResponse::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  return true;
}

void RPCHeader_ErrorResponse::Swap(RPCHeader_ErrorResponse* other) {
  if (other != this) {
    std::swap(error_type_, other->error_type_);
    std::swap(posix_errno_, other->posix_errno_);
    std::swap(error_message_, other->error_message_);
    std::swap(debug_info_, other->debug_info_);
    std::swap(redirect_to_server_uuid_, other->redirect_to_server_uuid_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata RPCHeader_ErrorResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = RPCHeader_ErrorResponse_descriptor_;
  metadata.reflection = RPCHeader_ErrorResponse_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int RPCHeader::kCallIdFieldNumber;
const int RPCHeader::kMessageTypeFieldNumber;
const int RPCHeader::kRequestHeaderFieldNumber;
const int RPCHeader::kErrorResponseFieldNumber;
#endif  // !_MSC_VER

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

void RPCHeader::InitAsDefaultInstance() {
  request_header_ = const_cast< ::xtreemfs::pbrpc::RPCHeader_RequestHeader*>(&::xtreemfs::pbrpc::RPCHeader_RequestHeader::default_instance());
  error_response_ = const_cast< ::xtreemfs::pbrpc::RPCHeader_ErrorResponse*>(&::xtreemfs::pbrpc::RPCHeader_ErrorResponse::default_instance());
}

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

void RPCHeader::SharedCtor() {
  _cached_size_ = 0;
  call_id_ = 0u;
  message_type_ = 0;
  request_header_ = NULL;
  error_response_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void RPCHeader::SharedDtor() {
  if (this != default_instance_) {
    delete request_header_;
    delete error_response_;
  }
}

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

const RPCHeader& RPCHeader::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_pbrpc_2fRPC_2eproto();
  return *default_instance_;
}

RPCHeader* RPCHeader::default_instance_ = NULL;

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

void RPCHeader::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    call_id_ = 0u;
    message_type_ = 0;
    if (has_request_header()) {
      if (request_header_ != NULL) request_header_->::xtreemfs::pbrpc::RPCHeader_RequestHeader::Clear();
    }
    if (has_error_response()) {
      if (error_response_ != NULL) error_response_->::xtreemfs::pbrpc::RPCHeader_ErrorResponse::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool RPCHeader::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required fixed32 call_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &call_id_)));
          set_has_call_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_message_type;
        break;
      }

      // required .xtreemfs.pbrpc.MessageType message_type = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_message_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::xtreemfs::pbrpc::MessageType_IsValid(value)) {
            set_message_type(static_cast< ::xtreemfs::pbrpc::MessageType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(2, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_request_header;
        break;
      }

      // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_request_header:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_request_header()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_error_response;
        break;
      }

      // optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_error_response:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_error_response()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void RPCHeader::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed32 call_id = 1;
  if (has_call_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->call_id(), output);
  }

  // required .xtreemfs.pbrpc.MessageType message_type = 2;
  if (has_message_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->message_type(), output);
  }

  // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
  if (has_request_header()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->request_header(), output);
  }

  // optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
  if (has_error_response()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->error_response(), output);
  }

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

::google::protobuf::uint8* RPCHeader::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required fixed32 call_id = 1;
  if (has_call_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->call_id(), target);
  }

  // required .xtreemfs.pbrpc.MessageType message_type = 2;
  if (has_message_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->message_type(), target);
  }

  // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
  if (has_request_header()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->request_header(), target);
  }

  // optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
  if (has_error_response()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->error_response(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required fixed32 call_id = 1;
    if (has_call_id()) {
      total_size += 1 + 4;
    }

    // required .xtreemfs.pbrpc.MessageType message_type = 2;
    if (has_message_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->message_type());
    }

    // optional .xtreemfs.pbrpc.RPCHeader.RequestHeader request_header = 3;
    if (has_request_header()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->request_header());
    }

    // optional .xtreemfs.pbrpc.RPCHeader.ErrorResponse error_response = 4;
    if (has_error_response()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->error_response());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RPCHeader::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const RPCHeader* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const RPCHeader*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void RPCHeader::MergeFrom(const RPCHeader& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_call_id()) {
      set_call_id(from.call_id());
    }
    if (from.has_message_type()) {
      set_message_type(from.message_type());
    }
    if (from.has_request_header()) {
      mutable_request_header()->::xtreemfs::pbrpc::RPCHeader_RequestHeader::MergeFrom(from.request_header());
    }
    if (from.has_error_response()) {
      mutable_error_response()->::xtreemfs::pbrpc::RPCHeader_ErrorResponse::MergeFrom(from.error_response());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool RPCHeader::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  if (has_request_header()) {
    if (!this->request_header().IsInitialized()) return false;
  }
  if (has_error_response()) {
    if (!this->error_response().IsInitialized()) return false;
  }
  return true;
}

void RPCHeader::Swap(RPCHeader* other) {
  if (other != this) {
    std::swap(call_id_, other->call_id_);
    std::swap(message_type_, other->message_type_);
    std::swap(request_header_, other->request_header_);
    std::swap(error_response_, other->error_response_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata RPCHeader::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = RPCHeader_descriptor_;
  metadata.reflection = RPCHeader_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace pbrpc
}  // namespace xtreemfs

// @@protoc_insertion_point(global_scope)