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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "xtreemfs/DIR.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* AddressMapping_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  AddressMapping_reflection_ = NULL;
const ::google::protobuf::Descriptor* AddressMappingSet_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  AddressMappingSet_reflection_ = NULL;
const ::google::protobuf::Descriptor* DirService_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DirService_reflection_ = NULL;
const ::google::protobuf::Descriptor* ServiceDataMap_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ServiceDataMap_reflection_ = NULL;
const ::google::protobuf::Descriptor* Service_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Service_reflection_ = NULL;
const ::google::protobuf::Descriptor* ServiceSet_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ServiceSet_reflection_ = NULL;
const ::google::protobuf::Descriptor* Configuration_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  Configuration_reflection_ = NULL;
const ::google::protobuf::Descriptor* addressMappingGetRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  addressMappingGetRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* addressMappingGetResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  addressMappingGetResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* addressMappingSetResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  addressMappingSetResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* globalTimeSGetResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  globalTimeSGetResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* serviceDeregisterRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  serviceDeregisterRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* serviceGetByNameRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  serviceGetByNameRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* serviceGetByUUIDRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  serviceGetByUUIDRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* serviceGetByTypeRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  serviceGetByTypeRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* serviceRegisterRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  serviceRegisterRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* serviceRegisterResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  serviceRegisterResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* configurationGetRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  configurationGetRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* configurationSetResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  configurationSetResponse_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* ServiceType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ServiceStatus_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_xtreemfs_2fDIR_2eproto() {
  protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "xtreemfs/DIR.proto");
  GOOGLE_CHECK(file != NULL);
  AddressMapping_descriptor_ = file->message_type(0);
  static const int AddressMapping_offsets_[8] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, uuid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, protocol_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, port_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, match_network_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, ttl_s_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, uri_),
  };
  AddressMapping_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      AddressMapping_descriptor_,
      AddressMapping::default_instance_,
      AddressMapping_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMapping, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(AddressMapping));
  AddressMappingSet_descriptor_ = file->message_type(1);
  static const int AddressMappingSet_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMappingSet, mappings_),
  };
  AddressMappingSet_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      AddressMappingSet_descriptor_,
      AddressMappingSet::default_instance_,
      AddressMappingSet_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMappingSet, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddressMappingSet, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(AddressMappingSet));
  DirService_descriptor_ = file->message_type(2);
  static const int DirService_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, port_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, protocol_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, interface_version_),
  };
  DirService_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DirService_descriptor_,
      DirService::default_instance_,
      DirService_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DirService, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DirService));
  ServiceDataMap_descriptor_ = file->message_type(3);
  static const int ServiceDataMap_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDataMap, data_),
  };
  ServiceDataMap_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ServiceDataMap_descriptor_,
      ServiceDataMap::default_instance_,
      ServiceDataMap_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDataMap, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDataMap, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ServiceDataMap));
  Service_descriptor_ = file->message_type(4);
  static const int Service_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, uuid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, last_updated_s_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, data_),
  };
  Service_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Service_descriptor_,
      Service::default_instance_,
      Service_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Service, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Service));
  ServiceSet_descriptor_ = file->message_type(5);
  static const int ServiceSet_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceSet, services_),
  };
  ServiceSet_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ServiceSet_descriptor_,
      ServiceSet::default_instance_,
      ServiceSet_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceSet, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceSet, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ServiceSet));
  Configuration_descriptor_ = file->message_type(6);
  static const int Configuration_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, uuid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, parameter_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, version_),
  };
  Configuration_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      Configuration_descriptor_,
      Configuration::default_instance_,
      Configuration_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Configuration, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(Configuration));
  addressMappingGetRequest_descriptor_ = file->message_type(7);
  static const int addressMappingGetRequest_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetRequest, uuid_),
  };
  addressMappingGetRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      addressMappingGetRequest_descriptor_,
      addressMappingGetRequest::default_instance_,
      addressMappingGetRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(addressMappingGetRequest));
  addressMappingGetResponse_descriptor_ = file->message_type(8);
  static const int addressMappingGetResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetResponse, result_),
  };
  addressMappingGetResponse_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      addressMappingGetResponse_descriptor_,
      addressMappingGetResponse::default_instance_,
      addressMappingGetResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetResponse, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingGetResponse, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(addressMappingGetResponse));
  addressMappingSetResponse_descriptor_ = file->message_type(9);
  static const int addressMappingSetResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingSetResponse, new_version_),
  };
  addressMappingSetResponse_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      addressMappingSetResponse_descriptor_,
      addressMappingSetResponse::default_instance_,
      addressMappingSetResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingSetResponse, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(addressMappingSetResponse, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(addressMappingSetResponse));
  globalTimeSGetResponse_descriptor_ = file->message_type(10);
  static const int globalTimeSGetResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(globalTimeSGetResponse, time_in_seconds_),
  };
  globalTimeSGetResponse_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      globalTimeSGetResponse_descriptor_,
      globalTimeSGetResponse::default_instance_,
      globalTimeSGetResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(globalTimeSGetResponse, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(globalTimeSGetResponse, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(globalTimeSGetResponse));
  serviceDeregisterRequest_descriptor_ = file->message_type(11);
  static const int serviceDeregisterRequest_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceDeregisterRequest, uuid_),
  };
  serviceDeregisterRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      serviceDeregisterRequest_descriptor_,
      serviceDeregisterRequest::default_instance_,
      serviceDeregisterRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceDeregisterRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceDeregisterRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(serviceDeregisterRequest));
  serviceGetByNameRequest_descriptor_ = file->message_type(12);
  static const int serviceGetByNameRequest_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByNameRequest, name_),
  };
  serviceGetByNameRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      serviceGetByNameRequest_descriptor_,
      serviceGetByNameRequest::default_instance_,
      serviceGetByNameRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByNameRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByNameRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(serviceGetByNameRequest));
  serviceGetByUUIDRequest_descriptor_ = file->message_type(13);
  static const int serviceGetByUUIDRequest_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByUUIDRequest, name_),
  };
  serviceGetByUUIDRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      serviceGetByUUIDRequest_descriptor_,
      serviceGetByUUIDRequest::default_instance_,
      serviceGetByUUIDRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByUUIDRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByUUIDRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(serviceGetByUUIDRequest));
  serviceGetByTypeRequest_descriptor_ = file->message_type(14);
  static const int serviceGetByTypeRequest_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByTypeRequest, type_),
  };
  serviceGetByTypeRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      serviceGetByTypeRequest_descriptor_,
      serviceGetByTypeRequest::default_instance_,
      serviceGetByTypeRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByTypeRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceGetByTypeRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(serviceGetByTypeRequest));
  serviceRegisterRequest_descriptor_ = file->message_type(15);
  static const int serviceRegisterRequest_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterRequest, service_),
  };
  serviceRegisterRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      serviceRegisterRequest_descriptor_,
      serviceRegisterRequest::default_instance_,
      serviceRegisterRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(serviceRegisterRequest));
  serviceRegisterResponse_descriptor_ = file->message_type(16);
  static const int serviceRegisterResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterResponse, new_version_),
  };
  serviceRegisterResponse_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      serviceRegisterResponse_descriptor_,
      serviceRegisterResponse::default_instance_,
      serviceRegisterResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterResponse, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(serviceRegisterResponse, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(serviceRegisterResponse));
  configurationGetRequest_descriptor_ = file->message_type(17);
  static const int configurationGetRequest_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationGetRequest, uuid_),
  };
  configurationGetRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      configurationGetRequest_descriptor_,
      configurationGetRequest::default_instance_,
      configurationGetRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationGetRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationGetRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(configurationGetRequest));
  configurationSetResponse_descriptor_ = file->message_type(18);
  static const int configurationSetResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationSetResponse, new_version_),
  };
  configurationSetResponse_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      configurationSetResponse_descriptor_,
      configurationSetResponse::default_instance_,
      configurationSetResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationSetResponse, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(configurationSetResponse, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(configurationSetResponse));
  ServiceType_descriptor_ = file->enum_type(0);
  ServiceStatus_descriptor_ = file->enum_type(1);
}

namespace {

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

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    AddressMapping_descriptor_, &AddressMapping::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    AddressMappingSet_descriptor_, &AddressMappingSet::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DirService_descriptor_, &DirService::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ServiceDataMap_descriptor_, &ServiceDataMap::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Service_descriptor_, &Service::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ServiceSet_descriptor_, &ServiceSet::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    Configuration_descriptor_, &Configuration::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    addressMappingGetRequest_descriptor_, &addressMappingGetRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    addressMappingGetResponse_descriptor_, &addressMappingGetResponse::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    addressMappingSetResponse_descriptor_, &addressMappingSetResponse::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    globalTimeSGetResponse_descriptor_, &globalTimeSGetResponse::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    serviceDeregisterRequest_descriptor_, &serviceDeregisterRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    serviceGetByNameRequest_descriptor_, &serviceGetByNameRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    serviceGetByUUIDRequest_descriptor_, &serviceGetByUUIDRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    serviceGetByTypeRequest_descriptor_, &serviceGetByTypeRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    serviceRegisterRequest_descriptor_, &serviceRegisterRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    serviceRegisterResponse_descriptor_, &serviceRegisterResponse::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    configurationGetRequest_descriptor_, &configurationGetRequest::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    configurationSetResponse_descriptor_, &configurationSetResponse::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto() {
  delete AddressMapping::default_instance_;
  delete AddressMapping_reflection_;
  delete AddressMappingSet::default_instance_;
  delete AddressMappingSet_reflection_;
  delete DirService::default_instance_;
  delete DirService_reflection_;
  delete ServiceDataMap::default_instance_;
  delete ServiceDataMap_reflection_;
  delete Service::default_instance_;
  delete Service_reflection_;
  delete ServiceSet::default_instance_;
  delete ServiceSet_reflection_;
  delete Configuration::default_instance_;
  delete Configuration_reflection_;
  delete addressMappingGetRequest::default_instance_;
  delete addressMappingGetRequest_reflection_;
  delete addressMappingGetResponse::default_instance_;
  delete addressMappingGetResponse_reflection_;
  delete addressMappingSetResponse::default_instance_;
  delete addressMappingSetResponse_reflection_;
  delete globalTimeSGetResponse::default_instance_;
  delete globalTimeSGetResponse_reflection_;
  delete serviceDeregisterRequest::default_instance_;
  delete serviceDeregisterRequest_reflection_;
  delete serviceGetByNameRequest::default_instance_;
  delete serviceGetByNameRequest_reflection_;
  delete serviceGetByUUIDRequest::default_instance_;
  delete serviceGetByUUIDRequest_reflection_;
  delete serviceGetByTypeRequest::default_instance_;
  delete serviceGetByTypeRequest_reflection_;
  delete serviceRegisterRequest::default_instance_;
  delete serviceRegisterRequest_reflection_;
  delete serviceRegisterResponse::default_instance_;
  delete serviceRegisterResponse_reflection_;
  delete configurationGetRequest::default_instance_;
  delete configurationGetRequest_reflection_;
  delete configurationSetResponse::default_instance_;
  delete configurationSetResponse_reflection_;
}

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

  ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fPBRPC_2eproto();
  ::xtreemfs::pbrpc::protobuf_AddDesc_include_2fCommon_2eproto();
  ::xtreemfs::pbrpc::protobuf_AddDesc_xtreemfs_2fGlobalTypes_2eproto();
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\022xtreemfs/DIR.proto\022\016xtreemfs.pbrpc\032\023in"
    "clude/PBRPC.proto\032\024include/Common.proto\032"
    "\032xtreemfs/GlobalTypes.proto\"\223\001\n\016AddressM"
    "apping\022\014\n\004uuid\030\001 \002(\t\022\017\n\007version\030\002 \002(\006\022\020\n"
    "\010protocol\030\003 \002(\t\022\017\n\007address\030\004 \002(\t\022\014\n\004port"
    "\030\005 \002(\007\022\025\n\rmatch_network\030\006 \002(\t\022\r\n\005ttl_s\030\007"
    " \002(\007\022\013\n\003uri\030\010 \002(\t\"E\n\021AddressMappingSet\0220"
    "\n\010mappings\030\001 \003(\0132\036.xtreemfs.pbrpc.Addres"
    "sMapping\"X\n\nDirService\022\017\n\007address\030\001 \002(\t\022"
    "\014\n\004port\030\002 \002(\007\022\020\n\010protocol\030\003 \002(\t\022\031\n\021inter"
    "face_version\030\004 \002(\007\"<\n\016ServiceDataMap\022*\n\004"
    "data\030\001 \003(\0132\034.xtreemfs.pbrpc.KeyValuePair"
    "\"\247\001\n\007Service\022)\n\004type\030\001 \002(\0162\033.xtreemfs.pb"
    "rpc.ServiceType\022\014\n\004uuid\030\002 \002(\t\022\017\n\007version"
    "\030\003 \002(\006\022\014\n\004name\030\004 \002(\t\022\026\n\016last_updated_s\030\005"
    " \002(\006\022,\n\004data\030\006 \002(\0132\036.xtreemfs.pbrpc.Serv"
    "iceDataMap\"7\n\nServiceSet\022)\n\010services\030\001 \003"
    "(\0132\027.xtreemfs.pbrpc.Service\"_\n\rConfigura"
    "tion\022\014\n\004uuid\030\001 \002(\t\022/\n\tparameter\030\002 \003(\0132\034."
    "xtreemfs.pbrpc.KeyValuePair\022\017\n\007version\030\003"
    " \002(\006\"(\n\030addressMappingGetRequest\022\014\n\004uuid"
    "\030\001 \002(\t\"N\n\031addressMappingGetResponse\0221\n\006r"
    "esult\030\001 \001(\0132!.xtreemfs.pbrpc.AddressMapp"
    "ingSet\"0\n\031addressMappingSetResponse\022\023\n\013n"
    "ew_version\030\001 \001(\006\"1\n\026globalTimeSGetRespon"
    "se\022\027\n\017time_in_seconds\030\001 \002(\006\"(\n\030serviceDe"
    "registerRequest\022\014\n\004uuid\030\001 \002(\t\"\'\n\027service"
    "GetByNameRequest\022\014\n\004name\030\001 \002(\t\"\'\n\027servic"
    "eGetByUUIDRequest\022\014\n\004name\030\001 \002(\t\"D\n\027servi"
    "ceGetByTypeRequest\022)\n\004type\030\001 \002(\0162\033.xtree"
    "mfs.pbrpc.ServiceType\"B\n\026serviceRegister"
    "Request\022(\n\007service\030\001 \002(\0132\027.xtreemfs.pbrp"
    "c.Service\".\n\027serviceRegisterResponse\022\023\n\013"
    "new_version\030\001 \002(\006\"\'\n\027configurationGetReq"
    "uest\022\014\n\004uuid\030\001 \002(\t\"/\n\030configurationSetRe"
    "sponse\022\023\n\013new_version\030\001 \001(\006*\200\001\n\013ServiceT"
    "ype\022\026\n\022SERVICE_TYPE_MIXED\020\000\022\024\n\020SERVICE_T"
    "YPE_MRC\020\001\022\024\n\020SERVICE_TYPE_OSD\020\002\022\027\n\023SERVI"
    "CE_TYPE_VOLUME\020\003\022\024\n\020SERVICE_TYPE_DIR\020\004*g"
    "\n\rServiceStatus\022\030\n\024SERVICE_STATUS_AVAIL\020"
    "\000\022 \n\034SERVICE_STATUS_TO_BE_REMOVED\020\001\022\032\n\026S"
    "ERVICE_STATUS_REMOVED\020\0022\355\r\n\020DirectorySer"
    "vice\022u\n\035xtreemfs_address_mappings_get\022(."
    "xtreemfs.pbrpc.addressMappingGetRequest\032"
    "!.xtreemfs.pbrpc.AddressMappingSet\"\007\215\265\030\001"
    "\000\000\000\022t\n xtreemfs_address_mappings_remove\022"
    "(.xtreemfs.pbrpc.addressMappingGetReques"
    "t\032\035.xtreemfs.pbrpc.emptyResponse\"\007\215\265\030\002\000\000"
    "\000\022v\n\035xtreemfs_address_mappings_set\022!.xtr"
    "eemfs.pbrpc.AddressMappingSet\032).xtreemfs"
    ".pbrpc.addressMappingSetResponse\"\007\215\265\030\003\000\000"
    "\000\022Z\n\025xtreemfs_discover_dir\022\034.xtreemfs.pb"
    "rpc.emptyRequest\032\032.xtreemfs.pbrpc.DirSer"
    "vice\"\007\215\265\030\004\000\000\000\022k\n\032xtreemfs_global_time_s_"
    "get\022\034.xtreemfs.pbrpc.emptyRequest\032&.xtre"
    "emfs.pbrpc.globalTimeSGetResponse\"\007\215\265\030\005\000"
    "\000\000\022o\n\033xtreemfs_service_deregister\022(.xtre"
    "emfs.pbrpc.serviceDeregisterRequest\032\035.xt"
    "reemfs.pbrpc.emptyResponse\"\007\215\265\030\006\000\000\000\022l\n\034x"
    "treemfs_service_get_by_name\022\'.xtreemfs.p"
    "brpc.serviceGetByNameRequest\032\032.xtreemfs."
    "pbrpc.ServiceSet\"\007\215\265\030\007\000\000\000\022l\n\034xtreemfs_se"
    "rvice_get_by_type\022\'.xtreemfs.pbrpc.servi"
    "ceGetByTypeRequest\032\032.xtreemfs.pbrpc.Serv"
    "iceSet\"\007\215\265\030\010\000\000\000\022l\n\034xtreemfs_service_get_"
    "by_uuid\022\'.xtreemfs.pbrpc.serviceGetByUUI"
    "DRequest\032\032.xtreemfs.pbrpc.ServiceSet\"\007\215\265"
    "\030\t\000\000\000\022k\n\030xtreemfs_service_offline\022\'.xtre"
    "emfs.pbrpc.serviceGetByUUIDRequest\032\035.xtr"
    "eemfs.pbrpc.emptyResponse\"\007\215\265\030\n\000\000\000\022u\n\031xt"
    "reemfs_service_register\022&.xtreemfs.pbrpc"
    ".serviceRegisterRequest\032\'.xtreemfs.pbrpc"
    ".serviceRegisterResponse\"\007\215\265\030\013\000\000\000\022[\n\023xtr"
    "eemfs_checkpoint\022\034.xtreemfs.pbrpc.emptyR"
    "equest\032\035.xtreemfs.pbrpc.emptyResponse\"\007\215"
    "\265\030\024\000\000\000\022Y\n\021xtreemfs_shutdown\022\034.xtreemfs.p"
    "brpc.emptyRequest\032\035.xtreemfs.pbrpc.empty"
    "Response\"\007\215\265\030\025\000\000\000\022m\n\032xtreemfs_configurat"
    "ion_get\022\'.xtreemfs.pbrpc.configurationGe"
    "tRequest\032\035.xtreemfs.pbrpc.Configuration\""
    "\007\215\265\030\026\000\000\000\022n\n\032xtreemfs_configuration_set\022\035"
    ".xtreemfs.pbrpc.Configuration\032(.xtreemfs"
    ".pbrpc.configurationSetResponse\"\007\215\265\030\027\000\000\000"
    "\022l\n\036xtreemfs_vivaldi_client_update\022\".xtr"
    "eemfs.pbrpc.VivaldiCoordinates\032\035.xtreemf"
    "s.pbrpc.emptyResponse\"\007\215\265\030\030\000\000\000\032\007\225\265\030\021\'\000\000B"
    "(\n&org.xtreemfs.pbrpc.generatedinterface"
    "s", 3481);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "xtreemfs/DIR.proto", &protobuf_RegisterTypes);
  AddressMapping::default_instance_ = new AddressMapping();
  AddressMappingSet::default_instance_ = new AddressMappingSet();
  DirService::default_instance_ = new DirService();
  ServiceDataMap::default_instance_ = new ServiceDataMap();
  Service::default_instance_ = new Service();
  ServiceSet::default_instance_ = new ServiceSet();
  Configuration::default_instance_ = new Configuration();
  addressMappingGetRequest::default_instance_ = new addressMappingGetRequest();
  addressMappingGetResponse::default_instance_ = new addressMappingGetResponse();
  addressMappingSetResponse::default_instance_ = new addressMappingSetResponse();
  globalTimeSGetResponse::default_instance_ = new globalTimeSGetResponse();
  serviceDeregisterRequest::default_instance_ = new serviceDeregisterRequest();
  serviceGetByNameRequest::default_instance_ = new serviceGetByNameRequest();
  serviceGetByUUIDRequest::default_instance_ = new serviceGetByUUIDRequest();
  serviceGetByTypeRequest::default_instance_ = new serviceGetByTypeRequest();
  serviceRegisterRequest::default_instance_ = new serviceRegisterRequest();
  serviceRegisterResponse::default_instance_ = new serviceRegisterResponse();
  configurationGetRequest::default_instance_ = new configurationGetRequest();
  configurationSetResponse::default_instance_ = new configurationSetResponse();
  AddressMapping::default_instance_->InitAsDefaultInstance();
  AddressMappingSet::default_instance_->InitAsDefaultInstance();
  DirService::default_instance_->InitAsDefaultInstance();
  ServiceDataMap::default_instance_->InitAsDefaultInstance();
  Service::default_instance_->InitAsDefaultInstance();
  ServiceSet::default_instance_->InitAsDefaultInstance();
  Configuration::default_instance_->InitAsDefaultInstance();
  addressMappingGetRequest::default_instance_->InitAsDefaultInstance();
  addressMappingGetResponse::default_instance_->InitAsDefaultInstance();
  addressMappingSetResponse::default_instance_->InitAsDefaultInstance();
  globalTimeSGetResponse::default_instance_->InitAsDefaultInstance();
  serviceDeregisterRequest::default_instance_->InitAsDefaultInstance();
  serviceGetByNameRequest::default_instance_->InitAsDefaultInstance();
  serviceGetByUUIDRequest::default_instance_->InitAsDefaultInstance();
  serviceGetByTypeRequest::default_instance_->InitAsDefaultInstance();
  serviceRegisterRequest::default_instance_->InitAsDefaultInstance();
  serviceRegisterResponse::default_instance_->InitAsDefaultInstance();
  configurationGetRequest::default_instance_->InitAsDefaultInstance();
  configurationSetResponse::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_xtreemfs_2fDIR_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_xtreemfs_2fDIR_2eproto {
  StaticDescriptorInitializer_xtreemfs_2fDIR_2eproto() {
    protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  }
} static_descriptor_initializer_xtreemfs_2fDIR_2eproto_;
const ::google::protobuf::EnumDescriptor* ServiceType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ServiceType_descriptor_;
}
bool ServiceType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* ServiceStatus_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ServiceStatus_descriptor_;
}
bool ServiceStatus_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}


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

#ifndef _MSC_VER
const int AddressMapping::kUuidFieldNumber;
const int AddressMapping::kVersionFieldNumber;
const int AddressMapping::kProtocolFieldNumber;
const int AddressMapping::kAddressFieldNumber;
const int AddressMapping::kPortFieldNumber;
const int AddressMapping::kMatchNetworkFieldNumber;
const int AddressMapping::kTtlSFieldNumber;
const int AddressMapping::kUriFieldNumber;
#endif  // !_MSC_VER

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

void AddressMapping::InitAsDefaultInstance() {
}

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

void AddressMapping::SharedCtor() {
  _cached_size_ = 0;
  uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  version_ = GOOGLE_ULONGLONG(0);
  protocol_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  address_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  port_ = 0u;
  match_network_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ttl_s_ = 0u;
  uri_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void AddressMapping::SharedDtor() {
  if (uuid_ != &::google::protobuf::internal::kEmptyString) {
    delete uuid_;
  }
  if (protocol_ != &::google::protobuf::internal::kEmptyString) {
    delete protocol_;
  }
  if (address_ != &::google::protobuf::internal::kEmptyString) {
    delete address_;
  }
  if (match_network_ != &::google::protobuf::internal::kEmptyString) {
    delete match_network_;
  }
  if (uri_ != &::google::protobuf::internal::kEmptyString) {
    delete uri_;
  }
  if (this != default_instance_) {
  }
}

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

const AddressMapping& AddressMapping::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

AddressMapping* AddressMapping::default_instance_ = NULL;

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

void AddressMapping::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_uuid()) {
      if (uuid_ != &::google::protobuf::internal::kEmptyString) {
        uuid_->clear();
      }
    }
    version_ = GOOGLE_ULONGLONG(0);
    if (has_protocol()) {
      if (protocol_ != &::google::protobuf::internal::kEmptyString) {
        protocol_->clear();
      }
    }
    if (has_address()) {
      if (address_ != &::google::protobuf::internal::kEmptyString) {
        address_->clear();
      }
    }
    port_ = 0u;
    if (has_match_network()) {
      if (match_network_ != &::google::protobuf::internal::kEmptyString) {
        match_network_->clear();
      }
    }
    ttl_s_ = 0u;
    if (has_uri()) {
      if (uri_ != &::google::protobuf::internal::kEmptyString) {
        uri_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool AddressMapping::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 uuid = 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_uuid()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->uuid().data(), this->uuid().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(17)) goto parse_version;
        break;
      }

      // required fixed64 version = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &version_)));
          set_has_version();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_protocol;
        break;
      }

      // required string protocol = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_protocol:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_protocol()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->protocol().data(), this->protocol().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_address;
        break;
      }

      // required string address = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_address:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_address()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->address().data(), this->address().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(45)) goto parse_port;
        break;
      }

      // required fixed32 port = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_port:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &port_)));
          set_has_port();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_match_network;
        break;
      }

      // required string match_network = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_match_network:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_match_network()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->match_network().data(), this->match_network().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(61)) goto parse_ttl_s;
        break;
      }

      // required fixed32 ttl_s = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_ttl_s:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &ttl_s_)));
          set_has_ttl_s();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(66)) goto parse_uri;
        break;
      }

      // required string uri = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_uri:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_uri()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->uri().data(), this->uri().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 AddressMapping::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string uuid = 1;
  if (has_uuid()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->uuid().data(), this->uuid().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->uuid(), output);
  }

  // required fixed64 version = 2;
  if (has_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->version(), output);
  }

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

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

  // required fixed32 port = 5;
  if (has_port()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->port(), output);
  }

  // required string match_network = 6;
  if (has_match_network()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->match_network().data(), this->match_network().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      6, this->match_network(), output);
  }

  // required fixed32 ttl_s = 7;
  if (has_ttl_s()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(7, this->ttl_s(), output);
  }

  // required string uri = 8;
  if (has_uri()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->uri().data(), this->uri().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      8, this->uri(), output);
  }

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

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

  // required fixed64 version = 2;
  if (has_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->version(), target);
  }

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

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

  // required fixed32 port = 5;
  if (has_port()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->port(), target);
  }

  // required string match_network = 6;
  if (has_match_network()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->match_network().data(), this->match_network().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        6, this->match_network(), target);
  }

  // required fixed32 ttl_s = 7;
  if (has_ttl_s()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(7, this->ttl_s(), target);
  }

  // required string uri = 8;
  if (has_uri()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->uri().data(), this->uri().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        8, this->uri(), target);
  }

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

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

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

    // required fixed64 version = 2;
    if (has_version()) {
      total_size += 1 + 8;
    }

    // required string protocol = 3;
    if (has_protocol()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->protocol());
    }

    // required string address = 4;
    if (has_address()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->address());
    }

    // required fixed32 port = 5;
    if (has_port()) {
      total_size += 1 + 4;
    }

    // required string match_network = 6;
    if (has_match_network()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->match_network());
    }

    // required fixed32 ttl_s = 7;
    if (has_ttl_s()) {
      total_size += 1 + 4;
    }

    // required string uri = 8;
    if (has_uri()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->uri());
    }

  }
  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 AddressMapping::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const AddressMapping* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const AddressMapping*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void AddressMapping::MergeFrom(const AddressMapping& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_uuid()) {
      set_uuid(from.uuid());
    }
    if (from.has_version()) {
      set_version(from.version());
    }
    if (from.has_protocol()) {
      set_protocol(from.protocol());
    }
    if (from.has_address()) {
      set_address(from.address());
    }
    if (from.has_port()) {
      set_port(from.port());
    }
    if (from.has_match_network()) {
      set_match_network(from.match_network());
    }
    if (from.has_ttl_s()) {
      set_ttl_s(from.ttl_s());
    }
    if (from.has_uri()) {
      set_uri(from.uri());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void AddressMapping::Swap(AddressMapping* other) {
  if (other != this) {
    std::swap(uuid_, other->uuid_);
    std::swap(version_, other->version_);
    std::swap(protocol_, other->protocol_);
    std::swap(address_, other->address_);
    std::swap(port_, other->port_);
    std::swap(match_network_, other->match_network_);
    std::swap(ttl_s_, other->ttl_s_);
    std::swap(uri_, other->uri_);
    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 AddressMapping::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = AddressMapping_descriptor_;
  metadata.reflection = AddressMapping_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int AddressMappingSet::kMappingsFieldNumber;
#endif  // !_MSC_VER

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

void AddressMappingSet::InitAsDefaultInstance() {
}

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

void AddressMappingSet::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void AddressMappingSet::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const AddressMappingSet& AddressMappingSet::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

AddressMappingSet* AddressMappingSet::default_instance_ = NULL;

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

void AddressMappingSet::Clear() {
  mappings_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool AddressMappingSet::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)) {
      // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_mappings:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_mappings()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_mappings;
        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 AddressMappingSet::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1;
  for (int i = 0; i < this->mappings_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->mappings(i), output);
  }

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

::google::protobuf::uint8* AddressMappingSet::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1;
  for (int i = 0; i < this->mappings_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->mappings(i), target);
  }

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

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

  // repeated .xtreemfs.pbrpc.AddressMapping mappings = 1;
  total_size += 1 * this->mappings_size();
  for (int i = 0; i < this->mappings_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->mappings(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 AddressMappingSet::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const AddressMappingSet* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const AddressMappingSet*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void AddressMappingSet::MergeFrom(const AddressMappingSet& from) {
  GOOGLE_CHECK_NE(&from, this);
  mappings_.MergeFrom(from.mappings_);
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool AddressMappingSet::IsInitialized() const {

  for (int i = 0; i < mappings_size(); i++) {
    if (!this->mappings(i).IsInitialized()) return false;
  }
  return true;
}

void AddressMappingSet::Swap(AddressMappingSet* other) {
  if (other != this) {
    mappings_.Swap(&other->mappings_);
    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 AddressMappingSet::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = AddressMappingSet_descriptor_;
  metadata.reflection = AddressMappingSet_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int DirService::kAddressFieldNumber;
const int DirService::kPortFieldNumber;
const int DirService::kProtocolFieldNumber;
const int DirService::kInterfaceVersionFieldNumber;
#endif  // !_MSC_VER

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

void DirService::InitAsDefaultInstance() {
}

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

void DirService::SharedCtor() {
  _cached_size_ = 0;
  address_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  port_ = 0u;
  protocol_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  interface_version_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void DirService::SharedDtor() {
  if (address_ != &::google::protobuf::internal::kEmptyString) {
    delete address_;
  }
  if (protocol_ != &::google::protobuf::internal::kEmptyString) {
    delete protocol_;
  }
  if (this != default_instance_) {
  }
}

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

const DirService& DirService::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

DirService* DirService::default_instance_ = NULL;

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

void DirService::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_address()) {
      if (address_ != &::google::protobuf::internal::kEmptyString) {
        address_->clear();
      }
    }
    port_ = 0u;
    if (has_protocol()) {
      if (protocol_ != &::google::protobuf::internal::kEmptyString) {
        protocol_->clear();
      }
    }
    interface_version_ = 0u;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DirService::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 address = 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_address()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->address().data(), this->address().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(21)) goto parse_port;
        break;
      }

      // required fixed32 port = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_port:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &port_)));
          set_has_port();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_protocol;
        break;
      }

      // required string protocol = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_protocol:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_protocol()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->protocol().data(), this->protocol().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(37)) goto parse_interface_version;
        break;
      }

      // required fixed32 interface_version = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_interface_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &interface_version_)));
          set_has_interface_version();
        } 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 DirService::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string address = 1;
  if (has_address()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->address().data(), this->address().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->address(), output);
  }

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

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

  // required fixed32 interface_version = 4;
  if (has_interface_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->interface_version(), output);
  }

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

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

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

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

  // required fixed32 interface_version = 4;
  if (has_interface_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->interface_version(), target);
  }

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

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

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

    // required fixed32 port = 2;
    if (has_port()) {
      total_size += 1 + 4;
    }

    // required string protocol = 3;
    if (has_protocol()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->protocol());
    }

    // required fixed32 interface_version = 4;
    if (has_interface_version()) {
      total_size += 1 + 4;
    }

  }
  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 DirService::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DirService* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DirService*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DirService::MergeFrom(const DirService& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_address()) {
      set_address(from.address());
    }
    if (from.has_port()) {
      set_port(from.port());
    }
    if (from.has_protocol()) {
      set_protocol(from.protocol());
    }
    if (from.has_interface_version()) {
      set_interface_version(from.interface_version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void DirService::Swap(DirService* other) {
  if (other != this) {
    std::swap(address_, other->address_);
    std::swap(port_, other->port_);
    std::swap(protocol_, other->protocol_);
    std::swap(interface_version_, other->interface_version_);
    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 DirService::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DirService_descriptor_;
  metadata.reflection = DirService_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ServiceDataMap::kDataFieldNumber;
#endif  // !_MSC_VER

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

void ServiceDataMap::InitAsDefaultInstance() {
}

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

void ServiceDataMap::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void ServiceDataMap::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const ServiceDataMap& ServiceDataMap::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

ServiceDataMap* ServiceDataMap::default_instance_ = NULL;

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

void ServiceDataMap::Clear() {
  data_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ServiceDataMap::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)) {
      // repeated .xtreemfs.pbrpc.KeyValuePair data = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_data;
        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 ServiceDataMap::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated .xtreemfs.pbrpc.KeyValuePair data = 1;
  for (int i = 0; i < this->data_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->data(i), output);
  }

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

::google::protobuf::uint8* ServiceDataMap::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated .xtreemfs.pbrpc.KeyValuePair data = 1;
  for (int i = 0; i < this->data_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->data(i), target);
  }

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

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

  // repeated .xtreemfs.pbrpc.KeyValuePair data = 1;
  total_size += 1 * this->data_size();
  for (int i = 0; i < this->data_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->data(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 ServiceDataMap::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ServiceDataMap* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ServiceDataMap*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ServiceDataMap::MergeFrom(const ServiceDataMap& from) {
  GOOGLE_CHECK_NE(&from, this);
  data_.MergeFrom(from.data_);
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool ServiceDataMap::IsInitialized() const {

  for (int i = 0; i < data_size(); i++) {
    if (!this->data(i).IsInitialized()) return false;
  }
  return true;
}

void ServiceDataMap::Swap(ServiceDataMap* other) {
  if (other != this) {
    data_.Swap(&other->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 ServiceDataMap::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ServiceDataMap_descriptor_;
  metadata.reflection = ServiceDataMap_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Service::kTypeFieldNumber;
const int Service::kUuidFieldNumber;
const int Service::kVersionFieldNumber;
const int Service::kNameFieldNumber;
const int Service::kLastUpdatedSFieldNumber;
const int Service::kDataFieldNumber;
#endif  // !_MSC_VER

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

void Service::InitAsDefaultInstance() {
  data_ = const_cast< ::xtreemfs::pbrpc::ServiceDataMap*>(&::xtreemfs::pbrpc::ServiceDataMap::default_instance());
}

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

void Service::SharedCtor() {
  _cached_size_ = 0;
  type_ = 0;
  uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  version_ = GOOGLE_ULONGLONG(0);
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  last_updated_s_ = GOOGLE_ULONGLONG(0);
  data_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void Service::SharedDtor() {
  if (uuid_ != &::google::protobuf::internal::kEmptyString) {
    delete uuid_;
  }
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (this != default_instance_) {
    delete data_;
  }
}

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

const Service& Service::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

Service* Service::default_instance_ = NULL;

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

void Service::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    type_ = 0;
    if (has_uuid()) {
      if (uuid_ != &::google::protobuf::internal::kEmptyString) {
        uuid_->clear();
      }
    }
    version_ = GOOGLE_ULONGLONG(0);
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
    last_updated_s_ = GOOGLE_ULONGLONG(0);
    if (has_data()) {
      if (data_ != NULL) data_->::xtreemfs::pbrpc::ServiceDataMap::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Service::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.ServiceType 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::ServiceType_IsValid(value)) {
            set_type(static_cast< ::xtreemfs::pbrpc::ServiceType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_uuid;
        break;
      }

      // required string uuid = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_uuid:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_uuid()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->uuid().data(), this->uuid().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(25)) goto parse_version;
        break;
      }

      // required fixed64 version = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &version_)));
          set_has_version();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_name;
        break;
      }

      // required string name = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(41)) goto parse_last_updated_s;
        break;
      }

      // required fixed64 last_updated_s = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_last_updated_s:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &last_updated_s_)));
          set_has_last_updated_s();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_data;
        break;
      }

      // required .xtreemfs.pbrpc.ServiceDataMap data = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_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 Service::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.ServiceType type = 1;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // required string uuid = 2;
  if (has_uuid()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->uuid().data(), this->uuid().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->uuid(), output);
  }

  // required fixed64 version = 3;
  if (has_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->version(), output);
  }

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

  // required fixed64 last_updated_s = 5;
  if (has_last_updated_s()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(5, this->last_updated_s(), output);
  }

  // required .xtreemfs.pbrpc.ServiceDataMap data = 6;
  if (has_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, this->data(), output);
  }

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

::google::protobuf::uint8* Service::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.ServiceType type = 1;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // required string uuid = 2;
  if (has_uuid()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->uuid().data(), this->uuid().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->uuid(), target);
  }

  // required fixed64 version = 3;
  if (has_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->version(), target);
  }

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

  // required fixed64 last_updated_s = 5;
  if (has_last_updated_s()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(5, this->last_updated_s(), target);
  }

  // required .xtreemfs.pbrpc.ServiceDataMap data = 6;
  if (has_data()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        6, this->data(), target);
  }

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

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

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

    // required string uuid = 2;
    if (has_uuid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->uuid());
    }

    // required fixed64 version = 3;
    if (has_version()) {
      total_size += 1 + 8;
    }

    // required string name = 4;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // required fixed64 last_updated_s = 5;
    if (has_last_updated_s()) {
      total_size += 1 + 8;
    }

    // required .xtreemfs.pbrpc.ServiceDataMap data = 6;
    if (has_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->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 Service::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Service* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Service*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Service::MergeFrom(const Service& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_uuid()) {
      set_uuid(from.uuid());
    }
    if (from.has_version()) {
      set_version(from.version());
    }
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_last_updated_s()) {
      set_last_updated_s(from.last_updated_s());
    }
    if (from.has_data()) {
      mutable_data()->::xtreemfs::pbrpc::ServiceDataMap::MergeFrom(from.data());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_data()) {
    if (!this->data().IsInitialized()) return false;
  }
  return true;
}

void Service::Swap(Service* other) {
  if (other != this) {
    std::swap(type_, other->type_);
    std::swap(uuid_, other->uuid_);
    std::swap(version_, other->version_);
    std::swap(name_, other->name_);
    std::swap(last_updated_s_, other->last_updated_s_);
    std::swap(data_, other->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 Service::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Service_descriptor_;
  metadata.reflection = Service_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ServiceSet::kServicesFieldNumber;
#endif  // !_MSC_VER

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

void ServiceSet::InitAsDefaultInstance() {
}

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

void ServiceSet::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void ServiceSet::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const ServiceSet& ServiceSet::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

ServiceSet* ServiceSet::default_instance_ = NULL;

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

void ServiceSet::Clear() {
  services_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ServiceSet::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)) {
      // repeated .xtreemfs.pbrpc.Service services = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_services:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_services()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_services;
        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 ServiceSet::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated .xtreemfs.pbrpc.Service services = 1;
  for (int i = 0; i < this->services_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->services(i), output);
  }

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

::google::protobuf::uint8* ServiceSet::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated .xtreemfs.pbrpc.Service services = 1;
  for (int i = 0; i < this->services_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->services(i), target);
  }

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

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

  // repeated .xtreemfs.pbrpc.Service services = 1;
  total_size += 1 * this->services_size();
  for (int i = 0; i < this->services_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->services(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 ServiceSet::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ServiceSet* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ServiceSet*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ServiceSet::MergeFrom(const ServiceSet& from) {
  GOOGLE_CHECK_NE(&from, this);
  services_.MergeFrom(from.services_);
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool ServiceSet::IsInitialized() const {

  for (int i = 0; i < services_size(); i++) {
    if (!this->services(i).IsInitialized()) return false;
  }
  return true;
}

void ServiceSet::Swap(ServiceSet* other) {
  if (other != this) {
    services_.Swap(&other->services_);
    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 ServiceSet::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ServiceSet_descriptor_;
  metadata.reflection = ServiceSet_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int Configuration::kUuidFieldNumber;
const int Configuration::kParameterFieldNumber;
const int Configuration::kVersionFieldNumber;
#endif  // !_MSC_VER

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

void Configuration::InitAsDefaultInstance() {
}

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

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

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

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

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

const Configuration& Configuration::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

Configuration* Configuration::default_instance_ = NULL;

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

void Configuration::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_uuid()) {
      if (uuid_ != &::google::protobuf::internal::kEmptyString) {
        uuid_->clear();
      }
    }
    version_ = GOOGLE_ULONGLONG(0);
  }
  parameter_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool Configuration::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 uuid = 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_uuid()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->uuid().data(), this->uuid().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_parameter;
        break;
      }

      // repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_parameter:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_parameter()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_parameter;
        if (input->ExpectTag(25)) goto parse_version;
        break;
      }

      // required fixed64 version = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         parse_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &version_)));
          set_has_version();
        } 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 Configuration::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string uuid = 1;
  if (has_uuid()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->uuid().data(), this->uuid().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->uuid(), output);
  }

  // repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2;
  for (int i = 0; i < this->parameter_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->parameter(i), output);
  }

  // required fixed64 version = 3;
  if (has_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->version(), output);
  }

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

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

  // repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2;
  for (int i = 0; i < this->parameter_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->parameter(i), target);
  }

  // required fixed64 version = 3;
  if (has_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->version(), target);
  }

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

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

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

    // required fixed64 version = 3;
    if (has_version()) {
      total_size += 1 + 8;
    }

  }
  // repeated .xtreemfs.pbrpc.KeyValuePair parameter = 2;
  total_size += 1 * this->parameter_size();
  for (int i = 0; i < this->parameter_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->parameter(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 Configuration::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const Configuration* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const Configuration*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void Configuration::MergeFrom(const Configuration& from) {
  GOOGLE_CHECK_NE(&from, this);
  parameter_.MergeFrom(from.parameter_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_uuid()) {
      set_uuid(from.uuid());
    }
    if (from.has_version()) {
      set_version(from.version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  for (int i = 0; i < parameter_size(); i++) {
    if (!this->parameter(i).IsInitialized()) return false;
  }
  return true;
}

void Configuration::Swap(Configuration* other) {
  if (other != this) {
    std::swap(uuid_, other->uuid_);
    parameter_.Swap(&other->parameter_);
    std::swap(version_, other->version_);
    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 Configuration::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = Configuration_descriptor_;
  metadata.reflection = Configuration_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int addressMappingGetRequest::kUuidFieldNumber;
#endif  // !_MSC_VER

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

void addressMappingGetRequest::InitAsDefaultInstance() {
}

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

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

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

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

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

const addressMappingGetRequest& addressMappingGetRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

addressMappingGetRequest* addressMappingGetRequest::default_instance_ = NULL;

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

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

bool addressMappingGetRequest::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 uuid = 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_uuid()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->uuid().data(), this->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 addressMappingGetRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string uuid = 1;
  if (has_uuid()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->uuid().data(), this->uuid().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->uuid(), output);
  }

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

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

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string uuid = 1;
    if (has_uuid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->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 addressMappingGetRequest::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const addressMappingGetRequest* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const addressMappingGetRequest*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void addressMappingGetRequest::MergeFrom(const addressMappingGetRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_uuid()) {
      set_uuid(from.uuid());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void addressMappingGetRequest::Swap(addressMappingGetRequest* other) {
  if (other != this) {
    std::swap(uuid_, other->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 addressMappingGetRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = addressMappingGetRequest_descriptor_;
  metadata.reflection = addressMappingGetRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int addressMappingGetResponse::kResultFieldNumber;
#endif  // !_MSC_VER

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

void addressMappingGetResponse::InitAsDefaultInstance() {
  result_ = const_cast< ::xtreemfs::pbrpc::AddressMappingSet*>(&::xtreemfs::pbrpc::AddressMappingSet::default_instance());
}

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

void addressMappingGetResponse::SharedCtor() {
  _cached_size_ = 0;
  result_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void addressMappingGetResponse::SharedDtor() {
  if (this != default_instance_) {
    delete result_;
  }
}

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

const addressMappingGetResponse& addressMappingGetResponse::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

addressMappingGetResponse* addressMappingGetResponse::default_instance_ = NULL;

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

void addressMappingGetResponse::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_result()) {
      if (result_ != NULL) result_->::xtreemfs::pbrpc::AddressMappingSet::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool addressMappingGetResponse::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)) {
      // optional .xtreemfs.pbrpc.AddressMappingSet result = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_result()));
        } 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 addressMappingGetResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .xtreemfs.pbrpc.AddressMappingSet result = 1;
  if (has_result()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->result(), output);
  }

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

::google::protobuf::uint8* addressMappingGetResponse::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .xtreemfs.pbrpc.AddressMappingSet result = 1;
  if (has_result()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->result(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .xtreemfs.pbrpc.AddressMappingSet result = 1;
    if (has_result()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->result());
    }

  }
  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 addressMappingGetResponse::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const addressMappingGetResponse* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const addressMappingGetResponse*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void addressMappingGetResponse::MergeFrom(const addressMappingGetResponse& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_result()) {
      mutable_result()->::xtreemfs::pbrpc::AddressMappingSet::MergeFrom(from.result());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool addressMappingGetResponse::IsInitialized() const {

  if (has_result()) {
    if (!this->result().IsInitialized()) return false;
  }
  return true;
}

void addressMappingGetResponse::Swap(addressMappingGetResponse* other) {
  if (other != this) {
    std::swap(result_, other->result_);
    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 addressMappingGetResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = addressMappingGetResponse_descriptor_;
  metadata.reflection = addressMappingGetResponse_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int addressMappingSetResponse::kNewVersionFieldNumber;
#endif  // !_MSC_VER

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

void addressMappingSetResponse::InitAsDefaultInstance() {
}

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

void addressMappingSetResponse::SharedCtor() {
  _cached_size_ = 0;
  new_version_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void addressMappingSetResponse::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const addressMappingSetResponse& addressMappingSetResponse::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

addressMappingSetResponse* addressMappingSetResponse::default_instance_ = NULL;

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

void addressMappingSetResponse::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    new_version_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool addressMappingSetResponse::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)) {
      // optional fixed64 new_version = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &new_version_)));
          set_has_new_version();
        } 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 addressMappingSetResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional fixed64 new_version = 1;
  if (has_new_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->new_version(), output);
  }

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

::google::protobuf::uint8* addressMappingSetResponse::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional fixed64 new_version = 1;
  if (has_new_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->new_version(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional fixed64 new_version = 1;
    if (has_new_version()) {
      total_size += 1 + 8;
    }

  }
  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 addressMappingSetResponse::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const addressMappingSetResponse* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const addressMappingSetResponse*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void addressMappingSetResponse::MergeFrom(const addressMappingSetResponse& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_new_version()) {
      set_new_version(from.new_version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool addressMappingSetResponse::IsInitialized() const {

  return true;
}

void addressMappingSetResponse::Swap(addressMappingSetResponse* other) {
  if (other != this) {
    std::swap(new_version_, other->new_version_);
    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 addressMappingSetResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = addressMappingSetResponse_descriptor_;
  metadata.reflection = addressMappingSetResponse_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int globalTimeSGetResponse::kTimeInSecondsFieldNumber;
#endif  // !_MSC_VER

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

void globalTimeSGetResponse::InitAsDefaultInstance() {
}

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

void globalTimeSGetResponse::SharedCtor() {
  _cached_size_ = 0;
  time_in_seconds_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void globalTimeSGetResponse::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const globalTimeSGetResponse& globalTimeSGetResponse::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

globalTimeSGetResponse* globalTimeSGetResponse::default_instance_ = NULL;

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

void globalTimeSGetResponse::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    time_in_seconds_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool globalTimeSGetResponse::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 fixed64 time_in_seconds = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &time_in_seconds_)));
          set_has_time_in_seconds();
        } 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 globalTimeSGetResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed64 time_in_seconds = 1;
  if (has_time_in_seconds()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->time_in_seconds(), output);
  }

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

::google::protobuf::uint8* globalTimeSGetResponse::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required fixed64 time_in_seconds = 1;
  if (has_time_in_seconds()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->time_in_seconds(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required fixed64 time_in_seconds = 1;
    if (has_time_in_seconds()) {
      total_size += 1 + 8;
    }

  }
  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 globalTimeSGetResponse::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const globalTimeSGetResponse* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const globalTimeSGetResponse*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void globalTimeSGetResponse::MergeFrom(const globalTimeSGetResponse& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_time_in_seconds()) {
      set_time_in_seconds(from.time_in_seconds());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void globalTimeSGetResponse::Swap(globalTimeSGetResponse* other) {
  if (other != this) {
    std::swap(time_in_seconds_, other->time_in_seconds_);
    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 globalTimeSGetResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = globalTimeSGetResponse_descriptor_;
  metadata.reflection = globalTimeSGetResponse_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int serviceDeregisterRequest::kUuidFieldNumber;
#endif  // !_MSC_VER

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

void serviceDeregisterRequest::InitAsDefaultInstance() {
}

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

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

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

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

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

const serviceDeregisterRequest& serviceDeregisterRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

serviceDeregisterRequest* serviceDeregisterRequest::default_instance_ = NULL;

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

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

bool serviceDeregisterRequest::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 uuid = 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_uuid()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->uuid().data(), this->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 serviceDeregisterRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string uuid = 1;
  if (has_uuid()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->uuid().data(), this->uuid().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->uuid(), output);
  }

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

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

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string uuid = 1;
    if (has_uuid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->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 serviceDeregisterRequest::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const serviceDeregisterRequest* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const serviceDeregisterRequest*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void serviceDeregisterRequest::MergeFrom(const serviceDeregisterRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_uuid()) {
      set_uuid(from.uuid());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void serviceDeregisterRequest::Swap(serviceDeregisterRequest* other) {
  if (other != this) {
    std::swap(uuid_, other->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 serviceDeregisterRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = serviceDeregisterRequest_descriptor_;
  metadata.reflection = serviceDeregisterRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int serviceGetByNameRequest::kNameFieldNumber;
#endif  // !_MSC_VER

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

void serviceGetByNameRequest::InitAsDefaultInstance() {
}

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

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

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

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

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

const serviceGetByNameRequest& serviceGetByNameRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

serviceGetByNameRequest* serviceGetByNameRequest::default_instance_ = NULL;

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

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

bool serviceGetByNameRequest::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 name = 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_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().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 serviceGetByNameRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->name(), output);
  }

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

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

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

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

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

  }
  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 serviceGetByNameRequest::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const serviceGetByNameRequest* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const serviceGetByNameRequest*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void serviceGetByNameRequest::MergeFrom(const serviceGetByNameRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void serviceGetByNameRequest::Swap(serviceGetByNameRequest* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    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 serviceGetByNameRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = serviceGetByNameRequest_descriptor_;
  metadata.reflection = serviceGetByNameRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int serviceGetByUUIDRequest::kNameFieldNumber;
#endif  // !_MSC_VER

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

void serviceGetByUUIDRequest::InitAsDefaultInstance() {
}

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

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

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

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

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

const serviceGetByUUIDRequest& serviceGetByUUIDRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

serviceGetByUUIDRequest* serviceGetByUUIDRequest::default_instance_ = NULL;

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

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

bool serviceGetByUUIDRequest::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 name = 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_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().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 serviceGetByUUIDRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->name(), output);
  }

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

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

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

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

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

  }
  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 serviceGetByUUIDRequest::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const serviceGetByUUIDRequest* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const serviceGetByUUIDRequest*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void serviceGetByUUIDRequest::MergeFrom(const serviceGetByUUIDRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void serviceGetByUUIDRequest::Swap(serviceGetByUUIDRequest* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    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 serviceGetByUUIDRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = serviceGetByUUIDRequest_descriptor_;
  metadata.reflection = serviceGetByUUIDRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int serviceGetByTypeRequest::kTypeFieldNumber;
#endif  // !_MSC_VER

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

void serviceGetByTypeRequest::InitAsDefaultInstance() {
}

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

void serviceGetByTypeRequest::SharedCtor() {
  _cached_size_ = 0;
  type_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void serviceGetByTypeRequest::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const serviceGetByTypeRequest& serviceGetByTypeRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

serviceGetByTypeRequest* serviceGetByTypeRequest::default_instance_ = NULL;

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

void serviceGetByTypeRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    type_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool serviceGetByTypeRequest::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.ServiceType 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::ServiceType_IsValid(value)) {
            set_type(static_cast< ::xtreemfs::pbrpc::ServiceType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } 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 serviceGetByTypeRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.ServiceType type = 1;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

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

::google::protobuf::uint8* serviceGetByTypeRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.ServiceType type = 1;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

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

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

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

  }
  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 serviceGetByTypeRequest::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const serviceGetByTypeRequest* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const serviceGetByTypeRequest*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void serviceGetByTypeRequest::MergeFrom(const serviceGetByTypeRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_type()) {
      set_type(from.type());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void serviceGetByTypeRequest::Swap(serviceGetByTypeRequest* other) {
  if (other != this) {
    std::swap(type_, other->type_);
    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 serviceGetByTypeRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = serviceGetByTypeRequest_descriptor_;
  metadata.reflection = serviceGetByTypeRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int serviceRegisterRequest::kServiceFieldNumber;
#endif  // !_MSC_VER

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

void serviceRegisterRequest::InitAsDefaultInstance() {
  service_ = const_cast< ::xtreemfs::pbrpc::Service*>(&::xtreemfs::pbrpc::Service::default_instance());
}

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

void serviceRegisterRequest::SharedCtor() {
  _cached_size_ = 0;
  service_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void serviceRegisterRequest::SharedDtor() {
  if (this != default_instance_) {
    delete service_;
  }
}

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

const serviceRegisterRequest& serviceRegisterRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

serviceRegisterRequest* serviceRegisterRequest::default_instance_ = NULL;

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

void serviceRegisterRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_service()) {
      if (service_ != NULL) service_->::xtreemfs::pbrpc::Service::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool serviceRegisterRequest::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.Service service = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_service()));
        } 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 serviceRegisterRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .xtreemfs.pbrpc.Service service = 1;
  if (has_service()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->service(), output);
  }

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

::google::protobuf::uint8* serviceRegisterRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .xtreemfs.pbrpc.Service service = 1;
  if (has_service()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->service(), target);
  }

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

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

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

  }
  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 serviceRegisterRequest::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const serviceRegisterRequest* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const serviceRegisterRequest*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void serviceRegisterRequest::MergeFrom(const serviceRegisterRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_service()) {
      mutable_service()->::xtreemfs::pbrpc::Service::MergeFrom(from.service());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  if (has_service()) {
    if (!this->service().IsInitialized()) return false;
  }
  return true;
}

void serviceRegisterRequest::Swap(serviceRegisterRequest* other) {
  if (other != this) {
    std::swap(service_, other->service_);
    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 serviceRegisterRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = serviceRegisterRequest_descriptor_;
  metadata.reflection = serviceRegisterRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int serviceRegisterResponse::kNewVersionFieldNumber;
#endif  // !_MSC_VER

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

void serviceRegisterResponse::InitAsDefaultInstance() {
}

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

void serviceRegisterResponse::SharedCtor() {
  _cached_size_ = 0;
  new_version_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void serviceRegisterResponse::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const serviceRegisterResponse& serviceRegisterResponse::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

serviceRegisterResponse* serviceRegisterResponse::default_instance_ = NULL;

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

void serviceRegisterResponse::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    new_version_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool serviceRegisterResponse::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 fixed64 new_version = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &new_version_)));
          set_has_new_version();
        } 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 serviceRegisterResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required fixed64 new_version = 1;
  if (has_new_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->new_version(), output);
  }

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

::google::protobuf::uint8* serviceRegisterResponse::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required fixed64 new_version = 1;
  if (has_new_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->new_version(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required fixed64 new_version = 1;
    if (has_new_version()) {
      total_size += 1 + 8;
    }

  }
  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 serviceRegisterResponse::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const serviceRegisterResponse* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const serviceRegisterResponse*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void serviceRegisterResponse::MergeFrom(const serviceRegisterResponse& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_new_version()) {
      set_new_version(from.new_version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void serviceRegisterResponse::Swap(serviceRegisterResponse* other) {
  if (other != this) {
    std::swap(new_version_, other->new_version_);
    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 serviceRegisterResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = serviceRegisterResponse_descriptor_;
  metadata.reflection = serviceRegisterResponse_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int configurationGetRequest::kUuidFieldNumber;
#endif  // !_MSC_VER

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

void configurationGetRequest::InitAsDefaultInstance() {
}

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

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

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

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

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

const configurationGetRequest& configurationGetRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

configurationGetRequest* configurationGetRequest::default_instance_ = NULL;

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

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

bool configurationGetRequest::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 uuid = 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_uuid()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->uuid().data(), this->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 configurationGetRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string uuid = 1;
  if (has_uuid()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->uuid().data(), this->uuid().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->uuid(), output);
  }

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

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

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string uuid = 1;
    if (has_uuid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->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 configurationGetRequest::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const configurationGetRequest* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const configurationGetRequest*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void configurationGetRequest::MergeFrom(const configurationGetRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_uuid()) {
      set_uuid(from.uuid());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void configurationGetRequest::Swap(configurationGetRequest* other) {
  if (other != this) {
    std::swap(uuid_, other->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 configurationGetRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = configurationGetRequest_descriptor_;
  metadata.reflection = configurationGetRequest_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int configurationSetResponse::kNewVersionFieldNumber;
#endif  // !_MSC_VER

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

void configurationSetResponse::InitAsDefaultInstance() {
}

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

void configurationSetResponse::SharedCtor() {
  _cached_size_ = 0;
  new_version_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void configurationSetResponse::SharedDtor() {
  if (this != default_instance_) {
  }
}

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

const configurationSetResponse& configurationSetResponse::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_xtreemfs_2fDIR_2eproto();
  return *default_instance_;
}

configurationSetResponse* configurationSetResponse::default_instance_ = NULL;

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

void configurationSetResponse::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    new_version_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool configurationSetResponse::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)) {
      // optional fixed64 new_version = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &new_version_)));
          set_has_new_version();
        } 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 configurationSetResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional fixed64 new_version = 1;
  if (has_new_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->new_version(), output);
  }

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

::google::protobuf::uint8* configurationSetResponse::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional fixed64 new_version = 1;
  if (has_new_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->new_version(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional fixed64 new_version = 1;
    if (has_new_version()) {
      total_size += 1 + 8;
    }

  }
  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 configurationSetResponse::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const configurationSetResponse* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const configurationSetResponse*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void configurationSetResponse::MergeFrom(const configurationSetResponse& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_new_version()) {
      set_new_version(from.new_version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool configurationSetResponse::IsInitialized() const {

  return true;
}

void configurationSetResponse::Swap(configurationSetResponse* other) {
  if (other != this) {
    std::swap(new_version_, other->new_version_);
    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 configurationSetResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = configurationSetResponse_descriptor_;
  metadata.reflection = configurationSetResponse_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace pbrpc
}  // namespace xtreemfs

// @@protoc_insertion_point(global_scope)